WebSVN – HelenOS – Diff – //trunk/kernel/generic/src/proc/scheduler.c

 /*
- * Copyright (C) 2001-2004 Jakub Jermar
+ * Copyright (C) 2001-2007 Jakub Jermar
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
         /* Allocate FPU context */
         if (!THREAD->saved_fpu_context) {
             /* Might sleep */
             spinlock_unlock(&THREAD->lock);
             spinlock_unlock(&CPU->lock);
+            THREAD->saved_fpu_context =
-            THREAD->saved_fpu_context = slab_alloc(fpu_context_slab, 0);
+                slab_alloc(fpu_context_slab, 0);
             /* We may have switched CPUs during slab_alloc */
             goto restart;
+        }
         fpu_init();
         THREAD->fpu_context_exists = 1;
         spinlock_unlock(&r->lock);
         spinlock_lock(&t->lock);
         t->cpu = CPU;
-        t->ticks = us2ticks((i+1)*10000);
+        t->ticks = us2ticks((i + 1) * 10000);
         t->priority = i;    /* correct rq index */
         /*
          * Clear the THREAD_FLAG_STOLEN flag so that t can be migrated
          * when load balancing needs emerge.
     int i, n;
     list_initialize(&head);
     spinlock_lock(&CPU->lock);
     if (CPU->needs_relink > NEEDS_RELINK_MAX) {
-        for (i = start; i<RQ_COUNT-1; i++) {
+        for (i = start; i < RQ_COUNT - 1; i++) {
             /* remember and empty rq[i + 1] */
             r = &CPU->rq[i + 1];
             spinlock_lock(&r->lock);
             list_concat(&head, &r->rq_head);
             n = r->n;
             return;
+        }
         /*
-         * Interrupt priority level of preempted thread is recorded here
+         * Interrupt priority level of preempted thread is recorded
-         * to facilitate scheduler() invocations from interrupts_disable()'d
+         * here to facilitate scheduler() invocations from
-         * code (e.g. waitq_sleep_timeout()).
+         * interrupts_disable()'d code (e.g. waitq_sleep_timeout()).
          */
         THREAD->saved_context.ipl = ipl;
