Ruby

void rb_clear_trace_func(void);

void rb_thread_stop_timer_thread(void);

void rb_call_inits(void);

void Init_heap(void);

static inline void blocking_region_end(rb_thread_t *th, struct rb_blocking_region_buffer *region);

static void rb_pqueue_enqueue(pqueue_t *pqueue, rb_thread_t *th, unsigned priority);

static rb_thread_t *rb_pqueue_dequeue(pqueue_t *pqueue);

static rb_thread_t *rb_pqueue_dequeue_starting_at(pqueue_t *pqueue, unsigned start_from, unsigned *found_at);

#define RB_GC_SAVE_MACHINE_CONTEXT(th) \

do { \

SET_MACHINE_STACK_END(&(th)->machine_stack_end); \

} while (0)

#define GVL_TAKE(th) \

while (0!=native_mutex_trylock(&(th)->vm->global_vm_lock)) { \

thread_debug("waiting for gvl\n"); \

if (th2) rb_undoze(th2); \

} while(0)

#define GVL_UNLOCK_BEGIN() do { \

rb_thread_t *_th_stored = GET_THREAD(); \

RB_GC_SAVE_MACHINE_CONTEXT(_th_stored); \

native_mutex_destroy(lock);

}

static void

rb_pqueue_flush(pqueue_t *pqueue)

{

}

if (++pqueue->next_promote_index>=RUBY_NUM_PRIORITIES) pqueue->next_promote_index=0;

}

static void

set_unblock_function(rb_thread_t *th, rb_unblock_function_t *func, void *arg,

rb_thread_wait_for(rb_time_timeval(INT2FIX(sec)));

}

static int

rb_there_are_equal_or_higher_priority_threads(rb_thread_t *th)

{

return(highest_waiting>=th->priority);

}

static void rb_threadptr_execute_interrupts_rec(rb_thread_t *, int);

thread_debug("rb_thread_schedule/switch done\n");

}

if (sched_depth){

if (ticks_til_rotate) {

--ticks_til_rotate;

rb_pqueue_rotate(&th->vm->ready_to_run_list);

}

}

if (!sched_depth && UNLIKELY(GET_THREAD()->interrupt_flag)) {

rb_threadptr_execute_interrupts_rec(GET_THREAD(), sched_depth+1);

rb_secure(4);

priority = NUM2INT(prio);

if (priority > RUBY_THREAD_PRIORITY_MAX) {

priority = RUBY_THREAD_PRIORITY_MAX;

priority = RUBY_THREAD_PRIORITY_MIN;

}

th->priority = priority;

#endif

return INT2NUM(th->priority);

}

vm->main_thread = th;

native_mutex_reinitialize_atfork(&th->vm->global_vm_lock);

rb_pqueue_flush(&vm->ready_to_run_list);

st_foreach(vm->living_threads, atfork, (st_data_t)th);

st_clear(vm->living_threads);

st_insert(vm->living_threads, thval, (st_data_t)th->thread_id);

rb_thread_lock_t *lp = &GET_THREAD()->vm->global_vm_lock;

native_mutex_initialize(lp);

native_mutex_lock(lp);

rb_pqueue_initialize(&GET_THREAD()->vm->ready_to_run_list);

native_mutex_initialize(&GET_THREAD()->interrupt_lock);

}

}

static void

native_thread_apply_priority(rb_thread_t *th)

{

struct sched_param sp;

int policy;

int priority = 0 - th->priority;

sp.sched_priority = priority;

pthread_setschedparam(th->thread_id, policy, &sp);

#endif

}

void vm_analysis_register(int reg, int isset);

void vm_analysis_insn(int insn);

extern void rb_pqueue_destroy(pqueue_t *pqueue);

void

rb_vm_change_state(void)

}

rb_thread_lock_unlock(&vm->global_vm_lock);

rb_thread_lock_destroy(&vm->global_vm_lock);

rb_pqueue_destroy(&vm->ready_to_run_list);

ruby_xfree(vm);

ruby_current_vm = 0;

#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE

#include <setjmp.h>

#include <signal.h>

#ifndef USE_NATIVE_THREAD_PRIORITY

#define USE_NATIVE_THREAD_PRIORITY 0

#define RUBY_THREAD_PRIORITY_MAX 15

#define RUBY_THREAD_PRIORITY_MIN -16

#endif

#ifndef NSIG

# define NSIG (_SIGMAX + 1) /* For QNX */

#endif

void rb_objspace_free(struct rb_objspace *);

#endif

struct rb_thread_struct;

typedef struct priority_queue {

/*elements in queues are circularly linked lists of rb_thread_t,

unsigned next_promote_index; /*makes this into a fair priority queue*/

rb_thread_lock_t lock;

} pqueue_t;

typedef struct rb_vm_struct {

VALUE self;

rb_thread_lock_t global_vm_lock;

pqueue_t ready_to_run_list;

struct rb_thread_struct *main_thread;

struct rb_thread_struct *running_thread;

int method_missing_reason;

int abort_on_exception;

struct rb_thread_struct *next;

#ifdef USE_SIGALTSTACK

void *altstack;