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

  */
 static thread_t *find_best_thread(void)
+{
     thread_t *t;
     runq_t *r;
-    int i, n;
+    int i;
     ASSERT(CPU != NULL);
 loop:
-    interrupts_disable();
-    spinlock_lock(&CPU->lock);
-    n = CPU->nrdy;
-    spinlock_unlock(&CPU->lock);
     interrupts_enable();
-    if (n == 0) {
+    if (atomic_get(&CPU->nrdy) == 0) {
         /*
          * For there was nothing to run, the CPU goes to sleep
          * until a hardware interrupt or an IPI comes.
          * This improves energy saving and hyperthreading.
          */
+    }
     interrupts_disable();
     i = 0;
-retry:
     for (; i<RQ_COUNT; i++) {
         r = &CPU->rq[i];
         spinlock_lock(&r->lock);
         if (r->n == 0) {
             /*
              */
             spinlock_unlock(&r->lock);
             continue;
+        }
-        /* avoid deadlock with relink_rq() */
-        if (!spinlock_trylock(&CPU->lock)) {
-            /*
-             * Unlock r and try again.
-             */
-            spinlock_unlock(&r->lock);
-            goto retry;
-        }
-        CPU->nrdy--;
-        spinlock_unlock(&CPU->lock);
+        atomic_dec(&CPU->nrdy);
         atomic_dec(&nrdy);
         r->n--;
         /*
          * Take the first thread from the queue.
+ *
  */
 void kcpulb(void *arg)
+{
     thread_t *t;
-    int count, i, j, k = 0;
+    int count, average, i, j, k = 0;
     ipl_t ipl;
 loop:
     /*
      * Work in 1s intervals.
     /*
      * Calculate the number of threads that will be migrated/stolen from
      * other CPU's. Note that situation can have changed between two
      * passes. Each time get the most up to date counts.
      */
-    ipl = interrupts_disable();
-    spinlock_lock(&CPU->lock);
-    count = atomic_get(&nrdy) / config.cpu_active;
+    average = atomic_get(&nrdy) / config.cpu_active;
-    count -= CPU->nrdy;
+    count = average - atomic_get(&CPU->nrdy);
-    spinlock_unlock(&CPU->lock);
-    interrupts_restore(ipl);
-    if (count <= 0)
+    if (count < 0)
         goto satisfied;
+    if (!count) { /* Try to steal threads from CPU's that have more then average count */
+        count = 1;
+        average += 1;
+    }
     /*
      * 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 (i=0; i < config.cpu_active; i++) {
             /*
              * Not interested in ourselves.
              * Doesn't require interrupt disabling for kcpulb is X_WIRED.
              */
             if (CPU == cpu)
+                continue;
+            if (atomic_get(&cpu->nrdy) <= average)
                 continue;
 restart:        ipl = interrupts_disable();
             r = &cpu->rq[j];
             spinlock_lock(&r->lock);
             if (r->n == 0) {
                         /* Release all locks and try again. */
                         spinlock_unlock(&r->lock);
                         interrupts_restore(ipl);
                         goto restart;
+                    }
-                    cpu->nrdy--;
+                    atomic_dec(&cpu->nrdy);
                     spinlock_unlock(&cpu->lock);
                     atomic_dec(&nrdy);
                     r->n--;
                 /*
                  * Ready t on local CPU
                  */
                 spinlock_lock(&t->lock);
                 #ifdef KCPULB_VERBOSE
-                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%d, avg=%d\n", CPU->id, t->tid, CPU->id, CPU->nrdy, atomic_get(&nrdy) / config.cpu_active);
+                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%d, avg=%d\n", CPU->id, t->tid, CPU->id, atomic_get(&CPU->nrdy), atomic_get(&nrdy) / config.cpu_active);
                 #endif
                 t->flags |= X_STOLEN;
                 spinlock_unlock(&t->lock);
                 thread_ready(t);
+            }
             interrupts_restore(ipl);
+        }
+    }
-    if (CPU->nrdy) {
+    if (atomic_get(&CPU->nrdy)) {
         /*
          * Be a little bit light-weight and let migrated threads run.
          */
         scheduler();
     } else {
     for (cpu=0;cpu < config.cpu_count; cpu++) {
         if (!cpus[cpu].active)
             continue;
         spinlock_lock(&cpus[cpu].lock);
         printf("cpu%d: nrdy: %d needs_relink: %d\n",
-               cpus[cpu].id, cpus[cpu].nrdy, cpus[cpu].needs_relink);
+               cpus[cpu].id, atomic_get(&cpus[cpu].nrdy), cpus[cpu].needs_relink);
         for (i=0; i<RQ_COUNT; i++) {
             r = &cpus[cpu].rq[i];
             spinlock_lock(&r->lock);
             if (!r->n) {

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/proc/scheduler.c – Rev 779 → 783