code review 104200047: runtime: stack allocator, separate from mallocgc

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 125 matching lines @@
 //      call runtime·mstart
 //
 // The new G calls runtime·main.
 void
 runtime·schedinit(void)
 {
         int32 n, procs;
         byte *p;
         Eface i;
 
+        // raceinit must be the first call to race detector.
+        // 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();
-        mcommoninit(m);
+        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);
@@ skipping 12 matching lines @@
         }
         runtime·allp = runtime·malloc((MaxGomaxprocs+1)*sizeof(runtime·allp[0]));
         procresize(procs);
 
         runtime·copystack = runtime·precisestack;
         p = runtime·getenv("GOCOPYSTACK");
         if(p != nil && !runtime·strcmp(p, (byte*)"0"))
                 runtime·copystack = false;
 
         mstats.enablegc = 1;
-
-        if(raceenabled)
-                g->racectx = runtime·raceinit();
 }
 
 extern void main·init(void);
 extern void main·main(void);
 
 static FuncVal scavenger = {runtime·MHeap_Scavenger};
 
 static FuncVal initDone = { runtime·unlockOSThread };
 
 // The main goroutine.
@@ skipping 30 matching lines @@
         runtime·lockOSThread();
 ········
         // Defer unlock so that runtime.Goexit during init does the unlock too.
         d.fn = &initDone;
         d.siz = 0;
         d.link = g->defer;
         d.argp = NoArgs;
         d.special = true;
         g->defer = &d;
 
-        if(m != &runtime·m0)
+        if(g->m != &runtime·m0)
                 runtime·throw("runtime·main not on m0");
         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();
@@ skipping 40 matching lines @@
         default:
                 status = "???";
                 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);
 
