code review 35990043: runtime: add support for GOOS=solaris

src/pkg/runtime/proc.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "zaexperiment.h"
 #include "malloc.h"
 #include "stack.h"
 #include "race.h"
@@ skipping 61 matching lines @@
 G*      runtime·lastg;
 M*      runtime·allm;
 M*      runtime·extram;
 int8*   runtime·goos;
 int32   runtime·ncpu;
 static int32    newprocs;
 
 void runtime·mstart(void);
 static void runqput(P*, G*);
 static G* runqget(P*);
-static void runqgrow(P*);
+static bool runqputslow(P*, G*, uint32, uint32);
 static G* runqsteal(P*, P*);
 static void mput(M*);
 static M* mget(void);
 static void mcommoninit(M*);
 static void schedule(void);
 static void procresize(int32);
 static void acquirep(P*);
 static P* releasep(void);
 static void newm(void(*)(void), P*);
 static void stopm(void);
 static void startm(P*, bool);
 static void handoffp(P*);
 static void wakep(void);
 static void stoplockedm(void);
 static void startlockedm(G*);
 static void sysmon(void);
 static uint32 retake(int64);
 static void incidlelocked(int32);
 static void checkdead(void);
 static void exitsyscall0(G*);
 static void park0(G*);
 static void goexit0(G*);
 static void gfput(P*, G*);
 static G* gfget(P*);
 static void gfpurge(P*);
 static void globrunqput(G*);
+static void globrunqputbatch(G*, G*, int32);
 static G* globrunqget(P*, int32);
 static P* pidleget(void);
 static void pidleput(P*);
 static void injectglist(G*);
 static bool preemptall(void);
 static bool preemptone(P*);
 static bool exitsyscallfast(void);
 static bool haveexperiment(int8*);
 
 // The bootstrap sequence is:
 //
 //      call osinit
 //      call schedinit
 //      make & queue new G
 //      call runtime·mstart
 //
 // The new G calls runtime·main.
 void
 runtime·schedinit(void)
 {
         int32 n, procs;
         byte *p;
         Eface i;
 
         runtime·sched.maxmcount = 10000;
         runtime·precisestack = haveexperiment("precisestack");
 
-        runtime·mprofinit();
         runtime·mallocinit();
         mcommoninit(m);
 ········
         // Initialize the itable value for newErrorCString,
         // so that the next time it gets called, possibly
         // in a fault during a garbage collection, it will not
         // need to allocated memory.
         runtime·newErrorCString(0, &i);
 
         runtime·goargs();
@@ skipping 55 matching lines @@
         d.fn = &initDone;
         d.siz = 0;
         d.link = g->defer;
         d.argp = (void*)-1;
         d.special = true;
         d.free = false;
         g->defer = &d;
 
         if(m != &runtime·m0)
                 runtime·throw("runtime·main not on m0");
-        // TODO(dfc) disable the scavenger
-        // runtime·newproc1(&scavenger, nil, 0, 0, runtime·main);
+        runtime·newproc1(&scavenger, nil, 0, 0, runtime·main);
         main·init();
 
         if(g->defer != &d || d.fn != &initDone)
                 runtime·throw("runtime: bad defer entry after init");
         g->defer = d.link;
         runtime·unlockOSThread();
 
         main·main();
         if(raceenabled)
                 runtime·racefini();
 
         // Make racy client program work: if panicking on
         // another goroutine at the same time as main returns,
         // let the other goroutine finish printing the panic trace.
         // Once it does, it will exit. See issue 3934.
         if(runtime·panicking)
                 runtime·park(nil, nil, "panicwait");
 
         runtime·exit(0);
         for(;;)
                 *(int32*)runtime·main = 0;
 }
 
 void
 runtime·goroutineheader(G *gp)
 {
         int8 *status;
+        int64 waitfor;
 
         switch(gp->status) {
         case Gidle:
                 status = "idle";
                 break;
         case Grunnable:
                 status = "runnable";
                 break;
         case Grunning:
                 status = "running";
                 break;
         case Gsyscall:
                 status = "syscall";
                 break;
         case Gwaiting:
                 if(gp->waitreason)
                         status = gp->waitreason;
                 else
                         status = "waiting";
                 break;
         default:
                 status = "???";
                 break;
         }
-        runtime·printf("goroutine %D [%s]:\n", gp->goid, status);
+
+        // approx time the G is blocked, in minutes
+        waitfor = 0;
+        if((gp->status == Gwaiting || gp->status == Gsyscall) && gp->waitsince != 0)
+                waitfor = (runtime·nanotime() - gp->waitsince) / (60LL*1000*1000*1000);
+
+        if(waitfor < 1)
+                runtime·printf("goroutine %D [%s]:\n", gp->goid, status);
+        else
+                runtime·printf("goroutine %D [%s, %D minutes]:\n", gp->goid, status, waitfor);
 }
 
 void
 runtime·tracebackothers(G *me)
 {
         G *gp;
         int32 traceback;
 
         traceback = runtime·gotraceback(nil);
 ········
         // Show the current goroutine first, if we haven't already.
         if((gp = m->curg) != nil && gp != me) {
                 runtime·printf("\n");
                 runtime·goroutineheader(gp);
-                runtime·traceback(gp->sched.pc, gp->sched.sp, gp->sched.lr, gp);
+                runtime·traceback(~(uintptr)0, ~(uintptr)0, 0, gp);
         }
 
         for(gp = runtime·allg; gp != nil; gp = gp->alllink) {
                 if(gp == me || gp == m->curg || gp->status == Gdead)
                         continue;
                 if(gp->issystem && traceback < 2)
                         continue;
                 runtime·printf("\n");
                 runtime·goroutineheader(gp);
                 if(gp->status == Grunning) {
                         runtime·printf("\tgoroutine running on other thread; stack unavailable\n");
                         runtime·printcreatedby(gp);
                 } else
-                        runtime·traceback(gp->sched.pc, gp->sched.sp, gp->sched.lr, gp);
+                        runtime·traceback(~(uintptr)0, ~(uintptr)0, 0, gp);
         }
 }
 
 static void
 checkmcount(void)
 {
         // sched lock is held
         if(runtime·sched.mcount > runtime·sched.maxmcount) {
                 runtime·printf("runtime: program exceeds %d-thread limit\n", runtime·sched.maxmcount);
                 runtime·throw("thread exhaustion");
@@ skipping 334 matching lines @@
                 Eface e;
                 runtime·gc_m_ptr(&e);
                 mtype = ((PtrType*)e.type)->elem;
         }
 
         mp = runtime·cnew(mtype);
         mcommoninit(mp);
 
         // In case of cgo or Solaris, pthread_create will make us a stack.
         // Windows will layout sched stack on OS stack.
-        if(runtime·iscgo || Windows || Sunos)
+        if(runtime·iscgo || Windows || Solaris)
                 mp->g0 = runtime·malg(-1);
         else
                 mp->g0 = runtime·malg(8192);
 
         if(p == m->p)
                 releasep();
         m->locks--;
         if(m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
                 g->stackguard0 = StackPreempt;
 
@@ skipping 282 matching lines @@
         m->nextp = nil;
 }
 
 static void
 mspinning(void)
 {
         m->spinning = true;
 }
 
 // Schedules some M to run the p (creates an M if necessary).
-// If p==nil, tries to get an idle P, if no idle P's returns false.
+// If p==nil, tries to get an idle P, if no idle P's does nothing.
 static void
 startm(P *p, bool spinning)
 {
         M *mp;
         void (*fn)(void);
 
         runtime·lock(&runtime·sched);
         if(p == nil) {
                 p = pidleget();
                 if(p == nil) {
@@ skipping 143 matching lines @@
 static void
 execute(G *gp)
 {
         int32 hz;
 
         if(gp->status != Grunnable) {
                 runtime·printf("execute: bad g status %d\n", gp->status);
                 runtime·throw("execute: bad g status");
         }
         gp->status = Grunning;
+        gp->waitsince = 0;
         gp->preempt = false;
         gp->stackguard0 = gp->stackguard;
         m->p->schedtick++;
         m->curg = gp;
         gp->m = m;
 
         // Check whether the profiler needs to be turned on or off.
         hz = runtime·sched.profilehz;
         if(m->profilehz != hz)
                 runtime·resetcpuprofiler(hz);
@@ skipping 403 matching lines @@
 // from the low-level system calls used by the runtime.
 #pragma textflag NOSPLIT
 void
 runtime·exitsyscall(void)
 {
         m->locks++;  // see comment in entersyscall
 
         if(g->isbackground)  // do not consider blocked scavenger for deadlock detection
                 incidlelocked(-1);
 
+        g->waitsince = 0;
         if(exitsyscallfast()) {
                 // There's a cpu for us, so we can run.
                 m->p->syscalltick++;
                 g->status = Grunning;
                 // Garbage collector isn't running (since we are),
                 // so okay to clear gcstack and gcsp.
                 g->syscallstack = (uintptr)nil;
                 g->syscallsp = (uintptr)nil;
                 m->locks--;
                 if(g->preempt) {
@@ skipping 661 matching lines @@
                         p->id = i;
                         p->status = Pgcstop;
                         runtime·atomicstorep(&runtime·allp[i], p);
                 }
                 if(p->mcache == nil) {
                         if(old==0 && i==0)
                                 p->mcache = m->mcache;  // bootstrap
                         else
                                 p->mcache = runtime·allocmcache();
                 }
-                if(p->runq == nil) {
-                        p->runqsize = 128;
-                        p->runq = (G**)runtime·mallocgc(p->runqsize*sizeof(G*), 0, FlagNoInvokeGC);
-                }
         }
 
         // redistribute runnable G's evenly
+        // collect all runnable goroutines in global queue
         for(i = 0; i < old; i++) {
                 p = runtime·allp[i];
                 while(gp = runqget(p))
                         globrunqput(gp);
         }
+        // fill local queues with at most nelem(p->runq)/2 goroutines
         // start at 1 because current M already executes some G and will acquire allp[0] below,
         // so if we have a spare G we want to put it into allp[1].
-        for(i = 1; runtime·sched.runqhead; i++) {
+        for(i = 1; i < new * nelem(p->runq)/2 && runtime·sched.runqsize > 0; i++) {
                 gp = runtime·sched.runqhead;
                 runtime·sched.runqhead = gp->schedlink;
+                if(runtime·sched.runqhead == nil)
+                        runtime·sched.runqtail = nil;
+                runtime·sched.runqsize--;
                 runqput(runtime·allp[i%new], gp);
         }
-        runtime·sched.runqtail = nil;
-        runtime·sched.runqsize = 0;
 
         // free unused P's
         for(i = new; i < old; i++) {
                 p = runtime·allp[i];
                 runtime·freemcache(p->mcache);
                 p->mcache = nil;
                 gfpurge(p);
                 p->status = Pdead;
                 // can't free P itself because it can be referenced by an M in syscall
         }
@@ skipping 268 matching lines @@
         gp->stackguard0 = StackPreempt;
         return true;
 }
 
 void
 runtime·schedtrace(bool detailed)
 {
         static int64 starttime;
         int64 now;
         int64 id1, id2, id3;
-        int32 i, q, t, h, s;
+        int32 i, t, h;
         int8 *fmt;
         M *mp, *lockedm;
         G *gp, *lockedg;
         P *p;
 
         now = runtime·nanotime();
         if(starttime == 0)
                 starttime = now;
 
         runtime·lock(&runtime·sched);
         runtime·printf("SCHED %Dms: gomaxprocs=%d idleprocs=%d threads=%d idlethreads=%d runqueue=%d",
                 (now-starttime)/1000000, runtime·gomaxprocs, runtime·sched.npidle, runtime·sched.mcount,
                 runtime·sched.nmidle, runtime·sched.runqsize);
         if(detailed) {
                 runtime·printf(" gcwaiting=%d nmidlelocked=%d nmspinning=%d stopwait=%d sysmonwait=%d\n",
                         runtime·sched.gcwaiting, runtime·sched.nmidlelocked, runtime·sched.nmspinning,
                         runtime·sched.stopwait, runtime·sched.sysmonwait);
         }
         // We must be careful while reading data from P's, M's and G's.
         // Even if we hold schedlock, most data can be changed concurrently.
         // E.g. (p->m ? p->m->id : -1) can crash if p->m changes from non-nil to nil.
         for(i = 0; i < runtime·gomaxprocs; i++) {
                 p = runtime·allp[i];
                 if(p == nil)
                         continue;
                 mp = p->m;
-                t = p->runqtail;
-                h = p->runqhead;
-                s = p->runqsize;
-                q = t - h;
-                if(q < 0)
-                        q += s;
+                h = runtime·atomicload(&p->runqhead);
+                t = runtime·atomicload(&p->runqtail);
                 if(detailed)
-                        runtime·printf("  P%d: status=%d schedtick=%d syscalltick=%d m=%d runqsize=%d/%d gfreecnt=%d\n",
-                                i, p->status, p->schedtick, p->syscalltick, mp ? mp->id : -1, q, s, p->gfreecnt);
+                        runtime·printf("  P%d: status=%d schedtick=%d syscalltick=%d m=%d runqsize=%d gfreecnt=%d\n",
+                                i, p->status, p->schedtick, p->syscalltick, mp ? mp->id : -1, t-h, p->gfreecnt);
                 else {
                         // In non-detailed mode format lengths of per-P run queues as:
                         // [len1 len2 len3 len4]
                         fmt = " %d";
                         if(runtime·gomaxprocs == 1)
                                 fmt = " [%d]\n";
                         else if(i == 0)
                                 fmt = " [%d";
                         else if(i == runtime·gomaxprocs-1)
                                 fmt = " %d]\n";
-                        runtime·printf(fmt, q);
+                        runtime·printf(fmt, t-h);
                 }
         }
         if(!detailed) {
                 runtime·unlock(&runtime·sched);
                 return;
         }
         for(mp = runtime·allm; mp; mp = mp->alllink) {
                 p = mp->p;
                 gp = mp->curg;
                 lockedg = mp->lockedg;
@@ skipping 54 matching lines @@
 {
         gp->schedlink = nil;
         if(runtime·sched.runqtail)
                 runtime·sched.runqtail->schedlink = gp;
         else
                 runtime·sched.runqhead = gp;
         runtime·sched.runqtail = gp;
         runtime·sched.runqsize++;
 }
 
+// Put a batch of runnable goroutines on the global runnable queue.
+// Sched must be locked.
+static void
+globrunqputbatch(G *ghead, G *gtail, int32 n)
+{
+        gtail->schedlink = nil;
+        if(runtime·sched.runqtail)
+                runtime·sched.runqtail->schedlink = ghead;
+        else
+                runtime·sched.runqhead = ghead;
+        runtime·sched.runqtail = gtail;
+        runtime·sched.runqsize += n;
+}
+
 // Try get a batch of G's from the global runnable queue.
 // Sched must be locked.
 static G*
 globrunqget(P *p, int32 max)
 {
         G *gp, *gp1;
         int32 n;
 
         if(runtime·sched.runqsize == 0)
                 return nil;
         n = runtime·sched.runqsize/runtime·gomaxprocs+1;
         if(n > runtime·sched.runqsize)
                 n = runtime·sched.runqsize;
         if(max > 0 && n > max)
                 n = max;
+        if(n > nelem(p->runq)/2)
+                n = nelem(p->runq)/2;
         runtime·sched.runqsize -= n;
         if(runtime·sched.runqsize == 0)
                 runtime·sched.runqtail = nil;
         gp = runtime·sched.runqhead;
         runtime·sched.runqhead = gp->schedlink;
         n--;
         while(n--) {
                 gp1 = runtime·sched.runqhead;
                 runtime·sched.runqhead = gp1->schedlink;
                 runqput(p, gp1);
@@ skipping 19 matching lines @@
         P *p;
 
         p = runtime·sched.pidle;
         if(p) {
                 runtime·sched.pidle = p->link;
                 runtime·xadd(&runtime·sched.npidle, -1);  // TODO: fast atomic
         }
         return p;
 }
 
-// Put g on local runnable queue.
-// TODO(dvyukov): consider using lock-free queue.
+// Try to put g on local runnable queue.
+// If it's full, put onto global queue.
+// Executed only by the owner P.
 static void
 runqput(P *p, G *gp)
 {
-        int32 h, t, s;
-
-        runtime·lock(p);
+        uint32 h, t;
+
 retry:
-        h = p->runqhead;
+        h = runtime·atomicload(&p->runqhead);  // load-acquire, synchronize with consumers
         t = p->runqtail;
-        s = p->runqsize;
-        if(t == h-1 || (h == 0 && t == s-1)) {
-                runqgrow(p);
-                goto retry;
-        }
-        p->runq[t++] = gp;
-        if(t == s)
-                t = 0;
-        p->runqtail = t;
-        runtime·unlock(p);
+        if(t - h < nelem(p->runq)) {
+                p->runq[t%nelem(p->runq)] = gp;
+                runtime·atomicstore(&p->runqtail, t+1);  // store-release, makes the item available for consumption
+                return;
+        }
+        if(runqputslow(p, gp, h, t))
+                return;
+        // the queue is not full, now the put above must suceed
+        goto retry;
+}
+
+// Put g and a batch of work from local runnable queue on global queue.
+// Executed only by the owner P.
+static bool
+runqputslow(P *p, G *gp, uint32 h, uint32 t)
+{
+        G *batch[nelem(p->runq)/2+1];
+        uint32 n, i;
+
+        // First, grab a batch from local queue.
+        n = t-h;
+        n = n/2;
+        if(n != nelem(p->runq)/2)
+                runtime·throw("runqputslow: queue is not full");
+        for(i=0; i<n; i++)
+                batch[i] = p->runq[(h+i)%nelem(p->runq)];
+        if(!runtime·cas(&p->runqhead, h, h+n))  // cas-release, commits consume
+                return false;
+        batch[n] = gp;
+        // Link the goroutines.
+        for(i=0; i<n; i++)
+                batch[i]->schedlink = batch[i+1];
+        // Now put the batch on global queue.
+        runtime·lock(&runtime·sched);
+        globrunqputbatch(batch[0], batch[n], n+1);
+        runtime·unlock(&runtime·sched);
+        return true;
 }
 
 // Get g from local runnable queue.
+// Executed only by the owner P.
 static G*
 runqget(P *p)
 {
         G *gp;
-        int32 t, h, s;
-
-        if(p->runqhead == p->runqtail)
-                return nil;
-        runtime·lock(p);
-        h = p->runqhead;
-        t = p->runqtail;
-        s = p->runqsize;
-        if(t == h) {
-                runtime·unlock(p);
-                return nil;
-        }
-        gp = p->runq[h++];
-        if(h == s)
-                h = 0;
-        p->runqhead = h;
-        runtime·unlock(p);
-        return gp;
-}
-
-// Grow local runnable queue.
-// TODO(dvyukov): consider using fixed-size array
-// and transfer excess to the global list (local queue can grow way too big).
-static void
-runqgrow(P *p)
-{
-        G **q;
-        int32 s, t, h, t2;
-
-        h = p->runqhead;
-        t = p->runqtail;
-        s = p->runqsize;
-        t2 = 0;
-        q = runtime·malloc(2*s*sizeof(*q));
-        while(t != h) {
-                q[t2++] = p->runq[h++];
-                if(h == s)
-                        h = 0;
-        }
-        runtime·free(p->runq);
-        p->runq = q;
-        p->runqhead = 0;
-        p->runqtail = t2;
-        p->runqsize = 2*s;
+        uint32 t, h;
+
+        for(;;) {
+                h = runtime·atomicload(&p->runqhead);  // load-acquire, synchronize with other consumers
+                t = p->runqtail;
+                if(t == h)
+                        return nil;
+                gp = p->runq[h%nelem(p->runq)];
+                if(runtime·cas(&p->runqhead, h, h+1))  // cas-release, commits consume
+                        return gp;
+        }
+}
+
+// Grabs a batch of goroutines from local runnable queue.
+// batch array must be of size nelem(p->runq)/2. Returns number of grabbed goroutines.
+// Can be executed by any P.
+static uint32
+runqgrab(P *p, G **batch)
+{
+        uint32 t, h, n, i;
+
+        for(;;) {
+                h = runtime·atomicload(&p->runqhead);  // load-acquire, synchronize with other consumers
+                t = runtime·atomicload(&p->runqtail);  // load-acquire, synchronize with the producer
+                n = t-h;
+                n = n - n/2;
+                if(n == 0)
+                        break;
+                if(n > nelem(p->runq)/2)  // read inconsistent h and t
+                        continue;
+                for(i=0; i<n; i++)
+                        batch[i] = p->runq[(h+i)%nelem(p->runq)];
+                if(runtime·cas(&p->runqhead, h, h+n))  // cas-release, commits consume
+                        break;
+        }
+        return n;
 }
 
 // Steal half of elements from local runnable queue of p2
 // and put onto local runnable queue of p.
 // Returns one of the stolen elements (or nil if failed).
 static G*
 runqsteal(P *p, P *p2)
 {
-        G *gp, *gp1;
-        int32 t, h, s, t2, h2, s2, c, i;
-
-        if(p2->runqhead == p2->runqtail)
+        G *gp;
+        G *batch[nelem(p->runq)/2];
+        uint32 t, h, n, i;
+
+        n = runqgrab(p2, batch);
+        if(n == 0)
                 return nil;
-        // sort locks to prevent deadlocks
-        if(p < p2)
-                runtime·lock(p);
-        runtime·lock(p2);
-        if(p2->runqhead == p2->runqtail) {
-                runtime·unlock(p2);
-                if(p < p2)
-                        runtime·unlock(p);
-                return nil;
-        }
-        if(p >= p2)
-                runtime·lock(p);
-        // now we've locked both queues and know the victim is not empty
-        h = p->runqhead;
+        n--;
+        gp = batch[n];
+        if(n == 0)
+                return gp;
+        h = runtime·atomicload(&p->runqhead);  // load-acquire, synchronize with consumers
         t = p->runqtail;
-        s = p->runqsize;
-        h2 = p2->runqhead;
-        t2 = p2->runqtail;
-        s2 = p2->runqsize;
-        gp = p2->runq[h2++];  // return value
-        if(h2 == s2)
-                h2 = 0;
-        // steal roughly half
-        if(t2 > h2)
-                c = (t2 - h2) / 2;
-        else
-                c = (s2 - h2 + t2) / 2;
-        // copy
-        for(i = 0; i != c; i++) {
-                // the target queue is full?
-                if(t == h-1 || (h == 0 && t == s-1))
-                        break;
-                // the victim queue is empty?
-                if(t2 == h2)
-                        break;
-                gp1 = p2->runq[h2++];
-                if(h2 == s2)
-                        h2 = 0;
-                p->runq[t++] = gp1;
-                if(t == s)
-                        t = 0;
-        }
-        p->runqtail = t;
-        p2->runqhead = h2;
-        runtime·unlock(p2);
-        runtime·unlock(p);
+        if(t - h + n >= nelem(p->runq))
+                runtime·throw("runqsteal: runq overflow");
+        for(i=0; i<n; i++, t++)
+                p->runq[t%nelem(p->runq)] = batch[i];
+        runtime·atomicstore(&p->runqtail, t);  // store-release, makes the item available for consumption
         return gp;
 }
 
 void
 runtime·testSchedLocalQueue(void)
 {
         P p;
-        G gs[1000];
+        G gs[nelem(p.runq)];
         int32 i, j;
 
         runtime·memclr((byte*)&p, sizeof(p));
-        p.runqsize = 1;
-        p.runqhead = 0;
-        p.runqtail = 0;
-        p.runq = runtime·malloc(p.runqsize*sizeof(*p.runq));
 
         for(i = 0; i < nelem(gs); i++) {
                 if(runqget(&p) != nil)
                         runtime·throw("runq is not empty initially");
                 for(j = 0; j < i; j++)
                         runqput(&p, &gs[i]);
                 for(j = 0; j < i; j++) {
                         if(runqget(&p) != &gs[i]) {
                                 runtime·printf("bad element at iter %d/%d\n", i, j);
                                 runtime·throw("bad element");
                         }
                 }
                 if(runqget(&p) != nil)
                         runtime·throw("runq is not empty afterwards");
         }
 }
 
 void
 runtime·testSchedLocalQueueSteal(void)
 {
         P p1, p2;
-        G gs[1000], *gp;
+        G gs[nelem(p1.runq)], *gp;
         int32 i, j, s;
 
         runtime·memclr((byte*)&p1, sizeof(p1));
-        p1.runqsize = 1;
-        p1.runqhead = 0;
-        p1.runqtail = 0;
-        p1.runq = runtime·malloc(p1.runqsize*sizeof(*p1.runq));
-
         runtime·memclr((byte*)&p2, sizeof(p2));
-        p2.runqsize = nelem(gs);
-        p2.runqhead = 0;
-        p2.runqtail = 0;
-        p2.runq = runtime·malloc(p2.runqsize*sizeof(*p2.runq));
 
         for(i = 0; i < nelem(gs); i++) {
                 for(j = 0; j < i; j++) {
                         gs[j].sig = 0;
                         runqput(&p1, &gs[j]);
                 }
                 gp = runqsteal(&p2, &p1);
                 s = 0;
                 if(gp) {
                         s++;
@@ skipping 57 matching lines @@
                                 if(experiment[i+j] != name[j])
                                         goto nomatch;
                         if(experiment[i+j] != '\0' && experiment[i+j] != ',')
                                 goto nomatch;
                         return 1;
                 }
         nomatch:;
         }
         return 0;
 }