HelenOS-historicHelenOSHelenOS-doc

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /SPARTAN/trunk/src/proc @ 404

  → /SPARTAN/trunk/src/proc @ 413

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Ignore whitespace Rev 404 → Rev 413

/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);
}