code review 123640043: runtime: convert common scheduler functions to Go

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 140 matching lines @@
         // In particular, it must be done before mallocinit below calls racemapshadow.
         if(raceenabled)
                 g->racectx = runtime·raceinit();
 
         runtime·sched.maxmcount = 10000;
         runtime·precisestack = true; // haveexperiment("precisestack");
 
         runtime·symtabinit();
         runtime·stackinit();
         runtime·mallocinit();
-        runtime·gcinit();
         runtime·chaninit();
         mcommoninit(g->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);
 ········
-        // Initialize the cached gotraceback value, since
-        // gotraceback calls getenv, which mallocs on Plan 9.
-        runtime·gotraceback(nil);
-
         runtime·goargs();
         runtime·goenvs();
         runtime·parsedebugvars();
+        runtime·gcinit();
 
         runtime·sched.lastpoll = runtime·nanotime();
         procs = 1;
         p = runtime·getenv("GOMAXPROCS");
         if(p != nil && (n = runtime·atoi(p)) > 0) {
                 if(n > MaxGomaxprocs)
                         n = MaxGomaxprocs;
                 procs = n;
         }
         runtime·allp = runtime·mallocgc((MaxGomaxprocs+1)*sizeof(runtime·allp[0]), nil, 0);
@@ skipping 74 matching lines @@
 
         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·park(nil, nil, runtime·gostringnocopy((byte*)"panicwait"));
 
         runtime·exit(0);
         for(;;)
                 *(int32*)runtime·main = 0;
 }
 
 void
 runtime·goroutineheader(G *gp)
 {
-        int8 *status;
+        String status;
         int64 waitfor;
 
         switch(gp->status) {
         case Gidle:
-                status = "idle";
+                status = runtime·gostringnocopy((byte*)"idle");
                 break;
         case Grunnable:
-                status = "runnable";
+                status = runtime·gostringnocopy((byte*)"runnable");
                 break;
         case Grunning:
-                status = "running";
+                status = runtime·gostringnocopy((byte*)"running");
                 break;
         case Gsyscall:
-                status = "syscall";
+                status = runtime·gostringnocopy((byte*)"syscall");
                 break;
         case Gwaiting:
-                if(gp->waitreason)
+                if(gp->waitreason.str != nil)
                         status = gp->waitreason;
                 else
-                        status = "waiting";
+                        status = runtime·gostringnocopy((byte*)"waiting");
                 break;
         default:
-                status = "???";
+                status = runtime·gostringnocopy((byte*)"???");
                 break;
         }
 
         // 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);
 
-        runtime·printf("goroutine %D [%s", gp->goid, status);
+        runtime·printf("goroutine %D [%S", gp->goid, status);
         if(waitfor >= 1)
                 runtime·printf(", %D minutes", waitfor);
         if(gp->lockedm != nil)
                 runtime·printf(", locked to thread");
         runtime·printf("]:\n");
 }
 
 void
 runtime·tracebackothers(G *me)
 {
@@ skipping 176 matching lines @@
 }
 
 void
 runtime·stoptheworld(void)
 {
         int32 i;
         uint32 s;
         P *p;
         bool wait;
 
+        // If we hold a lock, then we won't be able to stop another M
+        // that is blocked trying to acquire the lock.
+        if(g->m->locks > 0)
+                runtime·throw("stoptheworld: holding locks");
+        // There is no evidence that stoptheworld on g0 does not work,
+        // we just don't do it today.
+        if(g == g->m->g0)
+                runtime·throw("stoptheworld: on g0");
         runtime·lock(&runtime·sched.lock);
         runtime·sched.stopwait = runtime·gomaxprocs;
         runtime·atomicstore((uint32*)&runtime·sched.gcwaiting, 1);
         preemptall();
         // stop current P
         g->m->p->status = Pgcstop;
         runtime·sched.stopwait--;
         // try to retake all P's in Psyscall status
         for(i = 0; i < runtime·gomaxprocs; i++) {
                 p = runtime·allp[i];
@@ skipping 879 matching lines @@
 {
         if(g->m->lockedg == nil) {
                 g->m->curg->m = nil;
                 g->m->curg = nil;
         }
 }
 
 // Puts the current goroutine into a waiting state and calls unlockf.
 // If unlockf returns false, the goroutine is resumed.
 void
-runtime·park(bool(*unlockf)(G*, void*), void *lock, int8 *reason)
+runtime·park(bool(*unlockf)(G*, void*), void *lock, String reason)
 {
         if(g->status != Grunning)
                 runtime·throw("bad g status");
         g->m->waitlock = lock;
         g->m->waitunlockf = unlockf;
         g->waitreason = reason;
         runtime·mcall(runtime·park_m);
 }
 
 bool
 runtime·parkunlock_c(G *gp, void *lock)
 {
         USED(gp);
         runtime·unlock(lock);
         return true;
 }
 
 // Puts the current goroutine into a waiting state and unlocks the lock.
 // The goroutine can be made runnable again by calling runtime·ready(gp).
 void
-runtime·parkunlock(Lock *lock, int8 *reason)
+runtime·parkunlock(Lock *lock, String reason)
 {
         runtime·park(runtime·parkunlock_c, lock, reason);
 }
 
 // runtime·park continuation on g0.
 void
 runtime·park_m(G *gp)
 {
         bool ok;
 
@@ skipping 56 matching lines @@
 {
         gp->status = Gdead;
         gp->m = nil;
         gp->lockedm = nil;
         g->m->lockedg = nil;
         gp->paniconfault = 0;
         gp->defer = nil; // should be true already but just in case.
         gp->panic = nil; // non-nil for Goexit during panic. points at stack-allocated data.
         gp->writenbuf = 0;
         gp->writebuf = nil;
-        gp->waitreason = nil;
+        gp->waitreason.str = nil;
+        gp->waitreason.len = 0;
         gp->param = nil;
 ········
         dropg();
 
         if(g->m->locked & ~LockExternal) {
                 runtime·printf("invalid m->locked = %d\n", g->m->locked);
                 runtime·throw("internal lockOSThread error");
         }·······
         g->m->locked = 0;
         runtime·unwindstack(gp, nil);
@@ skipping 1299 matching lines @@
                         " locks=%d dying=%d helpgc=%d spinning=%d blocked=%d lockedg=%D\n",
                         mp->id, id1, id2,
                         mp->mallocing, mp->throwing, mp->gcing, mp->locks, mp->dying, mp->helpgc,
                         mp->spinning, g->m->blocked, id3);
         }
         runtime·lock(&allglock);
         for(gi = 0; gi < runtime·allglen; gi++) {
                 gp = runtime·allg[gi];
                 mp = gp->m;
                 lockedm = gp->lockedm;
-                runtime·printf("  G%D: status=%d(%s) m=%d lockedm=%d\n",
+                runtime·printf("  G%D: status=%d(%S) m=%d lockedm=%d\n",
                         gp->goid, gp->status, gp->waitreason, mp ? mp->id : -1,
                         lockedm ? lockedm->id : -1);
         }
         runtime·unlock(&allglock);
         runtime·unlock(&runtime·sched.lock);
 }
 
 // Put mp on midle list.
 // Sched must be locked.
 static void
@@ skipping 333 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;
 }