/SPARTAN/trunk/src/proc/scheduler.c |
---|
125,13 → 125,13 |
ASSERT(CPU != NULL); |
loop: |
cpu_priority_high(); |
interrupts_disable(); |
spinlock_lock(&CPU->lock); |
n = CPU->nrdy; |
spinlock_unlock(&CPU->lock); |
cpu_priority_low(); |
interrupts_enable(); |
if (n == 0) { |
#ifdef __SMP__ |
155,7 → 155,7 |
goto loop; |
} |
cpu_priority_high(); |
interrupts_disable(); |
i = 0; |
retry: |
196,7 → 196,7 |
t->cpu = CPU; |
t->ticks = us2ticks((i+1)*10000); |
t->pri = i; /* eventually correct rq index */ |
t->priority = i; /* eventually correct rq index */ |
/* |
* Clear the X_STOLEN flag so that t can be migrated when load balancing needs emerge. |
261,11 → 261,11 |
*/ |
void scheduler(void) |
{ |
volatile pri_t pri; |
volatile ipl_t ipl; |
ASSERT(CPU != NULL); |
pri = cpu_priority_high(); |
ipl = interrupts_disable(); |
if (haltstate) |
halt(); |
281,16 → 281,16 |
*/ |
before_thread_runs(); |
spinlock_unlock(&THREAD->lock); |
cpu_priority_restore(THREAD->saved_context.pri); |
interrupts_restore(THREAD->saved_context.ipl); |
return; |
} |
/* |
* CPU priority of preempted thread is recorded here |
* to facilitate scheduler() invocations from |
* cpu_priority_high()'ed code (e.g. waitq_sleep_timeout()). |
* Interrupt priority level of preempted thread is recorded here |
* to facilitate scheduler() invocations from interrupts_disable()'d |
* code (e.g. waitq_sleep_timeout()). |
*/ |
THREAD->saved_context.pri = pri; |
THREAD->saved_context.ipl = ipl; |
} |
/* |
371,7 → 371,7 |
/* |
* Prefer the thread after it's woken up. |
*/ |
THREAD->pri = -1; |
THREAD->priority = -1; |
/* |
* We need to release wq->lock which we locked in waitq_sleep(). |
406,7 → 406,7 |
THREAD = find_best_thread(); |
spinlock_lock(&THREAD->lock); |
priority = THREAD->pri; |
priority = THREAD->priority; |
spinlock_unlock(&THREAD->lock); |
relink_rq(priority); |
446,7 → 446,7 |
THREAD->state = Running; |
#ifdef SCHEDULER_VERBOSE |
printf("cpu%d: tid %d (pri=%d,ticks=%d,nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->pri, THREAD->ticks, CPU->nrdy); |
printf("cpu%d: tid %d (priority=%d,ticks=%d,nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks, CPU->nrdy); |
#endif |
/* |
472,7 → 472,7 |
{ |
thread_t *t; |
int count, i, j, k = 0; |
pri_t pri; |
ipl_t ipl; |
loop: |
/* |
486,12 → 486,12 |
* other CPU's. Note that situation can have changed between two |
* passes. Each time get the most up to date counts. |
*/ |
pri = cpu_priority_high(); |
ipl = interrupts_disable(); |
spinlock_lock(&CPU->lock); |
count = nrdy / config.cpu_active; |
count -= CPU->nrdy; |
spinlock_unlock(&CPU->lock); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
if (count <= 0) |
goto satisfied; |
514,12 → 514,12 |
if (CPU == cpu) |
continue; |
restart: pri = cpu_priority_high(); |
restart: ipl = interrupts_disable(); |
r = &cpu->rq[j]; |
spinlock_lock(&r->lock); |
if (r->n == 0) { |
spinlock_unlock(&r->lock); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
continue; |
} |
548,7 → 548,7 |
if (!spinlock_trylock(&cpu->lock)) { |
/* Release all locks and try again. */ |
spinlock_unlock(&r->lock); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
goto restart; |
} |
cpu->nrdy--; |
580,7 → 580,7 |
thread_ready(t); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
if (--count == 0) |
goto satisfied; |
592,7 → 592,7 |
continue; |
} |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
} |
} |
/SPARTAN/trunk/src/proc/task.c |
---|
64,7 → 64,7 |
*/ |
task_t *task_create(vm_t *m) |
{ |
pri_t pri; |
ipl_t ipl; |
task_t *ta; |
ta = (task_t *) malloc(sizeof(task_t)); |
74,11 → 74,11 |
list_initialize(&ta->tasks_link); |
ta->vm = m; |
pri = cpu_priority_high(); |
ipl = interrupts_disable(); |
spinlock_lock(&tasks_lock); |
list_append(&ta->tasks_link, &tasks_head); |
spinlock_unlock(&tasks_lock); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
} |
return ta; |
} |
/SPARTAN/trunk/src/proc/thread.c |
---|
67,7 → 67,7 |
* makes a call to thread_exit() when its implementing |
* function returns. |
* |
* cpu_priority_high() is assumed. |
* interrupts_disable() is assumed. |
* |
*/ |
void cushion(void) |
79,7 → 79,7 |
before_thread_runs(); |
spinlock_unlock(&THREAD->lock); |
cpu_priority_low(); |
interrupts_enable(); |
f(arg); |
thread_exit(); |
112,14 → 112,14 |
{ |
cpu_t *cpu; |
runq_t *r; |
pri_t pri; |
ipl_t ipl; |
int i, avg, send_ipi = 0; |
pri = cpu_priority_high(); |
ipl = interrupts_disable(); |
spinlock_lock(&t->lock); |
i = (t->pri < RQ_COUNT -1) ? ++t->pri : t->pri; |
i = (t->priority < RQ_COUNT -1) ? ++t->priority : t->priority; |
cpu = CPU; |
if (t->flags & X_WIRED) { |
148,7 → 148,7 |
} |
spinlock_unlock(&cpu->lock); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
} |
171,7 → 171,7 |
t = (thread_t *) malloc(sizeof(thread_t)); |
if (t) { |
pri_t pri; |
ipl_t ipl; |
spinlock_initialize(&t->lock); |
180,11 → 180,11 |
frame_us = frame_alloc(FRAME_KA); |
} |
pri = cpu_priority_high(); |
ipl = interrupts_disable(); |
spinlock_lock(&tidlock); |
t->tid = ++last_tid; |
spinlock_unlock(&tidlock); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
memsetb(frame_ks, THREAD_STACK_SIZE, 0); |
link_initialize(&t->rq_link); |
199,14 → 199,14 |
the_initialize((the_t *) t->kstack); |
pri = cpu_priority_high(); |
t->saved_context.pri = cpu_priority_read(); |
cpu_priority_restore(pri); |
ipl = interrupts_disable(); |
t->saved_context.ipl = interrupts_read(); |
interrupts_restore(ipl); |
t->thread_code = func; |
t->thread_arg = arg; |
t->ticks = -1; |
t->pri = -1; /* start in rq[0] */ |
t->priority = -1; /* start in rq[0] */ |
t->cpu = NULL; |
t->flags = 0; |
t->state = Entering; |
227,7 → 227,7 |
/* |
* Register this thread in the system-wide list. |
*/ |
pri = cpu_priority_high(); |
ipl = interrupts_disable(); |
spinlock_lock(&threads_lock); |
list_append(&t->threads_link, &threads_head); |
spinlock_unlock(&threads_lock); |
239,7 → 239,7 |
list_append(&t->th_link, &task->th_head); |
spinlock_unlock(&task->lock); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
} |
return t; |
254,14 → 254,14 |
*/ |
void thread_exit(void) |
{ |
pri_t pri; |
ipl_t ipl; |
restart: |
pri = cpu_priority_high(); |
ipl = interrupts_disable(); |
spinlock_lock(&THREAD->lock); |
if (THREAD->timeout_pending) { /* busy waiting for timeouts in progress */ |
spinlock_unlock(&THREAD->lock); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
goto restart; |
} |
THREAD->state = Exiting; |
311,12 → 311,12 |
*/ |
void thread_register_call_me(void (* call_me)(void *), void *call_me_with) |
{ |
pri_t pri; |
ipl_t ipl; |
pri = cpu_priority_high(); |
ipl = interrupts_disable(); |
spinlock_lock(&THREAD->lock); |
THREAD->call_me = call_me; |
THREAD->call_me_with = call_me_with; |
spinlock_unlock(&THREAD->lock); |
cpu_priority_restore(pri); |
interrupts_restore(ipl); |
} |