code review 5334051: runtime: add timer support, use for package time

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.h"
 #include "defs.h"
 #include "malloc.h"
 #include "os.h"
 #include "stack.h"
@@ skipping 720 matching lines @@
 
 typedef struct CgoThreadStart CgoThreadStart;
 struct CgoThreadStart
 {
         M *m;
         G *g;
         void (*fn)(void);
 };
 
 // Kick off new m's as needed (up to mcpumax).
-// There are already `other' other cpus that will
-// start looking for goroutines shortly.
 // Sched is locked.
 static void
 matchmg(void)
 {
         G *gp;
         M *mp;
 
         if(m->mallocing || m->gcing)
                 return;
 
         while(haveg() && canaddmcpu()) {
                 gp = gget();
                 if(gp == nil)
                         runtime·throw("gget inconsistency");
 
                 // Find the m that will run gp.
                 if((mp = mget(gp)) == nil)
                         mp = runtime·newm();
                 mnextg(mp, gp);
         }
 }
 
+// Create a new m.  It will start off with a call to runtime·mstart.
 M*
 runtime·newm(void)
 {
         M *m;
 
         m = runtime·malloc(sizeof(M));
         mcommoninit(m);
 
         if(runtime·iscgo) {
                 CgoThreadStart ts;
@@ skipping 212 matching lines @@
 
         // Gosched 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->gcstack = nil;
 }
 
+// Called from runtime·lessstack when returning from a function which
+// allocated a new stack segment.  The function's return value is in
+// m->cret.
 void
 runtime·oldstack(void)
 {
         Stktop *top, old;
         uint32 argsize;
         byte *sp;
         G *g1;
         int32 goid;
 
 //printf("oldstack m->cret=%p\n", m->cret);
@@ skipping 11 matching lines @@
         USED(goid);
 
         if(old.free != 0)
                 runtime·stackfree(g1->stackguard - StackGuard, old.free);
         g1->stackbase = old.stackbase;
         g1->stackguard = old.stackguard;
 
         runtime·gogo(&old.gobuf, m->cret);
 }
 
+// Called from reflect·call or from runtime·morestack when a new
+// stack segment is needed.  Allocate a new stack big enough for
+// m->moreframesize bytes, copy m->moreargsize bytes to the new frame,
+// and then act as though runtime·lessstack called the function at
+// m->morepc.
 void
 runtime·newstack(void)
 {
         int32 framesize, argsize;
         Stktop *top;
         byte *stk, *sp;
         G *g1;
         Gobuf label;
         bool reflectcall;
         uintptr free;
@@ skipping 67 matching lines @@
         // Continue as if lessstack had just called m->morepc
         // (the PC that decided to grow the stack).
         label.sp = sp;
         label.pc = (byte*)runtime·lessstack;
         label.g = m->curg;
         runtime·gogocall(&label, m->morepc);
 
         *(int32*)345 = 123;     // never return
 }
 
+// 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)
 {
         gp->param = runtime·stackalloc((uintptr)gp->param);
         runtime·gogo(&gp->sched, 0);
 }
 
+// Allocate a new g, with a stack big enough for stacksize bytes.
 G*
 runtime·malg(int32 stacksize)
 {
         G *newg;
         byte *stk;
 
         newg = runtime·malloc(sizeof(G));
         if(stacksize >= 0) {
                 if(g == m->g0) {
                         // running on scheduler stack already.
                         stk = runtime·stackalloc(StackSystem + stacksize);
                 } else {
                         // have to call stackalloc on scheduler stack.
                         g->param = (void*)(StackSystem + stacksize);
                         runtime·mcall(mstackalloc);
                         stk = g->param;
                         g->param = nil;
                 }
                 newg->stack0 = stk;
                 newg->stackguard = stk + StackGuard;
                 newg->stackbase = stk + StackSystem + stacksize - sizeof(Stktop);
                 runtime·memclr(newg->stackbase, sizeof(Stktop));
         }
         return newg;
 }
 
-/*
- * Newproc and deferproc need to be textflag 7
- * (no possible stack split when nearing overflow)
- * because they assume that the arguments to fn
- * are available sequentially beginning at &arg0.
- * If a stack split happened, only the one word
- * arg0 would be copied.  It's okay if any functions
- * they call split the stack below the newproc frame.
- */
+// Create a new g running fn with siz bytes of arguments.
+// Put it on the queue of g's waiting to run.
+// The compiler turns a go statement into a call to this.
+// Cannot split the stack because it assumes that the arguments
+// are available sequentially after &fn; they would not be
+// copied if a stack split occurred.  It's OK for this to call
+// functions that split the stack.
 #pragma textflag 7
 void
 runtime·newproc(int32 siz, byte* fn, ...)
 {
         byte *argp;
 
         if(thechar == '5')
                 argp = (byte*)(&fn+2);  // skip caller's saved LR
         else
                 argp = (byte*)(&fn+1);
         runtime·newproc1(fn, argp, siz, 0, runtime·getcallerpc(&siz));
 }
 
+// Create a new g running fn with narg bytes of arguments starting
+// at argp and returning nret bytes of results.  callerpc is the
+// address of the go statement that created this.  The new g is put
+// on the queue of g's waiting to run.
 G*
 runtime·newproc1(byte *fn, byte *argp, int32 narg, int32 nret, void *callerpc)
 {
         byte *sp;
         G *newg;
         int32 siz;
 
 //printf("newproc1 %p %p narg=%d nret=%d\n", fn, argp, narg, nret);
         siz = narg + nret;
         siz = (siz+7) & ~7;
@@ skipping 40 matching lines @@
         runtime·sched.goidgen++;
         newg->goid = runtime·sched.goidgen;
 
         newprocreadylocked(newg);
         schedunlock();
 
         return newg;
 //printf(" goid=%d\n", newg->goid);
 }
 
+// Create a new deferred function fn with siz bytes of arguments.
+// The compiler turns a defer statement into a call to this.
+// Cannot split the stack because it assumes that the arguments
+// are available sequentially after &fn; they would not be
+// copied if a stack split occurred.  It's OK for this to call
+// functions that split the stack.
 #pragma textflag 7
 uintptr
 runtime·deferproc(int32 siz, byte* fn, ...)
 {
         Defer *d;
 
         d = runtime·malloc(sizeof(*d) + siz - sizeof(d->args));
         d->fn = fn;
         d->siz = siz;
         d->pc = runtime·getcallerpc(&siz);
         if(thechar == '5')
                 d->argp = (byte*)(&fn+2);  // skip caller's saved link register
         else
                 d->argp = (byte*)(&fn+1);
         runtime·memmove(d->args, d->argp, d->siz);
 
         d->link = g->defer;
         g->defer = d;
 
         // deferproc returns 0 normally.
         // a deferred func that stops a panic
         // makes the deferproc return 1.
         // the code the compiler generates always
         // checks the return value and jumps to the
         // end of the function if deferproc returns != 0.
         return 0;
 }
 
+// Run a deferred function if there is one.
+// The compiler inserts a call to this at the end of any
+// function which calls defer.
+// If there is a deferred function, this will call runtime·jmpdefer,
+// which will jump to the deferred function such that it appears
+// to have been called by the caller of deferreturn at the point
+// just before deferreturn was called.  The effect is that deferreturn
+// is called again and again until there are no more deferred functions.
+// Cannot split the stack because we reuse the caller's frame to
+// call the deferred function.
 #pragma textflag 7
 void
 runtime·deferreturn(uintptr arg0)
 {
         Defer *d;
         byte *argp, *fn;
 
         d = g->defer;
         if(d == nil)
                 return;
         argp = (byte*)&arg0;
         if(d->argp != argp)
                 return;
         runtime·memmove(argp, d->args, d->siz);
         g->defer = d->link;
         fn = d->fn;
         if(!d->nofree)
                 runtime·free(d);
         runtime·jmpdefer(fn, argp);
 }
 
+// Run all deferred functions for the current goroutine.
 static void
 rundefer(void)
 {
         Defer *d;
 
         while((d = g->defer) != nil) {
                 g->defer = d->link;
                 reflect·call(d->fn, d->args, d->siz);
                 if(!d->nofree)
                         runtime·free(d);
@@ skipping 21 matching lines @@
                 if(top->free != 0)
                         runtime·stackfree(stk, top->free);
         }
 
         if(sp != nil && (sp < gp->stackguard - StackGuard || gp->stackbase < sp)) {
                 runtime·printf("recover: %p not in [%p, %p]\n", sp, gp->stackguard - StackGuard, gp->stackbase);
                 runtime·throw("bad unwindstack");
         }
 }
 
+// Print all currently active panics.  Used when crashing.
 static void
 printpanics(Panic *p)
 {
         if(p->link) {
                 printpanics(p->link);
                 runtime·printf("\t");
         }
         runtime·printf("panic: ");
         runtime·printany(p->arg);
         if(p->recovered)
                 runtime·printf(" [recovered]");
         runtime·printf("\n");
 }
 
 static void recovery(G*);
 
+// The implementation of the predeclared function panic.
 void
 runtime·panic(Eface e)
 {
         Defer *d;
         Panic *p;
 
         p = runtime·mal(sizeof *p);
         p->arg = e;
         p->link = g->panic;
         p->stackbase = g->stackbase;
@@ skipping 22 matching lines @@
                 if(!d->nofree)
                         runtime·free(d);
         }
 
         // ran out of deferred calls - old-school panic now
         runtime·startpanic();
         printpanics(g->panic);
         runtime·dopanic(0);
 }
 
