mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
* 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. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@11679 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
knu
parent
fff0db9dfe
commit
b28988b4f1
3 changed files with 570 additions and 752 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
|
||||
|
|
|
|||
|
|
@ -1,2 +1,7 @@
|
|||
require 'mkmf'
|
||||
|
||||
if with_config('mem-pools', true)
|
||||
$CPPFLAGS << ' -DUSE_MEM_POOLS'
|
||||
end
|
||||
|
||||
create_makefile("thread")
|
||||
|
|
|
|||
|
|
@ -13,16 +13,13 @@
|
|||
#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;
|
||||
}
|
||||
|
|
@ -39,11 +36,8 @@ typedef struct _List {
|
|||
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;
|
||||
|
|
@ -51,11 +45,8 @@ init_list(list)
|
|||
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) {
|
||||
|
|
@ -63,11 +54,8 @@ mark_list(list)
|
|||
}
|
||||
}
|
||||
|
||||
static void free_entries _((Entry *));
|
||||
|
||||
static void
|
||||
free_entries(first)
|
||||
Entry *first;
|
||||
free_entries(Entry *first)
|
||||
{
|
||||
Entry *next;
|
||||
while (first) {
|
||||
|
|
@ -77,22 +65,15 @@ free_entries(first)
|
|||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
static void push_list _((List *, VALUE));
|
||||
|
||||
static void
|
||||
push_list(list, value)
|
||||
List *list;
|
||||
VALUE value;
|
||||
push_list(List *list, VALUE value)
|
||||
{
|
||||
Entry *entry;
|
||||
|
||||
|
|
@ -116,13 +97,8 @@ push_list(list, value)
|
|||
++list->size;
|
||||
}
|
||||
|
||||
static void push_multiple_list _((List *, VALUE *, unsigned));
|
||||
|
||||
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++) {
|
||||
|
|
@ -130,11 +106,8 @@ push_multiple_list(list, values, count)
|
|||
}
|
||||
}
|
||||
|
||||
static VALUE shift_list _((List *));
|
||||
|
||||
static VALUE
|
||||
shift_list(list)
|
||||
List *list;
|
||||
shift_list(List *list)
|
||||
{
|
||||
Entry *entry;
|
||||
VALUE value;
|
||||
|
|
@ -150,40 +123,34 @@ shift_list(list)
|
|||
--list->size;
|
||||
|
||||
value = entry->value;
|
||||
if (USE_MEM_POOLS) {
|
||||
#ifdef USE_MEM_POOLS
|
||||
entry->next = list->entry_pool;
|
||||
list->entry_pool = entry;
|
||||
} else {
|
||||
#else
|
||||
free(entry);
|
||||
}
|
||||
#endif
|
||||
|
||||
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) {
|
||||
#ifdef USE_MEM_POOLS
|
||||
list->last_entry->next = list->entry_pool;
|
||||
list->entry_pool = list->entries;
|
||||
} else {
|
||||
#else
|
||||
free_entries(list->entries);
|
||||
}
|
||||
#endif
|
||||
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;
|
||||
|
|
@ -194,31 +161,22 @@ array_from_list(list)
|
|||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
static VALUE wake_one _((List *));
|
||||
|
||||
static VALUE
|
||||
wake_one(list)
|
||||
List *list;
|
||||
wake_one(List *list)
|
||||
{
|
||||
VALUE waking;
|
||||
|
||||
|
|
@ -230,11 +188,8 @@ wake_one(list)
|
|||
return waking;
|
||||
}
|
||||
|
||||
static VALUE wake_all _((List *));
|
||||
|
||||
static VALUE
|
||||
wake_all(list)
|
||||
List *list;
|
||||
wake_all(List *list)
|
||||
{
|
||||
while (list->entries) {
|
||||
wake_one(list);
|
||||
|
|
@ -242,13 +197,8 @@ wake_all(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) {
|
||||
|
|
@ -288,41 +238,29 @@ typedef struct _Mutex {
|
|||
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);
|
||||
}
|
||||
|
||||
static void finalize_mutex _((Mutex *));
|
||||
|
||||
static void
|
||||
finalize_mutex(mutex)
|
||||
Mutex *mutex;
|
||||
finalize_mutex(Mutex *mutex)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
static void init_mutex _((Mutex *));
|
||||
|
||||
static void
|
||||
init_mutex(mutex)
|
||||
Mutex *mutex;
|
||||
init_mutex(Mutex *mutex)
|
||||
{
|
||||
mutex->owner = Qnil;
|
||||
init_list(&mutex->waiting);
|
||||
|
|
@ -336,11 +274,8 @@ 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));
|
||||
|
|
@ -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 );
|
||||
return RTEST(mutex->owner) ? Qtrue : Qfalse;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -376,11 +308,8 @@ 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;
|
||||
|
|
@ -407,11 +336,8 @@ 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();
|
||||
|
|
@ -429,11 +355,8 @@ lock_mutex(mutex)
|
|||
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);
|
||||
|
|
@ -448,11 +371,8 @@ 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;
|
||||
|
||||
|
|
@ -465,21 +385,15 @@ unlock_mutex_inner(mutex)
|
|||
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;
|
||||
}
|
||||
|
||||
static VALUE unlock_mutex _((Mutex *));
|
||||
|
||||
static VALUE
|
||||
unlock_mutex(mutex)
|
||||
Mutex *mutex;
|
||||
unlock_mutex(Mutex *mutex)
|
||||
{
|
||||
VALUE waking;
|
||||
|
||||
|
|
@ -497,11 +411,8 @@ unlock_mutex(mutex)
|
|||
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);
|
||||
|
|
@ -522,11 +433,8 @@ 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);
|
||||
|
|
@ -534,11 +442,8 @@ rb_mutex_exclusive_unlock_inner(mutex)
|
|||
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;
|
||||
|
|
@ -567,11 +472,8 @@ 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);
|
||||
|
|
@ -612,40 +514,28 @@ typedef struct _ConditionVariable {
|
|||
List waiting;
|
||||
} ConditionVariable;
|
||||
|
||||
static void mark_condvar _((ConditionVariable *));
|
||||
|
||||
static void
|
||||
mark_condvar(condvar)
|
||||
ConditionVariable *condvar;
|
||||
mark_condvar(ConditionVariable *condvar)
|
||||
{
|
||||
mark_list(&condvar->waiting);
|
||||
}
|
||||
|
||||
static void finalize_condvar _((ConditionVariable *));
|
||||
|
||||
static void
|
||||
finalize_condvar(condvar)
|
||||
ConditionVariable *condvar;
|
||||
finalize_condvar(ConditionVariable *condvar)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
static void init_condvar _((ConditionVariable *));
|
||||
|
||||
static void
|
||||
init_condvar(condvar)
|
||||
ConditionVariable *condvar;
|
||||
init_condvar(ConditionVariable *condvar)
|
||||
{
|
||||
init_list(&condvar->waiting);
|
||||
}
|
||||
|
|
@ -658,11 +548,8 @@ init_condvar(condvar)
|
|||
*
|
||||
*/
|
||||
|
||||
static VALUE rb_condvar_alloc _((VALUE));
|
||||
|
||||
static VALUE
|
||||
rb_condvar_alloc(klass)
|
||||
VALUE klass;
|
||||
rb_condvar_alloc(VALUE klass)
|
||||
{
|
||||
ConditionVariable *condvar;
|
||||
|
||||
|
|
@ -680,12 +567,8 @@ 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)) {
|
||||
|
|
@ -703,11 +586,8 @@ wait_condvar(condvar, mutex)
|
|||
lock_mutex(mutex);
|
||||
}
|
||||
|
||||
static VALUE legacy_exclusive_unlock _((VALUE));
|
||||
|
||||
static VALUE
|
||||
legacy_exclusive_unlock(mutex)
|
||||
VALUE mutex;
|
||||
legacy_exclusive_unlock(VALUE mutex)
|
||||
{
|
||||
return rb_funcall(mutex, rb_intern("exclusive_unlock"), 0);
|
||||
}
|
||||
|
|
@ -717,12 +597,8 @@ typedef struct {
|
|||
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();
|
||||
|
|
@ -730,12 +606,8 @@ legacy_wait(unused, args)
|
|||
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);
|
||||
|
|
@ -763,11 +635,8 @@ 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;
|
||||
|
||||
|
|
@ -788,11 +657,8 @@ 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;
|
||||
|
|
@ -802,11 +668,8 @@ signal_condvar(condvar)
|
|||
}
|
||||
}
|
||||
|
||||
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);
|
||||
|
|
@ -853,11 +716,8 @@ typedef struct _Queue {
|
|||
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);
|
||||
|
|
@ -865,11 +725,8 @@ mark_queue(queue)
|
|||
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);
|
||||
|
|
@ -877,11 +734,8 @@ finalize_queue(queue)
|
|||
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);
|
||||
|
|
@ -890,11 +744,8 @@ free_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);
|
||||
|
|
@ -911,11 +762,8 @@ 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));
|
||||
|
|
@ -923,12 +771,8 @@ rb_queue_alloc(klass)
|
|||
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;
|
||||
|
|
@ -947,11 +791,8 @@ rb_queue_marshal_load(self, data)
|
|||
return self;
|
||||
}
|
||||
|
||||
static VALUE rb_queue_marshal_dump _((VALUE));
|
||||
|
||||
static VALUE
|
||||
rb_queue_marshal_dump(self)
|
||||
VALUE self;
|
||||
rb_queue_marshal_dump(VALUE self)
|
||||
{
|
||||
Queue *queue;
|
||||
VALUE array;
|
||||
|
|
@ -970,11 +811,8 @@ 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);
|
||||
|
|
@ -995,18 +833,15 @@ 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);
|
||||
|
||||
lock_mutex(&queue->mutex);
|
||||
result = ( ( queue->values.size == 0 ) ? Qtrue : Qfalse );
|
||||
result = queue->values.size == 0 ? Qtrue : Qfalse;
|
||||
unlock_mutex(&queue->mutex);
|
||||
|
||||
return result;
|
||||
|
|
@ -1020,11 +855,8 @@ 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;
|
||||
|
|
@ -1045,11 +877,8 @@ 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;
|
||||
|
|
@ -1073,13 +902,8 @@ 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;
|
||||
|
|
@ -1121,12 +945,8 @@ 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);
|
||||
|
|
@ -1168,11 +988,8 @@ 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;
|
||||
|
|
@ -1193,12 +1010,8 @@ 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;
|
||||
|
|
@ -1245,27 +1058,20 @@ 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;
|
||||
}
|
||||
|
||||
static VALUE dummy_dump _((VALUE));
|
||||
|
||||
static VALUE
|
||||
dummy_dump(self)
|
||||
VALUE self;
|
||||
dummy_dump(VALUE self)
|
||||
{
|
||||
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);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue