Project

General

Profile

Download (7.42 KB)

Feature #3176 » setpriority_wont_work.diff

coatl (caleb clausen), 05/22/2010 09:34 AM

View differences:

eval.c
void rb_clear_trace_func(void);
void rb_thread_stop_timer_thread(void);
extern void rb_threadptr_interrupt(rb_thread_t *th);
void rb_call_inits(void);
void Init_heap(void);
thread.c
static inline void blocking_region_end(rb_thread_t *th, struct rb_blocking_region_buffer *region);
#if !USE_NATIVE_THREAD_PRIORITY
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);
#endif
#define RB_GC_SAVE_MACHINE_CONTEXT(th) \
do { \
......
SET_MACHINE_STACK_END(&(th)->machine_stack_end); \
} while (0)
#if USE_NATIVE_THREAD_PRIORITY
#define GVL_TAKE(th) (native_mutex_lock(&(th)->vm->global_vm_lock))
#define GVL_GIVE(th) (native_mutex_unlock(&(th)->vm->global_vm_lock))
#else
#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)
#endif
#define GVL_UNLOCK_BEGIN() do { \
rb_thread_t *_th_stored = GET_THREAD(); \
RB_GC_SAVE_MACHINE_CONTEXT(_th_stored); \
......
native_mutex_destroy(lock);
}
#if !USE_NATIVE_THREAD_PRIORITY
static void
rb_pqueue_flush(pqueue_t *pqueue)
{
......
}
if (++pqueue->next_promote_index>=RUBY_NUM_PRIORITIES) pqueue->next_promote_index=0;
}
#endif /*USE_NATIVE_THREAD_PRIORITY*/
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)));
}
#if USE_NATIVE_THREAD_PRIORITY
#define rb_there_are_equal_or_higher_priority_threads(th) 0
#else
static int
rb_there_are_equal_or_higher_priority_threads(rb_thread_t *th)
{
......
return(highest_waiting>=th->priority);
}
#endif
static void rb_threadptr_execute_interrupts_rec(rb_thread_t *, int);
......
thread_debug("rb_thread_schedule/switch done\n");
}
#if !USE_NATIVE_THREAD_PRIORITY
if (sched_depth){
if (ticks_til_rotate) {
--ticks_til_rotate;
......
rb_pqueue_rotate(&th->vm->ready_to_run_list);
}
}
#endif
if (!sched_depth && UNLIKELY(GET_THREAD()->interrupt_flag)) {
rb_threadptr_execute_interrupts_rec(GET_THREAD(), sched_depth+1);
......
rb_secure(4);
#if USE_NATIVE_THREAD_PRIORITY
th->priority = NUM2INT(prio);
native_thread_apply_priority(th);
#else
priority = NUM2INT(prio);
if (priority > RUBY_THREAD_PRIORITY_MAX) {
priority = RUBY_THREAD_PRIORITY_MAX;
......
priority = RUBY_THREAD_PRIORITY_MIN;
}
th->priority = priority;
#if USE_NATIVE_THREAD_PRIORITY
native_thread_apply_priority(th);
#endif
return INT2NUM(th->priority);
}
......
vm->main_thread = th;
native_mutex_reinitialize_atfork(&th->vm->global_vm_lock);
#if !USE_NATIVE_THREAD_PRIORITY
rb_pqueue_flush(&vm->ready_to_run_list);
#endif
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);
#if !USE_NATIVE_THREAD_PRIORITY
rb_pqueue_initialize(&GET_THREAD()->vm->ready_to_run_list);
#endif
native_mutex_initialize(&GET_THREAD()->interrupt_lock);
}
}
thread_pthread.c
static void
native_thread_apply_priority(rb_thread_t *th)
{
#if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING > 0)
#ifdef linux
setpriority(PRIO_PROCESS,th->thread_id,-th->priority);
#else
struct sched_param sp;
int policy;
int priority = 0 - th->priority;
......
sp.sched_priority = priority;
pthread_setschedparam(th->thread_id, policy, &sp);
#else
/* not touched */
#endif
}
vm.c
void vm_analysis_register(int reg, int isset);
void vm_analysis_insn(int insn);
#if !USE_NATIVE_THREAD_PRIORITY
extern void rb_pqueue_destroy(pqueue_t *pqueue);
#endif
void
rb_vm_change_state(void)
......
}
rb_thread_lock_unlock(&vm->global_vm_lock);
rb_thread_lock_destroy(&vm->global_vm_lock);
#if !USE_NATIVE_THREAD_PRIORITY
rb_pqueue_destroy(&vm->ready_to_run_list);
#endif
ruby_xfree(vm);
ruby_current_vm = 0;
#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
vm_core.h
#include <setjmp.h>
#include <signal.h>
#ifdef linux
#define USE_NATIVE_THREAD_PRIORITY 1
#define RUBY_THREAD_PRIORITY_MAX 20
#define RUBY_THREAD_PRIORITY_MIN -19
#endif
#ifndef USE_NATIVE_THREAD_PRIORITY
#define USE_NATIVE_THREAD_PRIORITY 0
#define RUBY_THREAD_PRIORITY_MAX 15
#define RUBY_THREAD_PRIORITY_MIN -16
#define RUBY_NUM_PRIORITIES (1+RUBY_THREAD_PRIORITY_MAX-RUBY_THREAD_PRIORITY_MIN)
#endif
#define RUBY_NUM_PRIORITIES (1+RUBY_THREAD_PRIORITY_MAX-RUBY_THREAD_PRIORITY_MIN)
#ifndef NSIG
# define NSIG (_SIGMAX + 1) /* For QNX */
#endif
......
void rb_objspace_free(struct rb_objspace *);
#endif
#if !USE_NATIVE_THREAD_PRIORITY
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;
#endif
typedef struct rb_vm_struct {
VALUE self;
rb_thread_lock_t global_vm_lock;
#if !USE_NATIVE_THREAD_PRIORITY
pqueue_t ready_to_run_list;
#endif
struct rb_thread_struct *main_thread;
struct rb_thread_struct *running_thread;
......
int method_missing_reason;
int abort_on_exception;
#if !USE_NATIVE_THREAD_PRIORITY
struct rb_thread_struct *next;
#endif
#ifdef USE_SIGALTSTACK
void *altstack;
(5-5/5)