kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

ThreadShield

Browse source 
* thread.c (ThreadShield): rename from Barrier.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@36320 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
nobu 2012-07-05 07:00:29 +00:00
parent 6b801ac9f8
commit 51f458d4db
4 changed files with 53 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
ChangeLog
View file

@ -1,3 +1,7 @@
Thu Jul 5 16:00:24 2012 Nobuyoshi Nakada <nobu@ruby-lang.org>
* thread.c (ThreadShield): rename from Barrier.
Thu Jul 5 15:14:50 2012 Nobuyoshi Nakada <nobu@ruby-lang.org>
* bootstraptest/runner.rb (show_progress): refine error output. do not

8
include/ruby/intern.h
View file

@ -835,10 +835,10 @@ VALUE rb_mutex_lock(VALUE mutex);
VALUE rb_mutex_unlock(VALUE mutex);
VALUE rb_mutex_sleep(VALUE self, VALUE timeout);
VALUE rb_mutex_synchronize(VALUE mutex, VALUE (*func)(VALUE arg), VALUE arg);
VALUE rb_barrier_new(void);
VALUE rb_barrier_wait(VALUE self);
VALUE rb_barrier_release(VALUE self);
VALUE rb_barrier_destroy(VALUE self);
VALUE rb_thread_shield_new(void);
VALUE rb_thread_shield_wait(VALUE self);
VALUE rb_thread_shield_release(VALUE self);
VALUE rb_thread_shield_destroy(VALUE self);
/* time.c */
VALUE rb_time_new(time_t, long);
VALUE rb_time_nano_new(time_t, long);

12
load.c
View file