-        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);
+        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)
 {
         G *gp;
         int32 traceback;
         uintptr i;
 
         traceback = runtime·gotraceback(nil);
 ········
         // Show the current goroutine first, if we haven't already.
-        if((gp = m->curg) != nil && gp != me) {
+        if((gp = g->m->curg) != nil && gp != me) {
                 runtime·printf("\n");
                 runtime·goroutineheader(gp);
                 runtime·traceback(~(uintptr)0, ~(uintptr)0, 0, gp);
         }
 
         runtime·lock(&allglock);
         for(i = 0; i < runtime·allglen; i++) {
                 gp = runtime·allg[i];
-                if(gp == me || gp == m->curg || gp->status == Gdead)
+                if(gp == me || gp == g->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(~(uintptr)0, ~(uintptr)0, 0, gp);
         }
         runtime·unlock(&allglock);
 }
 
 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");
         }
 }
 
 static void
 mcommoninit(M *mp)
 {
         // If there is no mcache runtime·callers() will crash,
         // and we are most likely in sysmon thread so the stack is senseless anyway.
-        if(m->mcache)
+        if(g->m->mcache)
                 runtime·callers(1, mp->createstack, nelem(mp->createstack));
 
         mp->fastrand = 0x49f6428aUL + mp->id + runtime·cputicks();
 
         runtime·lock(&runtime·sched);
         mp->id = runtime·sched.mcount++;
         checkmcount();
         runtime·mpreinit(mp);
 
-        // Add to runtime·allm so garbage collector doesn't free m
+        // Add to runtime·allm so garbage collector doesn't free g->m
         // when it is just in a register or thread-local storage.
         mp->alllink = runtime·allm;
         // runtime·NumCgoCall() iterates over allm w/o schedlock,
         // so we need to publish it safely.
         runtime·atomicstorep(&runtime·allm, mp);
         runtime·unlock(&runtime·sched);
 }
 
 // Mark gp ready to run.
 void
 runtime·ready(G *gp)
 {
         // Mark runnable.
-        m->locks++;  // disable preemption because it can be holding p in a local var
+        g->m->locks++;  // disable preemption because it can be holding p in a local var
         if(gp->status != Gwaiting) {
                 runtime·printf("goroutine %D has status %d\n", gp->goid, gp->status);
                 runtime·throw("bad g->status in ready");
         }
         gp->status = Grunnable;
-        runqput(m->p, gp);
+        runqput(g->m->p, gp);
         if(runtime·atomicload(&runtime·sched.npidle) != 0 && runtime·atomicload(&runtime·sched.nmspinning) == 0)  // TODO: fast atomic
                 wakep();
-        m->locks--;
-        if(m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
+        g->m->locks--;
+        if(g->m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
                 g->stackguard0 = StackPreempt;
 }
 
 int32
 runtime·gcprocs(void)
 {
         int32 n;
 
         // Figure out how many CPUs to use during GC.
         // Limited by gomaxprocs, number of actual CPUs, and MaxGcproc.
@@ skipping 27 matching lines @@
 
 void
 runtime·helpgc(int32 nproc)
 {
         M *mp;
         int32 n, pos;
 
         runtime·lock(&runtime·sched);
         pos = 0;
         for(n = 1; n < nproc; n++) {  // one M is currently running
-                if(runtime·allp[pos]->mcache == m->mcache)
+                if(runtime·allp[pos]->mcache == g->m->mcache)
                         pos++;
                 mp = mget();
                 if(mp == nil)
                         runtime·throw("runtime·gcprocs inconsistency");
                 mp->helpgc = n;
                 mp->mcache = runtime·allp[pos]->mcache;
                 pos++;
                 runtime·notewakeup(&mp->park);
         }
         runtime·unlock(&runtime·sched);
@@ skipping 33 matching lines @@
         int32 i;
         uint32 s;
         P *p;
         bool wait;
 
         runtime·lock(&runtime·sched);
         runtime·sched.stopwait = runtime·gomaxprocs;
         runtime·atomicstore((uint32*)&runtime·sched.gcwaiting, 1);
         preemptall();
         // stop current P
-        m->p->status = Pgcstop;
+        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];
                 s = p->status;
                 if(s == Psyscall && runtime·cas(&p->status, s, Pgcstop))
                         runtime·sched.stopwait--;
         }
         // stop idle P's
         while(p = pidleget()) {
@@ skipping 19 matching lines @@
         for(i = 0; i < runtime·gomaxprocs; i++) {
                 p = runtime·allp[i];
                 if(p->status != Pgcstop)
                         runtime·throw("stoptheworld: not stopped");
         }
 }
 
 static void
 mhelpgc(void)
 {
-        m->helpgc = -1;
+        g->m->helpgc = -1;
 }
 
 void
 runtime·starttheworld(void)
 {
         P *p, *p1;
         M *mp;
         G *gp;
         bool add;
 
-        m->locks++;  // disable preemption because it can be holding p in a local var
+        g->m->locks++;  // disable preemption because it can be holding p in a local var
         gp = runtime·netpoll(false);  // non-blocking
         injectglist(gp);
         add = needaddgcproc();
         runtime·lock(&runtime·sched);
         if(newprocs) {
                 procresize(newprocs);
                 newprocs = 0;
         } else
                 procresize(runtime·gomaxprocs);
         runtime·sched.gcwaiting = 0;
@@ skipping 36 matching lines @@
         if(add) {
                 // If GC could have used another helper proc, start one now,
                 // in the hope that it will be available next time.
                 // It would have been even better to start it before the collection,
                 // but doing so requires allocating memory, so it's tricky to
                 // coordinate.  This lazy approach works out in practice:
                 // we don't mind if the first couple gc rounds don't have quite
                 // the maximum number of procs.
                 newm(mhelpgc, nil);
         }
-        m->locks--;
-        if(m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
+        g->m->locks--;
+        if(g->m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
                 g->stackguard0 = StackPreempt;
 }
 
 // Called to start an M.
 void
 runtime·mstart(void)
 {
-        if(g != m->g0)
+        if(g != g->m->g0)
                 runtime·throw("bad runtime·mstart");
 
         // Record top of stack for use by mcall.
         // Once we call schedule we're never coming back,
         // so other calls can reuse this stack space.
-        runtime·gosave(&m->g0->sched);
-        m->g0->sched.pc = (uintptr)-1;  // make sure it is never used
-        m->g0->stackguard = m->g0->stackguard0;  // cgo sets only stackguard0, copy it to stackguard
+        runtime·gosave(&g->m->g0->sched);
+        g->m->g0->sched.pc = (uintptr)-1;  // make sure it is never used
+        g->m->g0->stackguard = g->m->g0->stackguard0;  // cgo sets only stackguard0, copy it to stackguard
         runtime·asminit();
         runtime·minit();
 
         // Install signal handlers; after minit so that minit can
         // prepare the thread to be able to handle the signals.
-        if(m == &runtime·m0)
+        if(g->m == &runtime·m0)
                 runtime·initsig();
 ········
-        if(m->mstartfn)
-                m->mstartfn();
-
-        if(m->helpgc) {
-                m->helpgc = 0;
+        if(g->m->mstartfn)
+                g->m->mstartfn();
+
+        if(g->m->helpgc) {
+                g->m->helpgc = 0;
                 stopm();
-        } else if(m != &runtime·m0) {
-                acquirep(m->nextp);
-                m->nextp = nil;
+        } else if(g->m != &runtime·m0) {
+                acquirep(g->m->nextp);
+                g->m->nextp = nil;
         }
         schedule();
 
         // TODO(brainman): This point is never reached, because scheduler
         // does not release os threads at the moment. But once this path
         // is enabled, we must remove our seh here.
 }
 
 // When running with cgo, we call _cgo_thread_start
 // to start threads for us so that we can play nicely with
 // foreign code.
 void (*_cgo_thread_start)(void*);
 
 typedef struct CgoThreadStart CgoThreadStart;
 struct CgoThreadStart
 {
-        M *m;
         G *g;
         uintptr *tls;
         void (*fn)(void);
 };
 
 // Allocate a new m unassociated with any thread.
 // Can use p for allocation context if needed.
 M*
 runtime·allocm(P *p)
 {
         M *mp;
         static Type *mtype;  // The Go type M
 
-        m->locks++;  // disable GC because it can be called from sysmon
-        if(m->p == nil)
+        g->m->locks++;  // disable GC because it can be called from sysmon
+        if(g->m->p == nil)
                 acquirep(p);  // temporarily borrow p for mallocs in this function
         if(mtype == nil) {
                 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 || Solaris || Windows)
                 mp->g0 = runtime·malg(-1);
         else
                 mp->g0 = runtime·malg(8192);
-
-        if(p == m->p)
+        mp->g0->m = mp;
+
+        if(p == g->m->p)
                 releasep();
-        m->locks--;
-        if(m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
+        g->m->locks--;
+        if(g->m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
                 g->stackguard0 = StackPreempt;
 
         return mp;
 }
 
 static G*
 allocg(void)
 {
         G *gp;
         static Type *gtype;
@@ skipping 66 matching lines @@
         // Set needextram when we've just emptied the list,
         // so that the eventual call into cgocallbackg will
         // allocate a new m for the extra list. We delay the
         // allocation until then so that it can be done
         // after exitsyscall makes sure it is okay to be
         // running at all (that is, there's no garbage collection
         // running right now).
         mp->needextram = mp->schedlink == nil;
         unlockextra(mp->schedlink);
 
-        // Install m and g (= m->g0) and set the stack bounds
+        // Install g (= m->g0) and set the stack bounds
         // to match the current stack. We don't actually know
         // how big the stack is, like we don't know how big any
         // scheduling stack is, but we assume there's at least 32 kB,
         // which is more than enough for us.
-        runtime·setmg(mp, mp->g0);
+        runtime·setg(mp->g0);
         g->stackbase = (uintptr)(&x + 1024);
         g->stackguard = (uintptr)(&x - 32*1024);
         g->stackguard0 = g->stackguard;
 
         // Initialize this thread to use the m.
         runtime·asminit();
         runtime·minit();
 }
 
 // newextram allocates an m and puts it on the extra list.
@@ skipping 14 matching lines @@
         gp = runtime·malg(4096);
         gp->sched.pc = (uintptr)runtime·goexit;
         gp->sched.sp = gp->stackbase;
         gp->sched.lr = 0;
         gp->sched.g = gp;
         gp->syscallpc = gp->sched.pc;
         gp->syscallsp = gp->sched.sp;
         gp->syscallstack = gp->stackbase;
         gp->syscallguard = gp->stackguard;
         gp->status = Gsyscall;
+        gp->m = mp;
         mp->curg = gp;
         mp->locked = LockInternal;
         mp->lockedg = gp;
         gp->lockedm = mp;
         gp->goid = runtime·xadd64(&runtime·sched.goidgen, 1);
         if(raceenabled)
                 gp->racectx = runtime·racegostart(runtime·newextram);
         // put on allg for garbage collector
         allgadd(gp);
 
@@ skipping 29 matching lines @@
 void
 runtime·dropm(void)
 {
         M *mp, *mnext;
 
         // Undo whatever initialization minit did during needm.
         runtime·unminit();
 
         // Clear m and g, and return m to the extra list.
         // After the call to setmg we can only call nosplit functions.
-        mp = m;
-        runtime·setmg(nil, nil);
+        mp = g->m;
+        runtime·setg(nil);
 
         mnext = lockextra(true);
         mp->schedlink = mnext;
         unlockextra(mp);
 }
 
 #define MLOCKED ((M*)1)
 
 // lockextra locks the extra list and returns the list head.
 // The caller must unlock the list by storing a new list head
@@ skipping 44 matching lines @@
 
         mp = runtime·allocm(p);
         mp->nextp = p;
         mp->mstartfn = fn;
 
         if(runtime·iscgo) {
                 CgoThreadStart ts;
 
                 if(_cgo_thread_start == nil)
                         runtime·throw("_cgo_thread_start missing");
-                ts.m = mp;
                 ts.g = mp->g0;
                 ts.tls = mp->tls;
                 ts.fn = runtime·mstart;
                 runtime·asmcgocall(_cgo_thread_start, &ts);
                 return;
         }
         runtime·newosproc(mp, (byte*)mp->g0->stackbase);
 }
 
 // Stops execution of the current m until new work is available.
 // Returns with acquired P.
 static void
 stopm(void)
 {
-        if(m->locks)
+        if(g->m->locks)
                 runtime·throw("stopm holding locks");
-        if(m->p)
+        if(g->m->p)
                 runtime·throw("stopm holding p");
-        if(m->spinning) {
-                m->spinning = false;
+        if(g->m->spinning) {
+                g->m->spinning = false;
                 runtime·xadd(&runtime·sched.nmspinning, -1);
         }
 
 retry:
         runtime·lock(&runtime·sched);
-        mput(m);
+        mput(g->m);
         runtime·unlock(&runtime·sched);
-        runtime·notesleep(&m->park);
-        runtime·noteclear(&m->park);
-        if(m->helpgc) {
+        runtime·notesleep(&g->m->park);
+        runtime·noteclear(&g->m->park);
+        if(g->m->helpgc) {
                 runtime·gchelper();
-                m->helpgc = 0;
-                m->mcache = nil;
+                g->m->helpgc = 0;
+                g->m->mcache = nil;
                 goto retry;
         }
-        acquirep(m->nextp);
-        m->nextp = nil;
+        acquirep(g->m->nextp);
+        g->m->nextp = nil;
 }
 
 static void
 mspinning(void)
 {
-        m->spinning = true;
+        g->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 does nothing.
 static void
 startm(P *p, bool spinning)
 {
         M *mp;
         void (*fn)(void);
 
@@ skipping 76 matching lines @@
         startm(nil, true);
 }
 
 // Stops execution of the current m that is locked to a g until the g is runnable again.
 // Returns with acquired P.
 static void
 stoplockedm(void)
 {
         P *p;
 
-        if(m->lockedg == nil || m->lockedg->lockedm != m)
+        if(g->m->lockedg == nil || g->m->lockedg->lockedm != g->m)
                 runtime·throw("stoplockedm: inconsistent locking");
-        if(m->p) {
+        if(g->m->p) {
                 // Schedule another M to run this p.
                 p = releasep();
                 handoffp(p);
         }
         incidlelocked(1);
         // Wait until another thread schedules lockedg again.
-        runtime·notesleep(&m->park);
-        runtime·noteclear(&m->park);
-        if(m->lockedg->status != Grunnable)
+        runtime·notesleep(&g->m->park);
+        runtime·noteclear(&g->m->park);
+        if(g->m->lockedg->status != Grunnable)
                 runtime·throw("stoplockedm: not runnable");
-        acquirep(m->nextp);
-        m->nextp = nil;
+        acquirep(g->m->nextp);
+        g->m->nextp = nil;
 }
 
 // Schedules the locked m to run the locked gp.
 static void
 startlockedm(G *gp)
 {
         M *mp;
         P *p;
 
         mp = gp->lockedm;
-        if(mp == m)
+        if(mp == g->m)
                 runtime·throw("startlockedm: locked to me");
         if(mp->nextp)
                 runtime·throw("startlockedm: m has p");
         // directly handoff current P to the locked m
         incidlelocked(-1);
         p = releasep();
         mp->nextp = p;
         runtime·notewakeup(&mp->park);
         stopm();
 }
 
 // Stops the current m for stoptheworld.
 // Returns when the world is restarted.
 static void
 gcstopm(void)
 {
         P *p;
 
         if(!runtime·sched.gcwaiting)
                 runtime·throw("gcstopm: not waiting for gc");
-        if(m->spinning) {
-                m->spinning = false;
+        if(g->m->spinning) {
+                g->m->spinning = false;
                 runtime·xadd(&runtime·sched.nmspinning, -1);
         }
         p = releasep();
         runtime·lock(&runtime·sched);
         p->status = Pgcstop;
         if(--runtime·sched.stopwait == 0)
                 runtime·notewakeup(&runtime·sched.stopnote);
         runtime·unlock(&runtime·sched);
         stopm();
 }
 
 // Schedules gp to run on the current M.
 // Never returns.
 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;
+        g->m->p->schedtick++;
+        g->m->curg = gp;
+        gp->m = g->m;
 
         // Check whether the profiler needs to be turned on or off.
         hz = runtime·sched.profilehz;
-        if(m->profilehz != hz)
+        if(g->m->profilehz != hz)
                 runtime·resetcpuprofiler(hz);
 
         runtime·gogo(&gp->sched);
 }
 
 // Finds a runnable goroutine to execute.
 // Tries to steal from other P's, get g from global queue, poll network.
 static G*
 findrunnable(void)
 {
         G *gp;
         P *p;
         int32 i;
 
 top:
         if(runtime·sched.gcwaiting) {
                 gcstopm();
                 goto top;
         }
         if(runtime·fingwait && runtime·fingwake && (gp = runtime·wakefing()) != nil)
                 runtime·ready(gp);
         // local runq
-        gp = runqget(m->p);
+        gp = runqget(g->m->p);
         if(gp)
                 return gp;
         // global runq
         if(runtime·sched.runqsize) {
                 runtime·lock(&runtime·sched);
-                gp = globrunqget(m->p, 0);
+                gp = globrunqget(g->m->p, 0);
                 runtime·unlock(&runtime·sched);
                 if(gp)
                         return gp;
         }
         // poll network
         gp = runtime·netpoll(false);  // non-blocking
         if(gp) {
                 injectglist(gp->schedlink);
                 gp->status = Grunnable;
                 return gp;
         }
         // If number of spinning M's >= number of busy P's, block.
         // This is necessary to prevent excessive CPU consumption
         // when GOMAXPROCS>>1 but the program parallelism is low.
-        if(!m->spinning && 2 * runtime·atomicload(&runtime·sched.nmspinning) >= runtime·gomaxprocs - runtime·atomicload(&runtime·sched.npidle))  // TODO: fast atomic
+        if(!g->m->spinning && 2 * runtime·atomicload(&runtime·sched.nmspinning) >= runtime·gomaxprocs - runtime·atomicload(&runtime·sched.npidle))  // TODO: fast atomic
                 goto stop;
-        if(!m->spinning) {
-                m->spinning = true;
+        if(!g->m->spinning) {
+                g->m->spinning = true;
                 runtime·xadd(&runtime·sched.nmspinning, 1);
         }
         // random steal from other P's
         for(i = 0; i < 2*runtime·gomaxprocs; i++) {
                 if(runtime·sched.gcwaiting)
                         goto top;
                 p = runtime·allp[runtime·fastrand1()%runtime·gomaxprocs];
-                if(p == m->p)
+                if(p == g->m->p)
                         gp = runqget(p);
                 else
-                        gp = runqsteal(m->p, p);
+                        gp = runqsteal(g->m->p, p);
                 if(gp)
                         return gp;
         }
 stop:
         // return P and block
         runtime·lock(&runtime·sched);
         if(runtime·sched.gcwaiting) {
                 runtime·unlock(&runtime·sched);
                 goto top;
         }
         if(runtime·sched.runqsize) {
-                gp = globrunqget(m->p, 0);
+                gp = globrunqget(g->m->p, 0);
                 runtime·unlock(&runtime·sched);
                 return gp;
         }
         p = releasep();
         pidleput(p);
         runtime·unlock(&runtime·sched);
-        if(m->spinning) {
-                m->spinning = false;
+        if(g->m->spinning) {
+                g->m->spinning = false;
                 runtime·xadd(&runtime·sched.nmspinning, -1);
         }
         // check all runqueues once again
         for(i = 0; i < runtime·gomaxprocs; i++) {
                 p = runtime·allp[i];
                 if(p && p->runqhead != p->runqtail) {
                         runtime·lock(&runtime·sched);
                         p = pidleget();
                         runtime·unlock(&runtime·sched);
                         if(p) {
                                 acquirep(p);
                                 goto top;
                         }
                         break;
                 }
         }
         // poll network
         if(runtime·xchg64(&runtime·sched.lastpoll, 0) != 0) {
-                if(m->p)
+                if(g->m->p)
                         runtime·throw("findrunnable: netpoll with p");
-                if(m->spinning)
+                if(g->m->spinning)
                         runtime·throw("findrunnable: netpoll with spinning");
                 gp = runtime·netpoll(true);  // block until new work is available
                 runtime·atomicstore64(&runtime·sched.lastpoll, runtime·nanotime());
                 if(gp) {
                         runtime·lock(&runtime·sched);
                         p = pidleget();
                         runtime·unlock(&runtime·sched);
                         if(p) {
                                 acquirep(p);
                                 injectglist(gp->schedlink);
                                 gp->status = Grunnable;
                                 return gp;
                         }
                         injectglist(gp);
                 }
         }
         stopm();
         goto top;
 }
 
 static void
 resetspinning(void)
 {
         int32 nmspinning;
 
-        if(m->spinning) {
-                m->spinning = false;
+        if(g->m->spinning) {
+                g->m->spinning = false;
                 nmspinning = runtime·xadd(&runtime·sched.nmspinning, -1);
                 if(nmspinning < 0)
                         runtime·throw("findrunnable: negative nmspinning");
         } else
                 nmspinning = runtime·atomicload(&runtime·sched.nmspinning);
 
         // M wakeup policy is deliberately somewhat conservative (see nmspinning handling),
         // so see if we need to wakeup another P here.
         if (nmspinning == 0 && runtime·atomicload(&runtime·sched.npidle) > 0)
                 wakep();
@@ skipping 23 matching lines @@
 }
 
 // One round of scheduler: find a runnable goroutine and execute it.
 // Never returns.
 static void
 schedule(void)
 {
         G *gp;
         uint32 tick;
 
-        if(m->locks)
+        if(g->m->locks)
                 runtime·throw("schedule: holding locks");
 
 top:
         if(runtime·sched.gcwaiting) {
                 gcstopm();
                 goto top;
         }
 
         gp = nil;
         // Check the global runnable queue once in a while to ensure fairness.
         // Otherwise two goroutines can completely occupy the local runqueue
         // by constantly respawning each other.
-        tick = m->p->schedtick;
+        tick = g->m->p->schedtick;
         // This is a fancy way to say tick%61==0,
         // it uses 2 MUL instructions instead of a single DIV and so is faster on modern processors.
         if(tick - (((uint64)tick*0x4325c53fu)>>36)*61 == 0 && runtime·sched.runqsize > 0) {
                 runtime·lock(&runtime·sched);
-                gp = globrunqget(m->p, 1);
+                gp = globrunqget(g->m->p, 1);
                 runtime·unlock(&runtime·sched);
                 if(gp)
                         resetspinning();
         }
         if(gp == nil) {
-                gp = runqget(m->p);
-                if(gp && m->spinning)
+                gp = runqget(g->m->p);
+                if(gp && g->m->spinning)
                         runtime·throw("schedule: spinning with local work");
         }
         if(gp == nil) {
                 gp = findrunnable();  // blocks until work is available
                 resetspinning();
         }
 
         if(gp->lockedm) {
                 // Hands off own p to the locked m,
                 // then blocks waiting for a new p.
                 startlockedm(gp);
                 goto top;
         }
 
         execute(gp);
 }
 
 // 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)
 {
         if(g->status != Grunning)
                 runtime·throw("bad g status");
-        m->waitlock = lock;
-        m->waitunlockf = unlockf;
+        g->m->waitlock = lock;
+        g->m->waitunlockf = unlockf;
         g->waitreason = reason;
         runtime·mcall(park0);
 }
 
 static bool
 parkunlock(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·park(parkunlock, lock, reason);
 }
 
 // runtime·park continuation on g0.
 static void
 park0(G *gp)
 {
         bool ok;
 
         gp->status = Gwaiting;
         gp->m = nil;
-        m->curg = nil;
-        if(m->waitunlockf) {
-                ok = m->waitunlockf(gp, m->waitlock);
-                m->waitunlockf = nil;
-                m->waitlock = nil;
+        g->m->curg = nil;
+        if(g->m->waitunlockf) {
+                ok = g->m->waitunlockf(gp, g->m->waitlock);
+                g->m->waitunlockf = nil;
+                g->m->waitlock = nil;
                 if(!ok) {
                         gp->status = Grunnable;
                         execute(gp);  // Schedule it back, never returns.
                 }
         }
-        if(m->lockedg) {
+        if(g->m->lockedg) {
                 stoplockedm();
                 execute(gp);  // Never returns.
         }
         schedule();
 }
 
 // Scheduler yield.
 void
 runtime·gosched(void)
 {
         if(g->status != Grunning)
                 runtime·throw("bad g status");
         runtime·mcall(runtime·gosched0);
 }
 
 // runtime·gosched continuation on g0.
 void
 runtime·gosched0(G *gp)
 {
         gp->status = Grunnable;
         gp->m = nil;
-        m->curg = nil;
+        g->m->curg = nil;
         runtime·lock(&runtime·sched);
         globrunqput(gp);
         runtime·unlock(&runtime·sched);
-        if(m->lockedg) {
+        if(g->m->lockedg) {
                 stoplockedm();
                 execute(gp);  // Never returns.
         }
         schedule();
 }
 
 // Finishes execution of the current goroutine.
 // Need to mark it as nosplit, because it runs with sp > stackbase (as runtime·lessstack).
 // Since it does not return it does not matter.  But if it is preempted
 // at the split stack check, GC will complain about inconsistent sp.
@@ skipping 15 matching lines @@
         gp->status = Gdead;
         gp->m = nil;
         gp->lockedm = 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->param = nil;
-        m->curg = nil;
-        m->lockedg = nil;
-        if(m->locked & ~LockExternal) {
-                runtime·printf("invalid m->locked = %d\n", m->locked);
+        g->m->curg = nil;
+        g->m->lockedg = nil;
+        if(g->m->locked & ~LockExternal) {
+                runtime·printf("invalid m->locked = %d\n", g->m->locked);
                 runtime·throw("internal lockOSThread error");
         }·······
-        m->locked = 0;
+        g->m->locked = 0;
         runtime·unwindstack(gp, nil);
-        gfput(m->p, gp);
+        gfput(g->m->p, gp);
         schedule();
 }
 
 #pragma textflag NOSPLIT
 static void
 save(void *pc, uintptr sp)
 {
         g->sched.pc = (uintptr)pc;
         g->sched.sp = sp;
         g->sched.lr = 0;
         g->sched.ret = 0;
         g->sched.ctxt = 0;
         g->sched.g = g;
 }
 
 // The goroutine g is about to enter a system call.
 // Record that it's not using the cpu anymore.
 // This is called only from the go syscall library and cgocall,
 // not from the low-level system calls used by the runtime.
 //
 // Entersyscall cannot split the stack: the runtime·gosave must
 // make g->sched refer to the caller's stack segment, because
 // entersyscall is going to return immediately after.
 #pragma textflag NOSPLIT
 void
 ·entersyscall(int32 dummy)
 {
         // Disable preemption because during this function g is in Gsyscall status,
         // but can have inconsistent g->sched, do not let GC observe it.
-        m->locks++;
+        g->m->locks++;
 
         // Leave SP around for GC and traceback.
         save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
         g->syscallsp = g->sched.sp;
         g->syscallpc = g->sched.pc;
         g->syscallstack = g->stackbase;
         g->syscallguard = g->stackguard;
         g->status = Gsyscall;
         if(g->syscallsp < g->syscallguard-StackGuard || g->syscallstack < g->syscallsp) {
                 // runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
                 //      g->syscallsp, g->syscallguard-StackGuard, g->syscallstack);
                 runtime·throw("entersyscall");
         }
 
         if(runtime·atomicload(&runtime·sched.sysmonwait)) {  // TODO: fast atomic
                 runtime·lock(&runtime·sched);
                 if(runtime·atomicload(&runtime·sched.sysmonwait)) {
                         runtime·atomicstore(&runtime·sched.sysmonwait, 0);
                         runtime·notewakeup(&runtime·sched.sysmonnote);
                 }
                 runtime·unlock(&runtime·sched);
                 save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
         }
 
-        m->mcache = nil;
-        m->p->m = nil;
-        runtime·atomicstore(&m->p->status, Psyscall);
+        g->m->mcache = nil;
+        g->m->p->m = nil;
+        runtime·atomicstore(&g->m->p->status, Psyscall);
         if(runtime·sched.gcwaiting) {
                 runtime·lock(&runtime·sched);
-                if (runtime·sched.stopwait > 0 && runtime·cas(&m->p->status, Psyscall, Pgcstop)) {
+                if (runtime·sched.stopwait > 0 && runtime·cas(&g->m->p->status, Psyscall, Pgcstop)) {
                         if(--runtime·sched.stopwait == 0)
                                 runtime·notewakeup(&runtime·sched.stopnote);
                 }
                 runtime·unlock(&runtime·sched);
                 save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
         }
 
         // Goroutines must not split stacks in Gsyscall status (it would corrupt g->sched).
         // We set stackguard to StackPreempt so that first split stack check calls morestack.
         // Morestack detects this case and throws.
         g->stackguard0 = StackPreempt;
-        m->locks--;
+        g->m->locks--;
 }
 
 // The same as runtime·entersyscall(), but with a hint that the syscall is blocking.
 #pragma textflag NOSPLIT
 void
 ·entersyscallblock(int32 dummy)
 {
         P *p;
 
-        m->locks++;  // see comment in entersyscall
+        g->m->locks++;  // see comment in entersyscall
 
         // Leave SP around for GC and traceback.
         save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
         g->syscallsp = g->sched.sp;
         g->syscallpc = g->sched.pc;
         g->syscallstack = g->stackbase;
         g->syscallguard = g->stackguard;
         g->status = Gsyscall;
         if(g->syscallsp < g->syscallguard-StackGuard || g->syscallstack < g->syscallsp) {
                 // runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
                 //      g->syscallsp, g->syscallguard-StackGuard, g->syscallstack);
                 runtime·throw("entersyscallblock");
         }
 
         p = releasep();
         handoffp(p);
         if(g->isbackground)  // do not consider blocked scavenger for deadlock detection
                 incidlelocked(1);
 
         // Resave for traceback during blocked call.
         save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
 
         g->stackguard0 = StackPreempt;  // see comment in entersyscall
-        m->locks--;
+        g->m->locks--;
 }
 
 // The goroutine g exited its system call.
 // Arrange for it to run on a cpu again.
 // This is called only from the go syscall library, not
 // from the low-level system calls used by the runtime.
 #pragma textflag NOSPLIT
 void
 runtime·exitsyscall(void)
 {
-        m->locks++;  // see comment in entersyscall
+        g->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->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--;
+                g->m->locks--;
                 if(g->preempt) {
                         // restore the preemption request in case we've cleared it in newstack
                         g->stackguard0 = StackPreempt;
                 } else {
                         // otherwise restore the real stackguard, we've spoiled it in entersyscall/entersyscallblock
                         g->stackguard0 = g->stackguard;
                 }
                 return;
         }
 
-        m->locks--;
+        g->m->locks--;
 
         // Call the scheduler.
         runtime·mcall(exitsyscall0);
 
         // Scheduler returned, so we're allowed to run now.
         // Delete the gcstack information that we left for
         // the garbage collector during the system call.
         // Must wait until now because until gosched returns
         // we don't know for sure that the garbage collector
         // is not running.
         g->syscallstack = (uintptr)nil;
         g->syscallsp = (uintptr)nil;
-        m->p->syscalltick++;
+        g->m->p->syscalltick++;
 }
 
 #pragma textflag NOSPLIT
 static bool
 exitsyscallfast(void)
 {
         P *p;
 
         // Freezetheworld sets stopwait but does not retake P's.
         if(runtime·sched.stopwait) {
-                m->p = nil;
+                g->m->p = nil;
                 return false;
         }
 
         // Try to re-acquire the last P.
-        if(m->p && m->p->status == Psyscall && runtime·cas(&m->p->status, Psyscall, Prunning)) {
+        if(g->m->p && g->m->p->status == Psyscall && runtime·cas(&g->m->p->status, Psyscall, Prunning)) {
                 // There's a cpu for us, so we can run.
-                m->mcache = m->p->mcache;
-                m->p->m = m;
+                g->m->mcache = g->m->p->mcache;
+                g->m->p->m = g->m;
                 return true;
         }
         // Try to get any other idle P.
-        m->p = nil;
+        g->m->p = nil;
         if(runtime·sched.pidle) {
                 runtime·lock(&runtime·sched);
                 p = pidleget();
                 if(p && runtime·atomicload(&runtime·sched.sysmonwait)) {
                         runtime·atomicstore(&runtime·sched.sysmonwait, 0);
                         runtime·notewakeup(&runtime·sched.sysmonnote);
                 }
                 runtime·unlock(&runtime·sched);
                 if(p) {
                         acquirep(p);
                         return true;
                 }
         }
         return false;
 }
 
 // runtime·exitsyscall slow path on g0.
 // Failed to acquire P, enqueue gp as runnable.
 static void
 exitsyscall0(G *gp)
 {
         P *p;
 
         gp->status = Grunnable;
         gp->m = nil;
-        m->curg = nil;
+        g->m->curg = nil;
         runtime·lock(&runtime·sched);
         p = pidleget();
         if(p == nil)
                 globrunqput(gp);
         else if(runtime·atomicload(&runtime·sched.sysmonwait)) {
                 runtime·atomicstore(&runtime·sched.sysmonwait, 0);
                 runtime·notewakeup(&runtime·sched.sysmonnote);
         }
         runtime·unlock(&runtime·sched);
         if(p) {
                 acquirep(p);
                 execute(gp);  // Never returns.
         }
-        if(m->lockedg) {
+        if(g->m->lockedg) {
                 // Wait until another thread schedules gp and so m again.
                 stoplockedm();
                 execute(gp);  // Never returns.
         }
         stopm();
         schedule();  // Never returns.
 }
 
 // Called from syscall package before fork.
 #pragma textflag NOSPLIT
 void
 syscall·runtime_BeforeFork(void)
 {
         // Fork can hang if preempted with signals frequently enough (see issue 5517).
         // Ensure that we stay on the same M where we disable profiling.
-        m->locks++;
-        if(m->profilehz != 0)
+        g->m->locks++;
+        if(g->m->profilehz != 0)
                 runtime·resetcpuprofiler(0);
 
         // This function is called before fork in syscall package.
         // Code between fork and exec must not allocate memory nor even try to grow stack.
         // Here we spoil g->stackguard to reliably detect any attempts to grow stack.
         // runtime_AfterFork will undo this in parent process, but not in child.
-        m->forkstackguard = g->stackguard;
+        g->m->forkstackguard = g->stackguard;
         g->stackguard0 = StackPreempt-1;
         g->stackguard = StackPreempt-1;
 }
 
 // Called from syscall package after fork in parent.
 #pragma textflag NOSPLIT
 void
 syscall·runtime_AfterFork(void)
 {
         int32 hz;
 
         // See the comment in runtime_BeforeFork.
-        g->stackguard0 = m->forkstackguard;
-        g->stackguard = m->forkstackguard;
-        m->forkstackguard = 0;
+        g->stackguard0 = g->m->forkstackguard;
+        g->stackguard = g->m->forkstackguard;
+        g->m->forkstackguard = 0;
 
         hz = runtime·sched.profilehz;
         if(hz != 0)
                 runtime·resetcpuprofiler(hz);
-        m->locks--;
+        g->m->locks--;
 }
 
 // Hook used by runtime·malg to call runtime·stackalloc on the
 // scheduler stack.  This exists because runtime·stackalloc insists
 // on being called on the scheduler stack, to avoid trying to grow
 // the stack while allocating a new stack segment.
 static void
 mstackalloc(G *gp)
 {
         G *newg;
@@ skipping 14 matching lines @@
         byte *stk;
 
         if(StackTop < sizeof(Stktop)) {
                 runtime·printf("runtime: SizeofStktop=%d, should be >=%d\n", (int32)StackTop, (int32)sizeof(Stktop));
                 runtime·throw("runtime: bad stack.h");
         }
 
         newg = allocg();
         if(stacksize >= 0) {
                 stacksize = runtime·round2(StackSystem + stacksize);
-                if(g == m->g0) {
+                if(g == g->m->g0) {
                         // running on scheduler stack already.
                         stk = runtime·stackalloc(newg, stacksize);
                 } else {
                         // have to call stackalloc on scheduler stack.
                         newg->stacksize = stacksize;
                         g->param = newg;
                         runtime·mcall(mstackalloc);
                         stk = g->param;
                         g->param = nil;
                 }
@@ skipping 32 matching lines @@
 G*
 runtime·newproc1(FuncVal *fn, byte *argp, int32 narg, int32 nret, void *callerpc)
 {
         byte *sp;
         G *newg;
         P *p;
         int32 siz;
 
 //runtime·printf("newproc1 %p %p narg=%d nret=%d\n", fn->fn, argp, narg, nret);
         if(fn == nil) {
-                m->throwing = -1;  // do not dump full stacks
+                g->m->throwing = -1;  // do not dump full stacks
                 runtime·throw("go of nil func value");
         }
-        m->locks++;  // disable preemption because it can be holding p in a local var
+        g->m->locks++;  // disable preemption because it can be holding p in a local var
         siz = narg + nret;
         siz = (siz+7) & ~7;
 
         // We could instead create a secondary stack frame
         // and make it look like goexit was on the original but
         // the call to the actual goroutine function was split.
         // Not worth it: this is almost always an error.
         if(siz > StackMin - 1024)
                 runtime·throw("runtime.newproc: function arguments too large for new goroutine");
 
-        p = m->p;
+        p = g->m->p;
         if((newg = gfget(p)) != nil) {
                 if(newg->stackguard - StackGuard != newg->stack0)
                         runtime·throw("invalid stack in newg");
         } else {
                 newg = runtime·malg(StackMin);
                 allgadd(newg);
         }
 
         sp = (byte*)newg->stackbase;
         sp -= siz;
@@ skipping 16 matching lines @@
                 p->goidcacheend = p->goidcache + GoidCacheBatch;
         }
         newg->goid = p->goidcache++;
         newg->panicwrap = 0;
         if(raceenabled)
                 newg->racectx = runtime·racegostart((void*)callerpc);
         runqput(p, newg);
 
         if(runtime·atomicload(&runtime·sched.npidle) != 0 && runtime·atomicload(&runtime·sched.nmspinning) == 0 && fn->fn != runtime·main)  // TODO: fast atomic
                 wakep();
-        m->locks--;
-        if(m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
+        g->m->locks--;
+        if(g->m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
                 g->stackguard0 = StackPreempt;
         return newg;
 }
 
 static void
 allgadd(G *gp)
 {
         G **new;
         uintptr cap;
 
@@ skipping 26 matching lines @@
 
         if(gp->stackguard - StackGuard != gp->stack0)
                 runtime·throw("invalid stack in gfput");
         stksize = gp->stackbase + sizeof(Stktop) - gp->stack0;
         if(stksize != gp->stacksize) {
                 runtime·printf("runtime: bad stacksize, goroutine %D, remain=%d, last=%d\n",
                         gp->goid, (int32)gp->stacksize, (int32)stksize);
                 runtime·throw("gfput: bad stacksize");
         }
         top = (Stktop*)gp->stackbase;
-        if(stksize != StackMin) {
+        if(stksize != FixedStack) {
                 // non-standard stack size - free it.
                 runtime·stackfree(gp, (void*)gp->stack0, top);
                 gp->stack0 = 0;
                 gp->stackguard = 0;
                 gp->stackguard0 = 0;
                 gp->stackbase = 0;
         }
         gp->schedlink = p->gfree;
         p->gfree = gp;
         p->gfreecnt++;
@@ skipping 31 matching lines @@
                 }
                 runtime·unlock(&runtime·sched.gflock);
                 goto retry;
         }
         if(gp) {
                 p->gfree = gp->schedlink;
                 p->gfreecnt--;
 
                 if(gp->stack0 == 0) {
                         // Stack was deallocated in gfput.  Allocate a new one.
-                        if(g == m->g0) {
+                        if(g == g->m->g0) {
                                 stk = runtime·stackalloc(gp, FixedStack);
                         } else {
                                 gp->stacksize = FixedStack;
                                 g->param = gp;
                                 runtime·mcall(mstackalloc);
                                 stk = g->param;
                                 g->param = nil;
                         }
                         gp->stack0 = (uintptr)stk;
                         gp->stackbase = (uintptr)stk + FixedStack - sizeof(Stktop);
@@ skipping 44 matching lines @@
                 n = MaxGomaxprocs;
         runtime·lock(&runtime·sched);
         ret = runtime·gomaxprocs;
         if(n <= 0 || n == ret) {
                 runtime·unlock(&runtime·sched);
                 return ret;
         }
         runtime·unlock(&runtime·sched);
 
         runtime·semacquire(&runtime·worldsema, false);
-        m->gcing = 1;
+        g->m->gcing = 1;
         runtime·stoptheworld();
         newprocs = n;
-        m->gcing = 0;
+        g->m->gcing = 0;
         runtime·semrelease(&runtime·worldsema);
         runtime·starttheworld();
 
         return ret;
 }
 
 // lockOSThread is called by runtime.LockOSThread and runtime.lockOSThread below
 // after they modify m->locked. Do not allow preemption during this call,
 // or else the m might be different in this function than in the caller.
 #pragma textflag NOSPLIT
 static void
 lockOSThread(void)
 {
-        m->lockedg = g;
-        g->lockedm = m;
+        g->m->lockedg = g;
+        g->lockedm = g->m;
 }
 
 void
 runtime·LockOSThread(void)
 {
-        m->locked |= LockExternal;
+        g->m->locked |= LockExternal;
         lockOSThread();
 }
 
 void
 runtime·lockOSThread(void)
 {
-        m->locked += LockInternal;
+        g->m->locked += LockInternal;
         lockOSThread();
 }
 
 
 // unlockOSThread is called by runtime.UnlockOSThread and runtime.unlockOSThread below
 // after they update m->locked. Do not allow preemption during this call,
 // or else the m might be in different in this function than in the caller.
 #pragma textflag NOSPLIT
 static void
 unlockOSThread(void)
 {
-        if(m->locked != 0)
+        if(g->m->locked != 0)
                 return;
-        m->lockedg = nil;
+        g->m->lockedg = nil;
         g->lockedm = nil;
 }
 
 void
 runtime·UnlockOSThread(void)
 {
-        m->locked &= ~LockExternal;
+        g->m->locked &= ~LockExternal;
         unlockOSThread();
 }
 
 void
 runtime·unlockOSThread(void)
 {
-        if(m->locked < LockInternal)
+        if(g->m->locked < LockInternal)
                 runtime·throw("runtime: internal error: misuse of lockOSThread/unlockOSThread");
-        m->locked -= LockInternal;
+        g->m->locked -= LockInternal;
         unlockOSThread();
 }
 
 bool
 runtime·lockedOSThread(void)
 {
-        return g->lockedm != nil && m->lockedg != nil;
+        return g->lockedm != nil && g->m->lockedg != nil;
 }
 
 int32
 runtime·gcount(void)
 {
         G *gp;
         int32 n, s;
         uintptr i;
 
         n = 0;
@@ skipping 199 matching lines @@
         // Force sane arguments.
         if(hz < 0)
                 hz = 0;
         if(hz == 0)
                 fn = nil;
         if(fn == nil)
                 hz = 0;
 
         // Disable preemption, otherwise we can be rescheduled to another thread
         // that has profiling enabled.
-        m->locks++;
+        g->m->locks++;
 
         // Stop profiler on this thread so that it is safe to lock prof.
         // if a profiling signal came in while we had prof locked,
         // it would deadlock.
         runtime·resetcpuprofiler(0);
 
         runtime·lock(&prof);
         prof.fn = fn;
         prof.hz = hz;
         runtime·unlock(&prof);
         runtime·lock(&runtime·sched);
         runtime·sched.profilehz = hz;
         runtime·unlock(&runtime·sched);
 
         if(hz != 0)
                 runtime·resetcpuprofiler(hz);
 
-        m->locks--;
+        g->m->locks--;
 }
 
 // Change number of processors.  The world is stopped, sched is locked.
 static void
 procresize(int32 new)
 {
         int32 i, old;
         bool empty;
         G *gp;
         P *p;
 
         old = runtime·gomaxprocs;
         if(old < 0 || old > MaxGomaxprocs || new <= 0 || new >MaxGomaxprocs)
                 runtime·throw("procresize: invalid arg");
         // initialize new P's
         for(i = 0; i < new; i++) {
                 p = runtime·allp[i];
                 if(p == nil) {
                         p = (P*)runtime·mallocgc(sizeof(*p), 0, FlagNoInvokeGC);
                         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
+                                p->mcache = g->m->mcache;  // bootstrap
                         else
                                 p->mcache = runtime·allocmcache();
                 }
         }
 
         // redistribute runnable G's evenly
         // collect all runnable goroutines in global queue preserving FIFO order
         // FIFO order is required to ensure fairness even during frequent GCs
         // see http://golang.org/issue/7126
         empty = false;
@@ skipping 30 matching lines @@
         // 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
         }
 
-        if(m->p)
-                m->p->m = nil;
-        m->p = nil;
-        m->mcache = nil;
+        if(g->m->p)
+                g->m->p->m = nil;
+        g->m->p = nil;
+        g->m->mcache = nil;
         p = runtime·allp[0];
         p->m = nil;
         p->status = Pidle;
         acquirep(p);
         for(i = new-1; i > 0; i--) {
                 p = runtime·allp[i];
                 p->status = Pidle;
                 pidleput(p);
         }
         runtime·atomicstore((uint32*)&runtime·gomaxprocs, new);
 }
 
 // Associate p and the current m.
-#pragma textflag NOSPLIT
 static void
 acquirep(P *p)
 {
-        if(m->p || m->mcache)
+        if(g->m->p || g->m->mcache)
                 runtime·throw("acquirep: already in go");
         if(p->m || p->status != Pidle) {
-                //runtime·printf("acquirep: p->m=%p(%d) p->status=%d\n", p->m, p->m ? p->m->id : 0, p->status);
+                runtime·printf("acquirep: p->m=%p(%d) p->status=%d\n", p->m, p->m ? p->m->id : 0, p->status);
                 runtime·throw("acquirep: invalid p state");
         }
-        m->mcache = p->mcache;
-        m->p = p;
-        p->m = m;
+        g->m->mcache = p->mcache;
+        g->m->p = p;
+        p->m = g->m;
         p->status = Prunning;
 }
 
 // Disassociate p and the current m.
 static P*
 releasep(void)
 {
         P *p;
 
-        if(m->p == nil || m->mcache == nil)
+        if(g->m->p == nil || g->m->mcache == nil)
                 runtime·throw("releasep: invalid arg");
-        p = m->p;
-        if(p->m != m || p->mcache != m->mcache || p->status != Prunning) {
+        p = g->m->p;
+        if(p->m != g->m || p->mcache != g->m->mcache || p->status != Prunning) {
                 runtime·printf("releasep: m=%p m->p=%p p->m=%p m->mcache=%p p->mcache=%p p->status=%d\n",
-                        m, m->p, p->m, m->mcache, p->mcache, p->status);
+                        g->m, g->m->p, p->m, g->m->mcache, p->mcache, p->status);
                 runtime·throw("releasep: invalid p state");
         }
-        m->p = nil;
-        m->mcache = nil;
+        g->m->p = nil;
+        g->m->mcache = nil;
         p->m = nil;
         p->status = Pidle;
         return p;
 }
 
 static void
 incidlelocked(int32 v)
 {
         runtime·lock(&runtime·sched);
         runtime·sched.nmidlelocked += v;
@@ skipping 37 matching lines @@
                         grunning++;
                 else if(s == Grunnable || s == Grunning || s == Gsyscall) {
                         runtime·unlock(&allglock);
                         runtime·printf("runtime: checkdead: find g %D in status %d\n", gp->goid, s);
                         runtime·throw("checkdead: runnable g");
                 }
         }
         runtime·unlock(&allglock);
         if(grunning == 0)  // possible if main goroutine calls runtime·Goexit()
                 runtime·throw("no goroutines (main called runtime.Goexit) - deadlock!");
-        m->throwing = -1;  // do not dump full stacks
+        g->m->throwing = -1;  // do not dump full stacks
         runtime·throw("all goroutines are asleep - deadlock!");
 }
 
 static void
 sysmon(void)
 {
         uint32 idle, delay;
         int64 now, lastpoll, lasttrace;
         G *gp;
 
@@ skipping 150 matching lines @@
 // simultaneously executing runtime·newstack.
 // No lock needs to be held.
 // Returns true if preemption request was issued.
 static bool
 preemptone(P *p)
 {
         M *mp;
         G *gp;
 
         mp = p->m;
-        if(mp == nil || mp == m)
+        if(mp == nil || mp == g->m)
                 return false;
         gp = mp->curg;
         if(gp == nil || gp == mp->g0)
                 return false;
         gp->preempt = true;
         gp->stackguard0 = StackPreempt;
         return true;
 }
 
 void
 runtime·schedtrace(bool detailed)
 {
         static int64 starttime;
         int64 now;
         int64 id1, id2, id3;
         int32 i, t, h;
         uintptr gi;
         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",
+        runtime·printf("SCHED %Dms: gomaxprocs=%d idleprocs=%d threads=%d spinningthreads=%d idlethreads=%d runqueue=%d",
                 (now-starttime)/1000000, runtime·gomaxprocs, runtime·sched.npidle, runtime·sched.mcount,
-                runtime·sched.nmidle, runtime·sched.runqsize);
+                runtime·sched.nmspinning, 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·printf(" gcwaiting=%d nmidlelocked=%d stopwait=%d sysmonwait=%d\n",
+                        runtime·sched.gcwaiting, runtime·sched.nmidlelocked,
                         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;
@@ skipping 29 matching lines @@
                 id2 = -1;
                 if(gp)
                         id2 = gp->goid;
                 id3 = -1;
                 if(lockedg)
                         id3 = lockedg->goid;
                 runtime·printf("  M%d: p=%D curg=%D mallocing=%d throwing=%d gcing=%d"
                         " 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, m->blocked, id3);
+                        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",
                         gp->goid, gp->status, gp->waitreason, mp ? mp->id : -1,
                         lockedm ? lockedm->id : -1);
         }
@@ skipping 339 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;
 }