+    }
     /*
 repeat:
             if (THREAD->detached) {
                 thread_destroy(THREAD);
             } else {
                 /*
-                 * The thread structure is kept allocated until somebody
+                 * The thread structure is kept allocated until
-                 * calls thread_detach() on it.
+                 * somebody calls thread_detach() on it.
                  */
                 if (!spinlock_trylock(&THREAD->join_wq.lock)) {
                     /*
                      * Avoid deadlock.
                      */
              * Prefer the thread after it's woken up.
              */
             THREAD->priority = -1;
             /*
-             * We need to release wq->lock which we locked in waitq_sleep().
+             * We need to release wq->lock which we locked in
-             * Address of wq->lock is kept in THREAD->sleep_queue.
+             * waitq_sleep(). Address of wq->lock is kept in
+             * THREAD->sleep_queue.
              */
             spinlock_unlock(&THREAD->sleep_queue->lock);
             /*
-             * Check for possible requests for out-of-context invocation.
+             * Check for possible requests for out-of-context
+             * invocation.
              */
             if (THREAD->call_me) {
                 THREAD->call_me(THREAD->call_me_with);
                 THREAD->call_me = NULL;
                 THREAD->call_me_with = NULL;
         default:
             /*
              * Entering state is unexpected.
              */
-            panic("tid%d: unexpected state %s\n", THREAD->tid, thread_states[THREAD->state]);
+            panic("tid%d: unexpected state %s\n", THREAD->tid,
+                thread_states[THREAD->state]);
             break;
+        }
         THREAD = NULL;
+    }
     spinlock_unlock(&THREAD->lock);
     relink_rq(priority);
     /*
-     * If both the old and the new task are the same, lots of work is avoided.
+     * If both the old and the new task are the same, lots of work is
+     * avoided.
      */
     if (TASK != THREAD->task) {
         as_t *as1 = NULL;
         as_t *as2;
         spinlock_lock(&THREAD->task->lock);
         as2 = THREAD->task->as;
         spinlock_unlock(&THREAD->task->lock);
         /*
-         * Note that it is possible for two tasks to share one address space.
+         * Note that it is possible for two tasks to share one address
+         * space.
          */
         if (as1 != as2) {
             /*
              * Both tasks and address spaces are different.
              * Replace the old one with the new one.
     spinlock_lock(&THREAD->lock);
     THREAD->state = Running;
 #ifdef SCHEDULER_VERBOSE
-    printf("cpu%d: tid %d (priority=%d,ticks=%lld,nrdy=%ld)\n",
+    printf("cpu%d: tid %d (priority=%d, ticks=%lld, nrdy=%ld)\n",
-        CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks, atomic_get(&CPU->nrdy));
+        CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks,
+            atomic_get(&CPU->nrdy));
 #endif
     /*
      * Some architectures provide late kernel PA2KA(identity)
      * mapping in a page fault handler. However, the page fault
      * function must be executed before the switch to the new stack.
      */
     before_thread_runs();
     /*
-     * Copy the knowledge of CPU, TASK, THREAD and preemption counter to thread's stack.
+     * Copy the knowledge of CPU, TASK, THREAD and preemption counter to
+     * thread's stack.
      */
     the_copy(THE, (the_t *) THREAD->kstack);
     context_restore(&THREAD->saved_context);
     /* not reached */
     if (count <= 0)
         goto satisfied;
     /*
-     * Searching least priority queues on all CPU's first and most priority queues on all CPU's last.
+     * Searching least priority queues on all CPU's first and most priority
+     * queues on all CPU's last.
      */
-    for (j=RQ_COUNT-1; j >= 0; j--) {
+    for (j= RQ_COUNT - 1; j >= 0; j--) {
-        for (i=0; i < config.cpu_active; i++) {
+        for (i = 0; i < config.cpu_active; i++) {
             link_t *l;
             runq_t *r;
             cpu_t *cpu;
             cpu = &cpus[(i + k) % config.cpu_active];
             /*
              * Not interested in ourselves.
-             * Doesn't require interrupt disabling for kcpulb has THREAD_FLAG_WIRED.
+             * Doesn't require interrupt disabling for kcpulb has
+             * THREAD_FLAG_WIRED.
              */
             if (CPU == cpu)
                 continue;
             if (atomic_get(&cpu->nrdy) <= average)
                 continue;
             t = NULL;
             l = r->rq_head.prev;    /* search rq from the back */
             while (l != &r->rq_head) {
                 t = list_get_instance(l, thread_t, rq_link);
                 /*
-                 * We don't want to steal CPU-wired threads neither threads already
+                 * We don't want to steal CPU-wired threads
+                 * neither threads already stolen. The latter
-                 * stolen. The latter prevents threads from migrating between CPU's
+                 * prevents threads from migrating between CPU's
-                 * without ever being run. We don't want to steal threads whose FPU
+                 * without ever being run. We don't want to
-                 * context is still in CPU.
+                 * steal threads whose FPU context is still in
+                 * CPU.
                  */
                 spinlock_lock(&t->lock);
-                if ((!(t->flags & (THREAD_FLAG_WIRED | THREAD_FLAG_STOLEN))) &&
+                if ((!(t->flags & (THREAD_FLAG_WIRED |
+                    THREAD_FLAG_STOLEN))) &&
                     (!(t->fpu_context_engaged)) ) {
                     /*
                      * Remove t from r.
                      */
                     spinlock_unlock(&t->lock);
                 /*
                  * Ready t on local CPU
                  */
                 spinlock_lock(&t->lock);
 #ifdef KCPULB_VERBOSE
-                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%ld, avg=%nd\n",
+                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%ld, "
-                    CPU->id, t->tid, CPU->id, atomic_get(&CPU->nrdy),
+                    "avg=%nd\n", CPU->id, t->tid, CPU->id,
+                    atomic_get(&CPU->nrdy),
                     atomic_get(&nrdy) / config.cpu_active);
 #endif
                 t->flags |= THREAD_FLAG_STOLEN;
                 t->state = Entering;
                 spinlock_unlock(&t->lock);
                 if (--count == 0)
                     goto satisfied;
                 /*
-                 * We are not satisfied yet, focus on another CPU next time.
+                 * We are not satisfied yet, focus on another
+                 * CPU next time.
                  */
                 k++;
                 continue;
+            }
         if (!cpus[cpu].active)
             continue;
         spinlock_lock(&cpus[cpu].lock);
         printf("cpu%d: address=%p, nrdy=%ld, needs_relink=%ld\n",
-               cpus[cpu].id, &cpus[cpu], atomic_get(&cpus[cpu].nrdy), cpus[cpu].needs_relink);
+            cpus[cpu].id, &cpus[cpu], atomic_get(&cpus[cpu].nrdy),
+            cpus[cpu].needs_relink);
-        for (i=0; i<RQ_COUNT; i++) {
+        for (i = 0; i < RQ_COUNT; i++) {
             r = &cpus[cpu].rq[i];
             spinlock_lock(&r->lock);
             if (!r->n) {
                 spinlock_unlock(&r->lock);
                 continue;
+            }
             printf("\trq[%d]: ", i);
-            for (cur=r->rq_head.next; cur!=&r->rq_head; cur=cur->next) {
+            for (cur = r->rq_head.next; cur != &r->rq_head;
+                cur = cur->next) {
                 t = list_get_instance(cur, thread_t, rq_link);
                 printf("%d(%s) ", t->tid,
-                       thread_states[t->state]);
+                    thread_states[t->state]);
+            }
             printf("\n");
             spinlock_unlock(&r->lock);
+        }
         spinlock_unlock(&cpus[cpu].lock);

Subversion Repositories HelenOS

(root)//trunk/kernel/generic/src/proc/scheduler.c – Rev 2040 → 2067