@ -398,7 +398,7 @@ load_lock(const char *ftptr)
}
/* partial state */
ftptr = ruby_strdup(ftptr);
data = (st_data_t)rb_barrier_new();
data = (st_data_t)rb_thread_shield_new();
st_insert(loading_tbl, (st_data_t)ftptr, data);
return (char *)ftptr;
}
@ -406,7 +406,7 @@ load_lock(const char *ftptr)
rb_warning("loading in progress, circular require considered harmful - %s", ftptr);
rb_backtrace();
}
switch (rb_barrier_wait((VALUE)data)) {
switch (rb_thread_shield_wait((VALUE)data)) {
case Qfalse:
data = (st_data_t)ftptr;
st_delete(loading_tbl, &data, 0);
@ -418,11 +418,11 @@ load_lock(const char *ftptr)
}
static int
release_barrier(st_data_t *key, st_data_t *value, st_data_t done, int existing)
release_thread_shield(st_data_t *key, st_data_t *value, st_data_t done, int existing)
{
VALUE barrier = (VALUE)*value;
VALUE thread_shield = (VALUE)*value;
if (!existing) return ST_STOP;
if (done ? rb_barrier_destroy(barrier) : rb_barrier_release(barrier)) {
if (done ? rb_thread_shield_destroy(thread_shield) : rb_thread_shield_release(thread_shield)) {
/* still in-use */
return ST_CONTINUE;
}
@ -437,7 +437,7 @@ load_unlock(const char *ftptr, int done)
st_data_t key = (st_data_t)ftptr;
st_table *loading_tbl = get_loading_table();
st_update(loading_tbl, key, release_barrier, done);
st_update(loading_tbl, key, release_thread_shield, done);
}
}

78
thread.c
View file

@ -60,7 +60,7 @@
#endif
VALUE rb_cMutex;
VALUE rb_cBarrier;
VALUE rb_cThreadShield;
static void sleep_timeval(rb_thread_t *th, struct timeval time);
static void sleep_wait_for_interrupt(rb_thread_t *th, double sleepsec);
@ -3700,96 +3700,96 @@ rb_mutex_synchronize(VALUE mutex, VALUE (*func)(VALUE arg), VALUE arg)
}
/*
* Document-class: Barrier
* Document-class: ThreadShield
*/
static void
barrier_mark(void *ptr)
thread_shield_mark(void *ptr)
{
rb_gc_mark((VALUE)ptr);
}
static const rb_data_type_t barrier_data_type = {
"barrier",
{barrier_mark, 0, 0,},
static const rb_data_type_t thread_shield_data_type = {
"thread_shield",
{thread_shield_mark, 0, 0,},
};
static VALUE
barrier_alloc(VALUE klass)
thread_shield_alloc(VALUE klass)
{
return TypedData_Wrap_Struct(klass, &barrier_data_type, (void *)mutex_alloc(0));
return TypedData_Wrap_Struct(klass, &thread_shield_data_type, (void *)mutex_alloc(0));
}
#define GetBarrierPtr(obj) ((VALUE)rb_check_typeddata((obj), &barrier_data_type))
#define BARRIER_WAITING_MASK (FL_USER0|FL_USER1|FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6|FL_USER7|FL_USER8|FL_USER9|FL_USER10|FL_USER11|FL_USER12|FL_USER13|FL_USER14|FL_USER15|FL_USER16|FL_USER17|FL_USER18|FL_USER19)
#define BARRIER_WAITING_SHIFT (FL_USHIFT)
#define rb_barrier_waiting(b) (int)((RBASIC(b)->flags&BARRIER_WAITING_MASK)>>BARRIER_WAITING_SHIFT)
#define rb_barrier_waiting_inc(b) do { \
int w = rb_barrier_waiting(b); \
#define GetThreadShieldPtr(obj) ((VALUE)rb_check_typeddata((obj), &thread_shield_data_type))
#define THREAD_SHIELD_WAITING_MASK (FL_USER0|FL_USER1|FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6|FL_USER7|FL_USER8|FL_USER9|FL_USER10|FL_USER11|FL_USER12|FL_USER13|FL_USER14|FL_USER15|FL_USER16|FL_USER17|FL_USER18|FL_USER19)
#define THREAD_SHIELD_WAITING_SHIFT (FL_USHIFT)
#define rb_thread_shield_waiting(b) (int)((RBASIC(b)->flags&THREAD_SHIELD_WAITING_MASK)>>THREAD_SHIELD_WAITING_SHIFT)
#define rb_thread_shield_waiting_inc(b) do { \
int w = rb_thread_shield_waiting(b); \
w++; \
RBASIC(b)->flags &= ~BARRIER_WAITING_MASK; \
RBASIC(b)->flags |= ((VALUE)w << BARRIER_WAITING_SHIFT); \
RBASIC(b)->flags &= ~THREAD_SHIELD_WAITING_MASK; \
RBASIC(b)->flags |= ((VALUE)w << THREAD_SHIELD_WAITING_SHIFT); \
} while (0)
#define rb_barrier_waiting_dec(b) do { \
int w = rb_barrier_waiting(b); \
#define rb_thread_shield_waiting_dec(b) do { \
int w = rb_thread_shield_waiting(b); \
w--; \
RBASIC(b)->flags &= ~BARRIER_WAITING_MASK; \
RBASIC(b)->flags |= ((VALUE)w << BARRIER_WAITING_SHIFT); \
RBASIC(b)->flags &= ~THREAD_SHIELD_WAITING_MASK; \
RBASIC(b)->flags |= ((VALUE)w << THREAD_SHIELD_WAITING_SHIFT); \
} while (0)
VALUE
rb_barrier_new(void)
rb_thread_shield_new(void)
{
VALUE barrier = barrier_alloc(rb_cBarrier);
rb_mutex_lock((VALUE)DATA_PTR(barrier));
return barrier;
VALUE thread_shield = thread_shield_alloc(rb_cThreadShield);
rb_mutex_lock((VALUE)DATA_PTR(thread_shield));
return thread_shield;
}
/*
* Wait a barrier.
* Wait a thread shield.
*
* Returns
* true: acquired the barrier
* false: the barrier was destroyed and no other threads waiting
* nil: the barrier was destroyed but still in use
* true: acquired the thread shield
* false: the thread shield was destroyed and no other threads waiting
* nil: the thread shield was destroyed but still in use
*/
VALUE
rb_barrier_wait(VALUE self)
rb_thread_shield_wait(VALUE self)
{
VALUE mutex = GetBarrierPtr(self);
VALUE mutex = GetThreadShieldPtr(self);
rb_mutex_t *m;
if (!mutex) return Qfalse;
GetMutexPtr(mutex, m);
if (m->th == GET_THREAD()) return Qnil;
rb_barrier_waiting_inc(self);
rb_thread_shield_waiting_inc(self);
rb_mutex_lock(mutex);
rb_barrier_waiting_dec(self);
rb_thread_shield_waiting_dec(self);
if (DATA_PTR(self)) return Qtrue;
rb_mutex_unlock(mutex);
return rb_barrier_waiting(self) > 0 ? Qnil : Qfalse;
return rb_thread_shield_waiting(self) > 0 ? Qnil : Qfalse;
}
/*
* Release a barrrier, and return true if it has waiting threads.
*/
VALUE
rb_barrier_release(VALUE self)
rb_thread_shield_release(VALUE self)
{
VALUE mutex = GetBarrierPtr(self);
VALUE mutex = GetThreadShieldPtr(self);
rb_mutex_unlock(mutex);
return rb_barrier_waiting(self) > 0 ? Qtrue : Qfalse;
return rb_thread_shield_waiting(self) > 0 ? Qtrue : Qfalse;
}
/*
* Release and destroy a barrrier, and return true if it has waiting threads.
*/
VALUE
rb_barrier_destroy(VALUE self)
rb_thread_shield_destroy(VALUE self)
{
VALUE mutex = GetBarrierPtr(self);
VALUE mutex = GetThreadShieldPtr(self);
DATA_PTR(self) = 0;
rb_mutex_unlock(mutex);
return rb_barrier_waiting(self) > 0 ? Qtrue : Qfalse;
return rb_thread_shield_waiting(self) > 0 ? Qtrue : Qfalse;
}
/* variables for recursive traversals */