diff options
-rw-r--r-- | ChangeLog | 7 | ||||
-rw-r--r-- | ext/thread/extconf.rb | 5 | ||||
-rw-r--r-- | ext/thread/thread.c | 1198 |
3 files changed, 514 insertions, 696 deletions
@@ -1,3 +1,10 @@ +Fri Feb 9 20:44:53 2007 Akinori MUSHA <knu@iDaemons.org> + + * ext/thread: Make style fixes (mostly de-K&R'ism) to match the + rest of the source code. + + * ext/thread: Make USE_MEM_POOLS an extconf option. + Fri Feb 9 20:43:01 2007 Akinori MUSHA <knu@iDaemons.org> * ext/thread: Import the "fastthread" implementation by MenTaLguY diff --git a/ext/thread/extconf.rb b/ext/thread/extconf.rb index f83dacae39..efe1d5dbe5 100644 --- a/ext/thread/extconf.rb +++ b/ext/thread/extconf.rb @@ -1,2 +1,7 @@ require 'mkmf' + +if with_config('mem-pools', true) + $CPPFLAGS << ' -DUSE_MEM_POOLS' +end + create_makefile("thread") diff --git a/ext/thread/thread.c b/ext/thread/thread.c index d4443ba9ac..1ca5ee6dca 100644 --- a/ext/thread/thread.c +++ b/ext/thread/thread.c @@ -13,249 +13,199 @@ #include <intern.h> #include <rubysig.h> -#define USE_MEM_POOLS 1 - static VALUE rb_cMutex; static VALUE rb_cConditionVariable; static VALUE rb_cQueue; static VALUE rb_cSizedQueue; static VALUE -return_value(value) - VALUE value; +return_value(VALUE value) { - return value; + return value; } typedef struct _Entry { - VALUE value; - struct _Entry *next; + VALUE value; + struct _Entry *next; } Entry; typedef struct _List { - Entry *entries; - Entry *last_entry; - Entry *entry_pool; - unsigned long size; + Entry *entries; + Entry *last_entry; + Entry *entry_pool; + unsigned long size; } List; -static void init_list _((List *)); - static void -init_list(list) - List *list; +init_list(List *list) { - list->entries = NULL; - list->last_entry = NULL; - list->entry_pool = NULL; - list->size = 0; + list->entries = NULL; + list->last_entry = NULL; + list->entry_pool = NULL; + list->size = 0; } -static void mark_list _((List *)); - static void -mark_list(list) - List *list; +mark_list(List *list) { - Entry *entry; - for ( entry = list->entries ; entry ; entry = entry->next ) { - rb_gc_mark(entry->value); - } + Entry *entry; + for (entry = list->entries; entry; entry = entry->next) { + rb_gc_mark(entry->value); + } } -static void free_entries _((Entry *)); - static void -free_entries(first) - Entry *first; +free_entries(Entry *first) { - Entry *next; - while (first) { - next = first->next; - free(first); - first = next; - } + Entry *next; + while (first) { + next = first->next; + free(first); + first = next; + } } -static void finalize_list _((List *)); - static void -finalize_list(list) - List *list; +finalize_list(List *list) { - free_entries(list->entries); - free_entries(list->entry_pool); + free_entries(list->entries); + free_entries(list->entry_pool); } -static void push_list _((List *, VALUE)); - static void -push_list(list, value) - List *list; - VALUE value; +push_list(List *list, VALUE value) { - Entry *entry; - - if (list->entry_pool) { - entry = list->entry_pool; - list->entry_pool = entry->next; - } else { - entry = (Entry *)malloc(sizeof(Entry)); - } - - entry->value = value; - entry->next = NULL; - - if (list->last_entry) { - list->last_entry->next = entry; - } else { - list->entries = entry; - } - list->last_entry = entry; - - ++list->size; -} + Entry *entry; + + if (list->entry_pool) { + entry = list->entry_pool; + list->entry_pool = entry->next; + } else { + entry = (Entry *)malloc(sizeof(Entry)); + } + + entry->value = value; + entry->next = NULL; -static void push_multiple_list _((List *, VALUE *, unsigned)); + if (list->last_entry) { + list->last_entry->next = entry; + } else { + list->entries = entry; + } + list->last_entry = entry; + + ++list->size; +} static void -push_multiple_list(list, values, count) - List *list; - VALUE *values; - unsigned count; +push_multiple_list(List *list, VALUE *values, unsigned count) { - unsigned i; - for ( i = 0 ; i < count ; i++ ) { - push_list(list, values[i]); - } + unsigned i; + for (i = 0; i < count; i++) { + push_list(list, values[i]); + } } -static VALUE shift_list _((List *)); - static VALUE -shift_list(list) - List *list; +shift_list(List *list) { - Entry *entry; - VALUE value; + Entry *entry; + VALUE value; - entry = list->entries; - if (!entry) return Qundef; + entry = list->entries; + if (!entry) return Qundef; - list->entries = entry->next; - if ( entry == list->last_entry ) { - list->last_entry = NULL; - } + list->entries = entry->next; + if (entry == list->last_entry) { + list->last_entry = NULL; + } - --list->size; + --list->size; - value = entry->value; - if (USE_MEM_POOLS) { + value = entry->value; +#ifdef USE_MEM_POOLS entry->next = list->entry_pool; list->entry_pool = entry; - } else { +#else free(entry); - } +#endif - return value; + return value; } -static void clear_list _((List *)); - static void -clear_list(list) - List *list; +clear_list(List *list) { - if (list->last_entry) { - if (USE_MEM_POOLS) { - list->last_entry->next = list->entry_pool; - list->entry_pool = list->entries; - } else { - free_entries(list->entries); + if (list->last_entry) { +#ifdef USE_MEM_POOLS + list->last_entry->next = list->entry_pool; + list->entry_pool = list->entries; +#else + free_entries(list->entries); +#endif + list->entries = NULL; + list->last_entry = NULL; + list->size = 0; } - list->entries = NULL; - list->last_entry = NULL; - list->size = 0; - } } -static VALUE array_from_list _((List const *)); - static VALUE -array_from_list(list) - List const *list; +array_from_list(List const *list) { - VALUE ary; - Entry *entry; - ary = rb_ary_new(); - for ( entry = list->entries ; entry ; entry = entry->next ) { - rb_ary_push(ary, entry->value); - } - return ary; + VALUE ary; + Entry *entry; + ary = rb_ary_new(); + for (entry = list->entries; entry; entry = entry->next) { + rb_ary_push(ary, entry->value); + } + return ary; } -static VALUE wake_thread _((VALUE)); - static VALUE -wake_thread(thread) - VALUE thread; +wake_thread(VALUE thread) { - return rb_rescue2(rb_thread_wakeup, thread, - return_value, Qnil, rb_eThreadError, 0); + return rb_rescue2(rb_thread_wakeup, thread, + return_value, Qnil, rb_eThreadError, 0); } -static VALUE run_thread _((VALUE)); - static VALUE -run_thread(thread) - VALUE thread; +run_thread(VALUE thread) { - return rb_rescue2(rb_thread_run, thread, - return_value, Qnil, rb_eThreadError, 0); + return rb_rescue2(rb_thread_run, thread, + return_value, Qnil, rb_eThreadError, 0); } -static VALUE wake_one _((List *)); - static VALUE -wake_one(list) - List *list; +wake_one(List *list) { - VALUE waking; + VALUE waking; - waking = Qnil; - while ( list->entries && !RTEST(waking) ) { - waking = wake_thread(shift_list(list)); - } + waking = Qnil; + while (list->entries && !RTEST(waking)) { + waking = wake_thread(shift_list(list)); + } - return waking; + return waking; } -static VALUE wake_all _((List *)); - static VALUE -wake_all(list) - List *list; +wake_all(List *list) { - while (list->entries) { - wake_one(list); - } - return Qnil; + while (list->entries) { + wake_one(list); + } + return Qnil; } -static void assert_no_survivors _((List *, const char *, void *)); - static void -assert_no_survivors(waiting, label, addr) - List *waiting; - const char *label; - void *addr; +assert_no_survivors(List *waiting, const char *label, void *addr) { - Entry *entry; - for ( entry = waiting->entries ; entry ; entry = entry->next ) { - if (RTEST(wake_thread(entry->value))) { - rb_bug("%s %p freed with live thread(s) waiting", label, addr); + Entry *entry; + for (entry = waiting->entries; entry; entry = entry->next) { + if (RTEST(wake_thread(entry->value))) { + rb_bug("%s %p freed with live thread(s) waiting", label, addr); + } } - } } /* @@ -284,48 +234,36 @@ assert_no_survivors(waiting, label, addr) */ typedef struct _Mutex { - VALUE owner; - List waiting; + VALUE owner; + List waiting; } Mutex; -static void mark_mutex _((Mutex *)); - static void -mark_mutex(mutex) - Mutex *mutex; +mark_mutex(Mutex *mutex) { - rb_gc_mark(mutex->owner); - mark_list(&mutex->waiting); + rb_gc_mark(mutex->owner); + mark_list(&mutex->waiting); } -static void finalize_mutex _((Mutex *)); - static void -finalize_mutex(mutex) - Mutex *mutex; +finalize_mutex(Mutex *mutex) { - finalize_list(&mutex->waiting); + finalize_list(&mutex->waiting); } -static void free_mutex _((Mutex *)); - static void -free_mutex(mutex) - Mutex *mutex; +free_mutex(Mutex *mutex) { - assert_no_survivors(&mutex->waiting, "mutex", mutex); - finalize_mutex(mutex); - free(mutex); + assert_no_survivors(&mutex->waiting, "mutex", mutex); + finalize_mutex(mutex); + free(mutex); } -static void init_mutex _((Mutex *)); - static void -init_mutex(mutex) - Mutex *mutex; +init_mutex(Mutex *mutex) { - mutex->owner = Qnil; - init_list(&mutex->waiting); + mutex->owner = Qnil; + init_list(&mutex->waiting); } /* @@ -336,16 +274,13 @@ init_mutex(mutex) * */ -static VALUE rb_mutex_alloc _((VALUE)); - static VALUE -rb_mutex_alloc(klass) - VALUE klass; +rb_mutex_alloc(VALUE klass) { - Mutex *mutex; - mutex = (Mutex *)malloc(sizeof(Mutex)); - init_mutex(mutex); - return Data_Wrap_Struct(klass, mark_mutex, free_mutex, mutex); + Mutex *mutex; + mutex = (Mutex *)malloc(sizeof(Mutex)); + init_mutex(mutex); + return Data_Wrap_Struct(klass, mark_mutex, free_mutex, mutex); } /* @@ -356,15 +291,12 @@ rb_mutex_alloc(klass) * */ -static VALUE rb_mutex_locked_p _((VALUE)); - static VALUE -rb_mutex_locked_p(self) - VALUE self; +rb_mutex_locked_p(VALUE self) { - Mutex *mutex; - Data_Get_Struct(self, Mutex, mutex); - return ( RTEST(mutex->owner) ? Qtrue : Qfalse ); + Mutex *mutex; + Data_Get_Struct(self, Mutex, mutex); + return RTEST(mutex->owner) ? Qtrue : Qfalse; } /* @@ -376,27 +308,24 @@ rb_mutex_locked_p(self) * */ -static VALUE rb_mutex_try_lock _((VALUE)); - static VALUE -rb_mutex_try_lock(self) - VALUE self; +rb_mutex_try_lock(VALUE self) { - Mutex *mutex; - VALUE result; + Mutex *mutex; + VALUE result; - Data_Get_Struct(self, Mutex, mutex); + Data_Get_Struct(self, Mutex, mutex); - result = Qfalse; + result = Qfalse; - rb_thread_critical = 1; - if (!RTEST(mutex->owner)) { - mutex->owner = rb_thread_current(); - result = Qtrue; - } - rb_thread_critical = 0; + rb_thread_critical = 1; + if (!RTEST(mutex->owner)) { + mutex->owner = rb_thread_current(); + result = Qtrue; + } + rb_thread_critical = 0; - return result; + return result; } /* @@ -407,38 +336,32 @@ rb_mutex_try_lock(self) * */ -static void lock_mutex _((Mutex *)); - static void -lock_mutex(mutex) - Mutex *mutex; +lock_mutex(Mutex *mutex) { - VALUE current; - current = rb_thread_current(); + VALUE current; + current = rb_thread_current(); - rb_thread_critical = 1; + rb_thread_critical = 1; - while (RTEST(mutex->owner)) { - push_list(&mutex->waiting, current); - rb_thread_stop(); + while (RTEST(mutex->owner)) { + push_list(&mutex->waiting, current); + rb_thread_stop(); - rb_thread_critical = 1; - } - mutex->owner = current; + rb_thread_critical = 1; + } + mutex->owner = current; - rb_thread_critical = 0; + rb_thread_critical = 0; } -static VALUE rb_mutex_lock _((VALUE)); - static VALUE -rb_mutex_lock(self) - VALUE self; +rb_mutex_lock(VALUE self) { - Mutex *mutex; - Data_Get_Struct(self, Mutex, mutex); - lock_mutex(mutex); - return self; + Mutex *mutex; + Data_Get_Struct(self, Mutex, mutex); + lock_mutex(mutex); + return self; } /* @@ -448,69 +371,57 @@ rb_mutex_lock(self) * */ -static VALUE unlock_mutex_inner _((Mutex *)); - static VALUE -unlock_mutex_inner(mutex) - Mutex *mutex; +unlock_mutex_inner(Mutex *mutex) { - VALUE waking; + VALUE waking; - if (!RTEST(mutex->owner)) { - return Qundef; - } - mutex->owner = Qnil; - waking = wake_one(&mutex->waiting); + if (!RTEST(mutex->owner)) { + return Qundef; + } + mutex->owner = Qnil; + waking = wake_one(&mutex->waiting); - return waking; + return waking; } -static VALUE set_critical _((VALUE)); - static VALUE -set_critical(value) - VALUE value; +set_critical(VALUE value) { - rb_thread_critical = (int)value; - return Qnil; + rb_thread_critical = (int)value; + return Qnil; } -static VALUE unlock_mutex _((Mutex *)); - static VALUE -unlock_mutex(mutex) - Mutex *mutex; +unlock_mutex(Mutex *mutex) { - VALUE waking; + VALUE waking; - rb_thread_critical = 1; - waking = rb_ensure(unlock_mutex_inner, (VALUE)mutex, set_critical, 0); + rb_thread_critical = 1; + waking = rb_ensure(unlock_mutex_inner, (VALUE)mutex, set_critical, 0); - if ( waking == Qundef ) { - return Qfalse; - } + if (waking == Qundef) { + return Qfalse; + } - if (RTEST(waking)) { - run_thread(waking); - } + if (RTEST(waking)) { + run_thread(waking); + } - return Qtrue; + return Qtrue; } -static VALUE rb_mutex_unlock _((VALUE)); - static VALUE -rb_mutex_unlock(self) - VALUE self; +rb_mutex_unlock(VALUE self) { - Mutex *mutex; - Data_Get_Struct(self, Mutex, mutex); + Mutex *mutex; + Data_Get_Struct(self, Mutex, mutex); - if (RTEST(unlock_mutex(mutex))) { - return self; - } else { - return Qnil; - } + if (RTEST(unlock_mutex(mutex))) { + return self; + } else { + return Qnil; + } } /* @@ -522,40 +433,34 @@ rb_mutex_unlock(self) * */ -static VALUE rb_mutex_exclusive_unlock_inner _((Mutex *)); - static VALUE -rb_mutex_exclusive_unlock_inner(mutex) - Mutex *mutex; +rb_mutex_exclusive_unlock_inner(Mutex *mutex) { - VALUE waking; - waking = unlock_mutex_inner(mutex); - rb_yield(Qundef); - return waking; + VALUE waking; + waking = unlock_mutex_inner(mutex); + rb_yield(Qundef); + return waking; } -static VALUE rb_mutex_exclusive_unlock _((VALUE)); - static VALUE -rb_mutex_exclusive_unlock(self) - VALUE self; +rb_mutex_exclusive_unlock(VALUE self) { - Mutex *mutex; - VALUE waking; - Data_Get_Struct(self, Mutex, mutex); + Mutex *mutex; + VALUE waking; + Data_Get_Struct(self, Mutex, mutex); - rb_thread_critical = 1; - waking = rb_ensure(rb_mutex_exclusive_unlock_inner, (VALUE)mutex, set_critical, 0); + rb_thread_critical = 1; + waking = rb_ensure(rb_mutex_exclusive_unlock_inner, (VALUE)mutex, set_critical, 0); - if ( waking == Qundef ) { - return Qnil; - } + if (waking == Qundef) { + return Qnil; + } - if (RTEST(waking)) { - run_thread(waking); - } + if (RTEST(waking)) { + run_thread(waking); + } - return self; + return self; } /* @@ -567,14 +472,11 @@ rb_mutex_exclusive_unlock(self) * */ -static VALUE rb_mutex_synchronize _((VALUE)); - static VALUE -rb_mutex_synchronize(self) - VALUE self; +rb_mutex_synchronize(VALUE self) { - rb_mutex_lock(self); - return rb_ensure(rb_yield, Qundef, rb_mutex_unlock, self); + rb_mutex_lock(self); + return rb_ensure(rb_yield, Qundef, rb_mutex_unlock, self); } /* @@ -609,45 +511,33 @@ rb_mutex_synchronize(self) */ typedef struct _ConditionVariable { - List waiting; + List waiting; } ConditionVariable; -static void mark_condvar _((ConditionVariable *)); - static void -mark_condvar(condvar) - ConditionVariable *condvar; +mark_condvar(ConditionVariable *condvar) { - mark_list(&condvar->waiting); + mark_list(&condvar->waiting); } -static void finalize_condvar _((ConditionVariable *)); - static void -finalize_condvar(condvar) - ConditionVariable *condvar; +finalize_condvar(ConditionVariable *condvar) { - finalize_list(&condvar->waiting); + finalize_list(&condvar->waiting); } -static void free_condvar _((ConditionVariable *)); - static void -free_condvar(condvar) - ConditionVariable *condvar; +free_condvar(ConditionVariable *condvar) { - assert_no_survivors(&condvar->waiting, "condition variable", condvar); - finalize_condvar(condvar); - free(condvar); + assert_no_survivors(&condvar->waiting, "condition variable", condvar); + finalize_condvar(condvar); + free(condvar); } -static void init_condvar _((ConditionVariable *)); - static void -init_condvar(condvar) - ConditionVariable *condvar; +init_condvar(ConditionVariable *condvar) { - init_list(&condvar->waiting); + init_list(&condvar->waiting); } /* @@ -658,18 +548,15 @@ init_condvar(condvar) * */ -static VALUE rb_condvar_alloc _((VALUE)); - static VALUE -rb_condvar_alloc(klass) - VALUE klass; +rb_condvar_alloc(VALUE klass) { - ConditionVariable *condvar; + ConditionVariable *condvar; - condvar = (ConditionVariable *)malloc(sizeof(ConditionVariable)); - init_condvar(condvar); + condvar = (ConditionVariable *)malloc(sizeof(ConditionVariable)); + init_condvar(condvar); - return Data_Wrap_Struct(klass, mark_condvar, free_condvar, condvar); + return Data_Wrap_Struct(klass, mark_condvar, free_condvar, condvar); } /* @@ -680,79 +567,64 @@ rb_condvar_alloc(klass) * */ -static void wait_condvar _((ConditionVariable *, Mutex *)); - static void -wait_condvar(condvar, mutex) - ConditionVariable *condvar; - Mutex *mutex; +wait_condvar(ConditionVariable *condvar, Mutex *mutex) { - rb_thread_critical = 1; - if (!RTEST(mutex->owner)) { - rb_thread_critical = Qfalse; - return; - } - if ( mutex->owner != rb_thread_current() ) { - rb_thread_critical = Qfalse; - rb_raise(rb_eThreadError, "Not owner"); - } - mutex->owner = Qnil; - push_list(&condvar->waiting, rb_thread_current()); - rb_thread_stop(); - - lock_mutex(mutex); -} + rb_thread_critical = 1; + if (!RTEST(mutex->owner)) { + rb_thread_critical = Qfalse; + return; + } + if (mutex->owner != rb_thread_current()) { + rb_thread_critical = Qfalse; + rb_raise(rb_eThreadError, "Not owner"); + } + mutex->owner = Qnil; + push_list(&condvar->waiting, rb_thread_current()); + rb_thread_stop(); -static VALUE legacy_exclusive_unlock _((VALUE)); + lock_mutex(mutex); +} static VALUE -legacy_exclusive_unlock(mutex) - VALUE mutex; +legacy_exclusive_unlock(VALUE mutex) { - return rb_funcall(mutex, rb_intern("exclusive_unlock"), 0); + return rb_funcall(mutex, rb_intern("exclusive_unlock"), 0); } typedef struct { - ConditionVariable *condvar; - VALUE mutex; + ConditionVariable *condvar; + VALUE mutex; } legacy_wait_args; -static VALUE legacy_wait _((VALUE, legacy_wait_args *)); - static VALUE -legacy_wait(unused, args) - VALUE unused; - legacy_wait_args *args; +legacy_wait(VALUE unused, legacy_wait_args *args) { - push_list(&args->condvar->waiting, rb_thread_current()); - rb_thread_stop(); - rb_funcall(args->mutex, rb_intern("lock"), 0); - return Qnil; + push_list(&args->condvar->waiting, rb_thread_current()); + rb_thread_stop(); + rb_funcall(args->mutex, rb_intern("lock"), 0); + return Qnil; } -static VALUE rb_condvar_wait _((VALUE, VALUE)); - static VALUE -rb_condvar_wait(self, mutex_v) - VALUE self; - VALUE mutex_v; +rb_condvar_wait(VALUE self, VALUE mutex_v) { - ConditionVariable *condvar; - Data_Get_Struct(self, ConditionVariable, condvar); - - if ( CLASS_OF(mutex_v) != rb_cMutex ) { - /* interoperate with legacy mutex */ - legacy_wait_args args; - args.condvar = condvar; - args.mutex = mutex_v; - rb_iterate(legacy_exclusive_unlock, mutex_v, legacy_wait, (VALUE)&args); - } else { - Mutex *mutex; - Data_Get_Struct(mutex_v, Mutex, mutex); - wait_condvar(condvar, mutex); - } + ConditionVariable *condvar; + Data_Get_Struct(self, ConditionVariable, condvar); + + if (CLASS_OF(mutex_v) != rb_cMutex) { + /* interoperate with legacy mutex */ + legacy_wait_args args; + args.condvar = condvar; + args.mutex = mutex_v; + rb_iterate(legacy_exclusive_unlock, mutex_v, legacy_wait, (VALUE)&args); + } else { + Mutex *mutex; + Data_Get_Struct(mutex_v, Mutex, mutex); + wait_condvar(condvar, mutex); + } - return self; + return self; } /* @@ -763,21 +635,18 @@ rb_condvar_wait(self, mutex_v) * */ -static VALUE rb_condvar_broadcast _((VALUE)); - static VALUE -rb_condvar_broadcast(self) - VALUE self; +rb_condvar_broadcast(VALUE self) { - ConditionVariable *condvar; + ConditionVariable *condvar; - Data_Get_Struct(self, ConditionVariable, condvar); + Data_Get_Struct(self, ConditionVariable, condvar); - rb_thread_critical = 1; - rb_ensure(wake_all, (VALUE)&condvar->waiting, set_critical, 0); - rb_thread_schedule(); + rb_thread_critical = 1; + rb_ensure(wake_all, (VALUE)&condvar->waiting, set_critical, 0); + rb_thread_schedule(); - return self; + return self; } /* @@ -788,30 +657,24 @@ rb_condvar_broadcast(self) * */ -static void signal_condvar _((ConditionVariable *condvar)); - static void -signal_condvar(condvar) - ConditionVariable *condvar; +signal_condvar(ConditionVariable *condvar) { - VALUE waking; - rb_thread_critical = 1; - waking = rb_ensure(wake_one, (VALUE)&condvar->waiting, set_critical, 0); - if (RTEST(waking)) { - run_thread(waking); - } + VALUE waking; + rb_thread_critical = 1; + waking = rb_ensure(wake_one, (VALUE)&condvar->waiting, set_critical, 0); + if (RTEST(waking)) { + run_thread(waking); + } } -static VALUE rb_condvar_signal _((VALUE)); - static VALUE -rb_condvar_signal(self) - VALUE self; +rb_condvar_signal(VALUE self) { - ConditionVariable *condvar; - Data_Get_Struct(self, ConditionVariable, condvar); - signal_condvar(condvar); - return self; + ConditionVariable *condvar; + Data_Get_Struct(self, ConditionVariable, condvar); + signal_condvar(condvar); + return self; } /* @@ -846,61 +709,49 @@ rb_condvar_signal(self) */ typedef struct _Queue { - Mutex mutex; - ConditionVariable value_available; - ConditionVariable space_available; - List values; - unsigned long capacity; + Mutex mutex; + ConditionVariable value_available; + ConditionVariable space_available; + List values; + unsigned long capacity; } Queue; -static void mark_queue _((Queue *)); - static void -mark_queue(queue) - Queue *queue; +mark_queue(Queue *queue) { - mark_mutex(&queue->mutex); - mark_condvar(&queue->value_available); - mark_condvar(&queue->space_available); - mark_list(&queue->values); + mark_mutex(&queue->mutex); + mark_condvar(&queue->value_available); + mark_condvar(&queue->space_available); + mark_list(&queue->values); } -static void finalize_queue _((Queue *)); - static void -finalize_queue(queue) - Queue *queue; +finalize_queue(Queue *queue) { - finalize_mutex(&queue->mutex); - finalize_condvar(&queue->value_available); - finalize_condvar(&queue->space_available); - finalize_list(&queue->values); + finalize_mutex(&queue->mutex); + finalize_condvar(&queue->value_available); + finalize_condvar(&queue->space_available); + finalize_list(&queue->values); } -static void free_queue _((Queue *)); - static void -free_queue(queue) - Queue *queue; +free_queue(Queue *queue) { - assert_no_survivors(&queue->mutex.waiting, "queue", queue); - assert_no_survivors(&queue->space_available.waiting, "queue", queue); - assert_no_survivors(&queue->value_available.waiting, "queue", queue); - finalize_queue(queue); - free(queue); + assert_no_survivors(&queue->mutex.waiting, "queue", queue); + assert_no_survivors(&queue->space_available.waiting, "queue", queue); + assert_no_survivors(&queue->value_available.waiting, "queue", queue); + finalize_queue(queue); + free(queue); } -static void init_queue _((Queue *)); - static void -init_queue(queue) - Queue *queue; +init_queue(Queue *queue) { - init_mutex(&queue->mutex); - init_condvar(&queue->value_available); - init_condvar(&queue->space_available); - init_list(&queue->values); - queue->capacity = 0; + init_mutex(&queue->mutex); + init_condvar(&queue->value_available); + init_condvar(&queue->space_available); + init_list(&queue->values); + queue->capacity = 0; } /* @@ -911,55 +762,45 @@ init_queue(queue) * */ -static VALUE rb_queue_alloc _((VALUE)); - static VALUE -rb_queue_alloc(klass) - VALUE klass; +rb_queue_alloc(VALUE klass) { - Queue *queue; - queue = (Queue *)malloc(sizeof(Queue)); - init_queue(queue); - return Data_Wrap_Struct(klass, mark_queue, free_queue, queue); + Queue *queue; + queue = (Queue *)malloc(sizeof(Queue)); + init_queue(queue); + return Data_Wrap_Struct(klass, mark_queue, free_queue, queue); } -static VALUE rb_queue_marshal_load _((VALUE, VALUE)); - static VALUE -rb_queue_marshal_load(self, data) - VALUE self; - VALUE data; +rb_queue_marshal_load(VALUE self, VALUE data) { - Queue *queue; - VALUE array; - Data_Get_Struct(self, Queue, queue); - - array = rb_marshal_load(data); - if ( TYPE(array) != T_ARRAY ) { - rb_raise(rb_eRuntimeError, "expected Array of queue data"); - } - if ( RARRAY(array)->len < 1 ) { - rb_raise(rb_eRuntimeError, "missing capacity value"); - } - queue->capacity = NUM2ULONG(rb_ary_shift(array)); - push_multiple_list(&queue->values, RARRAY(array)->ptr, (unsigned)RARRAY(array)->len); - - return self; -} + Queue *queue; + VALUE array; + Data_Get_Struct(self, Queue, queue); + + array = rb_marshal_load(data); + if (TYPE(array) != T_ARRAY) { + rb_raise(rb_eRuntimeError, "expected Array of queue data"); + } + if (RARRAY(array)->len < 1) { + rb_raise(rb_eRuntimeError, "missing capacity value"); + } + queue->capacity = NUM2ULONG(rb_ary_shift(array)); + push_multiple_list(&queue->values, RARRAY(array)->ptr, (unsigned)RARRAY(array)->len); -static VALUE rb_queue_marshal_dump _((VALUE)); + return self; +} static VALUE -rb_queue_marshal_dump(self) - VALUE self; +rb_queue_marshal_dump(VALUE self) { - Queue *queue; - VALUE array; - Data_Get_Struct(self, Queue, queue); + Queue *queue; + VALUE array; + Data_Get_Struct(self, Queue, queue); - array = array_from_list(&queue->values); - rb_ary_unshift(array, ULONG2NUM(queue->capacity)); - return rb_marshal_dump(array, Qnil); + array = array_from_list(&queue->values); + rb_ary_unshift(array, ULONG2NUM(queue->capacity)); + return rb_marshal_dump(array, Qnil); } /* @@ -970,21 +811,18 @@ rb_queue_marshal_dump(self) * */ -static VALUE rb_queue_clear _((VALUE)); - static VALUE -rb_queue_clear(self) - VALUE self; +rb_queue_clear(VALUE self) { - Queue *queue; - Data_Get_Struct(self, Queue, queue); + Queue *queue; + Data_Get_Struct(self, Queue, queue); - lock_mutex(&queue->mutex); - clear_list(&queue->values); - signal_condvar(&queue->space_available); - unlock_mutex(&queue->mutex); + lock_mutex(&queue->mutex); + clear_list(&queue->values); + signal_condvar(&queue->space_available); + unlock_mutex(&queue->mutex); - return self; + return self; } /* @@ -995,21 +833,18 @@ rb_queue_clear(self) * */ -static VALUE rb_queue_empty_p _((VALUE)); - static VALUE -rb_queue_empty_p(self) - VALUE self; +rb_queue_empty_p(VALUE self) { - Queue *queue; - VALUE result; - Data_Get_Struct(self, Queue, queue); + Queue *queue; + VALUE result; + Data_Get_Struct(self, Queue, queue); - lock_mutex(&queue->mutex); - result = ( ( queue->values.size == 0 ) ? Qtrue : Qfalse ); - unlock_mutex(&queue->mutex); + lock_mutex(&queue->mutex); + result = queue->values.size == 0 ? Qtrue : Qfalse; + unlock_mutex(&queue->mutex); - return result; + return result; } /* @@ -1020,21 +855,18 @@ rb_queue_empty_p(self) * */ -static VALUE rb_queue_length _((VALUE)); - static VALUE -rb_queue_length(self) - VALUE self; +rb_queue_length(VALUE self) { - Queue *queue; - VALUE result; - Data_Get_Struct(self, Queue, queue); + Queue *queue; + VALUE result; + Data_Get_Struct(self, Queue, queue); - lock_mutex(&queue->mutex); - result = ULONG2NUM(queue->values.size); - unlock_mutex(&queue->mutex); + lock_mutex(&queue->mutex); + result = ULONG2NUM(queue->values.size); + unlock_mutex(&queue->mutex); - return result; + return result; } /* @@ -1045,22 +877,19 @@ rb_queue_length(self) * */ -static VALUE rb_queue_num_waiting _((VALUE)); - static VALUE -rb_queue_num_waiting(self) - VALUE self; +rb_queue_num_waiting(VALUE self) { - Queue *queue; - VALUE result; - Data_Get_Struct(self, Queue, queue); + Queue *queue; + VALUE result; + Data_Get_Struct(self, Queue, queue); - lock_mutex(&queue->mutex); - result = ULONG2NUM(queue->value_available.waiting.size + - queue->space_available.waiting.size); - unlock_mutex(&queue->mutex); + lock_mutex(&queue->mutex); + result = ULONG2NUM(queue->value_available.waiting.size + + queue->space_available.waiting.size); + unlock_mutex(&queue->mutex); - return result; + return result; } /* @@ -1073,44 +902,39 @@ rb_queue_num_waiting(self) * */ -static VALUE rb_queue_pop _((int, VALUE *, VALUE)); - static VALUE -rb_queue_pop(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +rb_queue_pop(int argc, VALUE *argv, VALUE self) { - Queue *queue; - int should_block; - VALUE result; - Data_Get_Struct(self, Queue, queue); - - if ( argc == 0 ) { - should_block = 1; - } else if ( argc == 1 ) { - should_block = !RTEST(argv[0]); - } else { - rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); - } - - lock_mutex(&queue->mutex); - if ( !queue->values.entries && !should_block ) { - unlock_mutex(&queue->mutex); - rb_raise(rb_eThreadError, "queue empty"); - } + Queue *queue; + int should_block; + VALUE result; + Data_Get_Struct(self, Queue, queue); + + if (argc == 0) { + should_block = 1; + } else if (argc == 1) { + should_block = !RTEST(argv[0]); + } else { + rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); + } - while (!queue->values.entries) { - wait_condvar(&queue->value_available, &queue->mutex); - } + lock_mutex(&queue->mutex); + if (!queue->values.entries && !should_block) { + unlock_mutex(&queue->mutex); + rb_raise(rb_eThreadError, "queue empty"); + } - result = shift_list(&queue->values); - if ( queue->capacity && queue->values.size < queue->capacity ) { - signal_condvar(&queue->space_available); - } - unlock_mutex(&queue->mutex); + while (!queue->values.entries) { + wait_condvar(&queue->value_available, &queue->mutex); + } - return result; + result = shift_list(&queue->values); + if (queue->capacity && queue->values.size < queue->capacity) { + signal_condvar(&queue->space_available); + } + unlock_mutex(&queue->mutex); + + return result; } /* @@ -1121,25 +945,21 @@ rb_queue_pop(argc, argv, self) * */ -static VALUE rb_queue_push _((VALUE, VALUE)); - static VALUE -rb_queue_push(self, value) - VALUE self; - VALUE value; +rb_queue_push(VALUE self, VALUE value) { - Queue *queue; - Data_Get_Struct(self, Queue, queue); - - lock_mutex(&queue->mutex); - while ( queue->capacity && queue->values.size >= queue->capacity ) { - wait_condvar(&queue->space_available, &queue->mutex); - } - push_list(&queue->values, value); - signal_condvar(&queue->value_available); - unlock_mutex(&queue->mutex); - - return self; + Queue *queue; + Data_Get_Struct(self, Queue, queue); + + lock_mutex(&queue->mutex); + while (queue->capacity && queue->values.size >= queue->capacity) { + wait_condvar(&queue->space_available, &queue->mutex); + } + push_list(&queue->values, value); + signal_condvar(&queue->value_available); + unlock_mutex(&queue->mutex); + + return self; } /* @@ -1168,21 +988,18 @@ rb_queue_push(self, value) * */ -static VALUE rb_sized_queue_max _((VALUE)); - static VALUE -rb_sized_queue_max(self) - VALUE self; +rb_sized_queue_max(VALUE self) { - Queue *queue; - VALUE result; - Data_Get_Struct(self, Queue, queue); + Queue *queue; + VALUE result; + Data_Get_Struct(self, Queue, queue); - lock_mutex(&queue->mutex); - result = ULONG2NUM(queue->capacity); - unlock_mutex(&queue->mutex); + lock_mutex(&queue->mutex); + result = ULONG2NUM(queue->capacity); + unlock_mutex(&queue->mutex); - return result; + return result; } /* @@ -1193,37 +1010,33 @@ rb_sized_queue_max(self) * */ -static VALUE rb_sized_queue_max_set _((VALUE, VALUE)); - static VALUE -rb_sized_queue_max_set(self, value) - VALUE self; - VALUE value; +rb_sized_queue_max_set(VALUE self, VALUE value) { - Queue *queue; - unsigned long new_capacity; - unsigned long difference; - Data_Get_Struct(self, Queue, queue); - - new_capacity = NUM2ULONG(value); - - if ( new_capacity < 1 ) { - rb_raise(rb_eArgError, "value must be positive"); - } - - lock_mutex(&queue->mutex); - if ( queue->capacity && new_capacity > queue->capacity ) { - difference = new_capacity - queue->capacity; - } else { - difference = 0; - } - queue->capacity = new_capacity; - for ( ; difference > 0 ; --difference ) { - signal_condvar(&queue->space_available); - } - unlock_mutex(&queue->mutex); + Queue *queue; + unsigned long new_capacity; + unsigned long difference; + Data_Get_Struct(self, Queue, queue); + + new_capacity = NUM2ULONG(value); + + if (new_capacity < 1) { + rb_raise(rb_eArgError, "value must be positive"); + } + + lock_mutex(&queue->mutex); + if (queue->capacity && new_capacity > queue->capacity) { + difference = new_capacity - queue->capacity; + } else { + difference = 0; + } + queue->capacity = new_capacity; + for (; difference > 0; --difference) { + signal_condvar(&queue->space_available); + } + unlock_mutex(&queue->mutex); - return self; + return self; } /* @@ -1245,74 +1058,67 @@ rb_sized_queue_max_set(self, value) /* for marshalling mutexes and condvars */ -static VALUE dummy_load _((VALUE, VALUE)); - static VALUE -dummy_load(self, string) - VALUE self; - VALUE string; +dummy_load(VALUE self, VALUE string) { - return Qnil; + return Qnil; } -static VALUE dummy_dump _((VALUE)); - static VALUE -dummy_dump(self) - VALUE self; +dummy_dump(VALUE self) { - return rb_str_new2(""); + return rb_str_new2(""); } void -Init_thread() +Init_thread(void) { - rb_cMutex = rb_define_class("Mutex", rb_cObject); - rb_define_alloc_func(rb_cMutex, rb_mutex_alloc); - rb_define_method(rb_cMutex, "marshal_load", dummy_load, 1); - rb_define_method(rb_cMutex, "marshal_dump", dummy_dump, 0); - rb_define_method(rb_cMutex, "initialize", return_value, 0); - rb_define_method(rb_cMutex, "locked?", rb_mutex_locked_p, 0); - rb_define_method(rb_cMutex, "try_lock", rb_mutex_try_lock, 0); - rb_define_method(rb_cMutex, "lock", rb_mutex_lock, 0); - rb_define_method(rb_cMutex, "unlock", rb_mutex_unlock, 0); - rb_define_method(rb_cMutex, "exclusive_unlock", rb_mutex_exclusive_unlock, 0); - rb_define_method(rb_cMutex, "synchronize", rb_mutex_synchronize, 0); - - rb_cConditionVariable = rb_define_class("ConditionVariable", rb_cObject); - rb_define_alloc_func(rb_cConditionVariable, rb_condvar_alloc); - rb_define_method(rb_cConditionVariable, "marshal_load", dummy_load, 1); - rb_define_method(rb_cConditionVariable, "marshal_dump", dummy_dump, 0); - rb_define_method(rb_cConditionVariable, "initialize", return_value, 0); - rb_define_method(rb_cConditionVariable, "wait", rb_condvar_wait, 1); - rb_define_method(rb_cConditionVariable, "broadcast", rb_condvar_broadcast, 0); - rb_define_method(rb_cConditionVariable, "signal", rb_condvar_signal, 0); - - rb_cQueue = rb_define_class("Queue", rb_cObject); - rb_define_alloc_func(rb_cQueue, rb_queue_alloc); - rb_define_method(rb_cQueue, "marshal_load", rb_queue_marshal_load, 1); - rb_define_method(rb_cQueue, "marshal_dump", rb_queue_marshal_dump, 0); - rb_define_method(rb_cQueue, "initialize", return_value, 0); - rb_define_method(rb_cQueue, "clear", rb_queue_clear, 0); - rb_define_method(rb_cQueue, "empty?", rb_queue_empty_p, 0); - rb_define_method(rb_cQueue, "length", rb_queue_length, 0); - rb_define_method(rb_cQueue, "num_waiting", rb_queue_num_waiting, 0); - rb_define_method(rb_cQueue, "pop", rb_queue_pop, -1); - rb_define_method(rb_cQueue, "push", rb_queue_push, 1); - rb_alias(rb_cQueue, rb_intern("<<"), rb_intern("push")); - rb_alias(rb_cQueue, rb_intern("deq"), rb_intern("pop")); - rb_alias(rb_cQueue, rb_intern("shift"), rb_intern("pop")); - rb_alias(rb_cQueue, rb_intern("size"), rb_intern("length")); - - rb_cSizedQueue = rb_define_class("SizedQueue", rb_cQueue); - rb_define_method(rb_cSizedQueue, "initialize", rb_sized_queue_max_set, 1); - rb_define_method(rb_cSizedQueue, "num_waiting", rb_queue_num_waiting, 0); - rb_define_method(rb_cSizedQueue, "pop", rb_queue_pop, -1); - rb_define_method(rb_cSizedQueue, "push", rb_queue_push, 1); - rb_define_method(rb_cSizedQueue, "max", rb_sized_queue_max, 0); - rb_define_method(rb_cSizedQueue, "max=", rb_sized_queue_max_set, 1); - rb_alias(rb_cSizedQueue, rb_intern("<<"), rb_intern("push")); - rb_alias(rb_cSizedQueue, rb_intern("deq"), rb_intern("pop")); - rb_alias(rb_cSizedQueue, rb_intern("shift"), rb_intern("pop")); + rb_cMutex = rb_define_class("Mutex", rb_cObject); + rb_define_alloc_func(rb_cMutex, rb_mutex_alloc); + rb_define_method(rb_cMutex, "marshal_load", dummy_load, 1); + rb_define_method(rb_cMutex, "marshal_dump", dummy_dump, 0); + rb_define_method(rb_cMutex, "initialize", return_value, 0); + rb_define_method(rb_cMutex, "locked?", rb_mutex_locked_p, 0); + rb_define_method(rb_cMutex, "try_lock", rb_mutex_try_lock, 0); + rb_define_method(rb_cMutex, "lock", rb_mutex_lock, 0); + rb_define_method(rb_cMutex, "unlock", rb_mutex_unlock, 0); + rb_define_method(rb_cMutex, "exclusive_unlock", rb_mutex_exclusive_unlock, 0); + rb_define_method(rb_cMutex, "synchronize", rb_mutex_synchronize, 0); + + rb_cConditionVariable = rb_define_class("ConditionVariable", rb_cObject); + rb_define_alloc_func(rb_cConditionVariable, rb_condvar_alloc); + rb_define_method(rb_cConditionVariable, "marshal_load", dummy_load, 1); + rb_define_method(rb_cConditionVariable, "marshal_dump", dummy_dump, 0); + rb_define_method(rb_cConditionVariable, "initialize", return_value, 0); + rb_define_method(rb_cConditionVariable, "wait", rb_condvar_wait, 1); + rb_define_method(rb_cConditionVariable, "broadcast", rb_condvar_broadcast, 0); + rb_define_method(rb_cConditionVariable, "signal", rb_condvar_signal, 0); + + rb_cQueue = rb_define_class("Queue", rb_cObject); + rb_define_alloc_func(rb_cQueue, rb_queue_alloc); + rb_define_method(rb_cQueue, "marshal_load", rb_queue_marshal_load, 1); + rb_define_method(rb_cQueue, "marshal_dump", rb_queue_marshal_dump, 0); + rb_define_method(rb_cQueue, "initialize", return_value, 0); + rb_define_method(rb_cQueue, "clear", rb_queue_clear, 0); + rb_define_method(rb_cQueue, "empty?", rb_queue_empty_p, 0); + rb_define_method(rb_cQueue, "length", rb_queue_length, 0); + rb_define_method(rb_cQueue, "num_waiting", rb_queue_num_waiting, 0); + rb_define_method(rb_cQueue, "pop", rb_queue_pop, -1); + rb_define_method(rb_cQueue, "push", rb_queue_push, 1); + rb_alias(rb_cQueue, rb_intern("<<"), rb_intern("push")); + rb_alias(rb_cQueue, rb_intern("deq"), rb_intern("pop")); + rb_alias(rb_cQueue, rb_intern("shift"), rb_intern("pop")); + rb_alias(rb_cQueue, rb_intern("size"), rb_intern("length")); + + rb_cSizedQueue = rb_define_class("SizedQueue", rb_cQueue); + rb_define_method(rb_cSizedQueue, "initialize", rb_sized_queue_max_set, 1); + rb_define_method(rb_cSizedQueue, "num_waiting", rb_queue_num_waiting, 0); + rb_define_method(rb_cSizedQueue, "pop", rb_queue_pop, -1); + rb_define_method(rb_cSizedQueue, "push", rb_queue_push, 1); + rb_define_method(rb_cSizedQueue, "max", rb_sized_queue_max, 0); + rb_define_method(rb_cSizedQueue, "max=", rb_sized_queue_max_set, 1); + rb_alias(rb_cSizedQueue, rb_intern("<<"), rb_intern("push")); + rb_alias(rb_cSizedQueue, rb_intern("deq"), rb_intern("pop")); + rb_alias(rb_cSizedQueue, rb_intern("shift"), rb_intern("pop")); } |