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

src/pkg/runtime/mgc0.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.
 
 // Garbage collector (GC).
 //
 // GC is:
 // - mark&sweep
 // - mostly precise (with the exception of some C-allocated objects, assembly frames/arguments, etc)
 // - parallel (up to MaxGcproc threads)
@@ skipping 89 matching lines @@
         // clear sync.Pool's
         if(poolcleanup != nil)
                 reflect·call(poolcleanup, nil, 0, 0);
 
         for(pp=runtime·allp; p=*pp; pp++) {
                 // clear tinyalloc pool
                 c = p->mcache;
                 if(c != nil) {
                         c->tiny = nil;
                         c->tinysize = 0;
+                        c->sudogcache = nil;
                 }
                 // clear defer pools
                 for(i=0; i<nelem(p->deferpool); i++)
                         p->deferpool[i] = nil;
         }
 }
 
 // Holding worldsema grants an M the right to try to stop the world.
 // The procedure is:
 //
@@ skipping 983 matching lines @@
                 }
                 runtime·lock(&gclock);
                 if(!runtime·mheap.sweepdone) {
                         // It's possible if GC has happened between sweepone has
                         // returned -1 and gclock lock.
                         runtime·unlock(&gclock);
                         continue;
                 }
                 sweep.parked = true;
                 g->isbackground = true;
-                runtime·parkunlock(&gclock, "GC sweep wait");
+                runtime·parkunlock(&gclock, runtime·gostringnocopy((byte*)"GC sweep wait"));
                 g->isbackground = false;
         }
 }
 
 // sweeps one span
 // returns number of pages returned to heap, or -1 if there is nothing to sweep
 uintptr
 runtime·sweepone(void)
 {
         MSpan *s;
@@ skipping 243 matching lines @@
         // we're currently running on will no longer change.  Cuts
         // the root set down a bit (g0 stacks are not scanned, and
         // we don't need to scan gc's internal state).  Also an
         // enabler for copyable stacks.
         for(i = 0; i < (runtime·debug.gctrace > 1 ? 2 : 1); i++) {
                 if(i > 0)
                         a.start_time = runtime·nanotime();
                 // switch to g0, call gc(&a), then switch back
                 g->param = &a;
                 g->status = Gwaiting;
-                g->waitreason = "garbage collection";
+                g->waitreason = runtime·gostringnocopy((byte*)"garbage collection");
                 runtime·mcall(mgc);
         }
 
         // all done
         g->m->gcing = 0;
         g->m->locks++;
         runtime·semrelease(&runtime·worldsema);
         runtime·starttheworld();
         g->m->locks--;
 
@@ skipping 14 matching lines @@
 }
 
 void
 runtime·gc_m(void)
 {
         struct gc_args a;
         G *gp;
 
         gp = g->m->curg;
         gp->status = Gwaiting;
-        gp->waitreason = "garbage collection";
+        gp->waitreason = runtime·gostringnocopy((byte*)"garbage collection");
 
         a.start_time = (uint64)(g->m->scalararg[0]) | ((uint64)(g->m->scalararg[1]) << 32);
         a.eagersweep = g->m->scalararg[2];
         gc(&a);
 
         gp->status = Grunning;
 }
 
 static void
 gc(struct gc_args *args)
@@ skipping 233 matching lines @@
         USED(&ef);
         USED(&ef1);
 
         for(;;) {
                 runtime·lock(&finlock);
                 fb = finq;
                 finq = nil;
                 if(fb == nil) {
                         runtime·fingwait = true;
                         g->isbackground = true;
-                        runtime·parkunlock(&finlock, "finalizer wait");
+                        runtime·parkunlock(&finlock, runtime·gostringnocopy((byte*)"finalizer wait"));
                         g->isbackground = false;
                         continue;
                 }
                 runtime·unlock(&finlock);
                 if(raceenabled)
                         runtime·racefingo();
                 for(; fb; fb=next) {
                         next = fb->next;
                         for(i=0; i<fb->cnt; i++) {
                                 f = &fb->fin[i];
@@ skipping 423 matching lines @@
                 n = ((PtrType*)t)->elem->size;
                 *len = n/PtrSize;
                 *mask = runtime·mallocgc(*len, nil, 0);
                 for(i = 0; i < n; i += PtrSize) {
                         off = (p+i-frame.varp+size)/PtrSize;
                         bits = (bv.data[off*BitsPerPointer/32] >> ((off*BitsPerPointer)%32))&BitsMask;
                         (*mask)[i/PtrSize] = bits;
                 }
         }
 }