+// Unwind the stack after a deferred function calls recover
+// after a panic.  Then arrange to continue running as though
+// the caller of the deferred function returned normally.
 static void
 recovery(G *gp)
 {
         Defer *d;
 
         // Rewind gp's stack; we're running on m->g0's stack.
         d = gp->defer;
         gp->defer = d->link;
 
         // Unwind to the stack frame with d's arguments in it.
@@ skipping 11 matching lines @@
         if(thechar == '5')
                 gp->sched.sp = (byte*)d->argp - 4*sizeof(uintptr);
         else
                 gp->sched.sp = (byte*)d->argp - 2*sizeof(uintptr);
         gp->sched.pc = d->pc;
         if(!d->nofree)
                 runtime·free(d);
         runtime·gogo(&gp->sched, 1);
 }
 
-#pragma textflag 7      /* no split, or else g->stackguard is not the stack for fp */
+// The implementation of the predeclared function recover.
+// Cannot split the stack because it needs to reliably
+// find the stack segment of its caller.
+#pragma textflag 7
 void
 runtime·recover(byte *argp, Eface ret)
 {
         Stktop *top, *oldtop;
         Panic *p;
 
         // Must be a panic going on.
         if((p = g->panic) == nil || p->recovered)
                 goto nomatch;
 
@@ skipping 91 matching lines @@
         rundefer();
         runtime·goexit();
 }
 
 void
 runtime·Gosched(void)
 {
         runtime·gosched();
 }
 
