Changeset 248fc1a in mainline

Timestamp:

2006-02-05T13:56:01Z (19 years ago)

Author:

Ondrej Palkovsky <ondrap@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

444ec64

Parents:

e22f561

Message:

Fixed some typos in slab allocator.
Scheduler now has better algorithm on load balancing.
Unfortunately it reveals deadlock in slab allocator :-/

Location:

generic

Files:

• include/cpu.h (modified) (1 diff)
• src/mm/slab.c (modified) (6 diffs)
• src/proc/scheduler.c (modified) (10 diffs)
• src/proc/thread.c (modified) (1 diff)

generic/include/cpu.h

@@ -51 +51 @@
         context_t saved_context;
 
-        volatile count_t nrdy;
+        atomic_t nrdy;
         runq_t rq[RQ_COUNT];
         volatile count_t needs_relink;

generic/src/mm/slab.c

@@ -253 +253 @@
                 list_remove(&slab->link);
                 list_prepend(&slab->link, &cache->partial_slabs);
-                spinlock_unlock(&cache->slablock);
-        }
+        }
+        spinlock_unlock(&cache->slablock);
         return 0;
 }
@@ -537 +537 @@
         int i;
         int pages;
+        ipl_t ipl;
 
         memsetb((__address)cache, sizeof(*cache), 0);
@@ -581 +582 @@
                 cache->flags |= SLAB_CACHE_SLINSIDE;
 
+        /* Add cache to cache list */
+        ipl = interrupts_disable();
         spinlock_lock(&slab_cache_lock);
 
@@ -586 +589 @@
 
         spinlock_unlock(&slab_cache_lock);
+        interrupts_restore(ipl);
 }
 
@@ -759 +763 @@
         slab_cache_t *cache;
         link_t *cur;
-
+        ipl_t ipl;
+        
+        ipl = interrupts_disable();
         spinlock_lock(&slab_cache_lock);
         printf("SLAB name\tOsize\tPages\tObj/pg\tSlabs\tCached\tAllocobjs\tCtl\n");
@@ -772 +778 @@
         }
         spinlock_unlock(&slab_cache_lock);
+        interrupts_restore(ipl);
 }
 

generic/src/proc/scheduler.c

@@ -120 +120 @@
         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
@@ -146 +140 @@
         
         i = 0;
-retry:
         for (; i<RQ_COUNT; i++) {
                 r = &CPU->rq[i];
@@ -158 +151 @@
                 }
 
-                /* 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--;
@@ -465 +448 @@
 {
         thread_t *t;
-        int count, i, j, k = 0;
+        int count, average, i, j, k = 0;
         ipl_t ipl;
 
@@ -480 +463 @@
          * passes. Each time get the most up to date counts.
          */
-        ipl = interrupts_disable();
-        spinlock_lock(&CPU->lock);
-        count = atomic_get(&nrdy) / config.cpu_active;
-        count -= CPU->nrdy;
-        spinlock_unlock(&CPU->lock);
-        interrupts_restore(ipl);
-
-        if (count <= 0)
+        average = atomic_get(&nrdy) / config.cpu_active;
+        count = average - atomic_get(&CPU->nrdy);
+
+        if (count < 0)
                 goto satisfied;
+
+        if (!count) { /* Try to steal threads from CPU's that have more then average count */
+                count = 1;
+                average += 1;
+        }
 
         /*
@@ -506 +490 @@
                          */
                         if (CPU == cpu)
-                                continue;                               
+                                continue;
+                        if (atomic_get(&cpu->nrdy) <= average)
+                                continue;
 
 restart:                ipl = interrupts_disable();
@@ -545 +531 @@
                                                 goto restart;
                                         }
-                                        cpu->nrdy--;
+                                        atomic_dec(&cpu->nrdy);
                                         spinlock_unlock(&cpu->lock);
 
@@ -567 +553 @@
                                 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;
@@ -590 +576 @@
         }
 
-        if (CPU->nrdy) {
+        if (atomic_get(&CPU->nrdy)) {
                 /*
                  * Be a little bit light-weight and let migrated threads run.
@@ -630 +616 @@
                 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++) {

generic/src/proc/thread.c

@@ -138 +138 @@
         atomic_inc(&nrdy);
         avg = atomic_get(&nrdy) / config.cpu_active;
-
-        spinlock_lock(&cpu->lock);
-        if ((++cpu->nrdy) > avg) {
-                /*
-                 * If there are idle halted CPU's, this will wake them up.
-                 */
-                ipi_broadcast(VECTOR_WAKEUP_IPI);
-        }       
-        spinlock_unlock(&cpu->lock);
+        atomic_inc(&cpu->nrdy);
 
         interrupts_restore(ipl);