+// Implementation of runtime.GOMAXPROCS.
 // delete when scheduler is stronger
 int32
 runtime·gomaxprocsfunc(int32 n)
 {
         int32 ret;
         uint32 v;
 
         schedlock();
         ret = runtime·gomaxprocs;
         if(n <= 0)
@@ skipping 95 matching lines @@
         runtime·throw("runtime: mcall function returned");
 }
 
 static struct {
         Lock;
         void (*fn)(uintptr*, int32);
         int32 hz;
         uintptr pcbuf[100];
 } prof;
 
+// Called if we receive a SIGPROF signal.
 void
 runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp)
 {
         int32 n;
 
         if(prof.fn == nil || prof.hz == 0)
                 return;
 
         runtime·lock(&prof);
         if(prof.fn == nil) {
                 runtime·unlock(&prof);
                 return;
         }
         n = runtime·gentraceback(pc, sp, lr, gp, 0, prof.pcbuf, nelem(prof.pcbuf));
         if(n > 0)
                 prof.fn(prof.pcbuf, n);
         runtime·unlock(&prof);
 }
 
+// Arrange to call fn with a traceback hz times a second.
 void
 runtime·setcpuprofilerate(void (*fn)(uintptr*, int32), int32 hz)
 {
         // Force sane arguments.
         if(hz < 0)
                 hz = 0;
         if(hz == 0)
                 fn = nil;
         if(fn == nil)
                 hz = 0;
@@ skipping 10 matching lines @@
         runtime·lock(&runtime·sched);
         runtime·sched.profilehz = hz;
         runtime·unlock(&runtime·sched);
 
         if(hz != 0)
                 runtime·resetcpuprofiler(hz);
 }
 
 void (*libcgo_setenv)(byte**);
 
+// Update the C environment if cgo is loaded.
+// Called from os.Setenv.
 void
 os·setenv_c(String k, String v)
 {
         byte *arg[2];
 
         if(libcgo_setenv == nil)
                 return;
 
         arg[0] = runtime·malloc(k.len + 1);
         runtime·memmove(arg[0], k.str, k.len);
         arg[0][k.len] = 0;
 
         arg[1] = runtime·malloc(v.len + 1);
         runtime·memmove(arg[1], v.str, v.len);
         arg[1][v.len] = 0;
 
         runtime·asmcgocall((void*)libcgo_setenv, arg);
         runtime·free(arg[0]);
         runtime·free(arg[1]);
 }