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"
 
 bool    runtime·iscgo;
 
 static void unwindstack(G*, byte*);
 static void schedule(G*);
 static void acquireproc(void);
 static void releaseproc(void);
-static M *startm(void);
 
 typedef struct Sched Sched;
 
 M       runtime·m0;
 G       runtime·g0;     // idle goroutine for m0
 
 static  int32   debug   = 0;
 
 int32   runtime·gcwaiting;
 
@@ skipping 548 matching lines @@
                 // g queue or changing mcpumax.  Entersyscall can decrement
                 // mcpu, but if does so when there is something on the g queue,
                 // the gwait bit will be set, so entersyscall will take the slow path
                 // and use the sched lock.  So it cannot invalidate our decision.
                 //
                 // Wait on global m queue.
                 mput(m);
         }
 
         v = runtime·atomicload(&runtime·sched.atomic);
-        if(runtime·sched.grunning == 0)
+        if(runtime·sched.grunning == 0 && !runtime·havetimers())

[dvyukov, 2011/11/07 10:54:15]

Need to re-check the condition in time.goc when havetimers() becomes false.

                 runtime·throw("all goroutines are asleep - deadlock!");
         m->nextg = nil;
         m->waitnextg = 1;
         runtime·noteclear(&m->havenextg);
 
         // Stoptheworld is waiting for all but its cpu to go to stop.
         // Entersyscall might have decremented mcpu too, but if so
         // it will see the waitstop and take the slow path.
         // Exitsyscall never increments mcpu beyond mcpumax.
         if(atomic_waitstop(v) && atomic_mcpu(v) <= atomic_mcpumax(v)) {
@@ skipping 96 matching lines @@
         if(extra && canaddmcpu()) {
                 // Start a new m that will (we hope) be idle
                 // and so available to help when the next
                 // garbage collection happens.
                 // canaddmcpu above did mcpu++
                 // (necessary, because m will be doing various
                 // initialization work so is definitely running),
                 // but m is not running a specific goroutine,
                 // so set the helpgc flag as a signal to m's
                 // first schedule(nil) to mcpu-- and grunning--.
-                m = startm();
+                m = runtime·newm(nil);
                 m->helpgc = 1;
                 runtime·sched.grunning++;
         }
         schedunlock();
 }
 
 // Called to start an M.
 void
 runtime·mstart(void)
 {
         if(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 = (void*)-1;  // make sure it is never used
 
         runtime·minit();
+        if(m->procfn)
+                m->procfn();

[dvyukov, 2011/11/07 10:35:02]

I think as of now it will throw if fall through to schedule(). Isn't it better
to put explicit return?

         schedule(nil);
 }
 
 // When running with cgo, we call libcgo_thread_start
 // to start threads for us so that we can play nicely with
 // foreign code.
 void (*libcgo_thread_start)(void*);
 
 typedef struct CgoThreadStart CgoThreadStart;
 struct CgoThreadStart
@@ skipping 16 matching lines @@
         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 = startm();
+                        mp = runtime·newm(nil);
                 mnextg(mp, gp);
         }
 }
 
-static M*
-startm(void)
+M*
+runtime·newm(void (*procfn)(void))
 {
         M *m;
 
         m = runtime·malloc(sizeof(M));
         mcommoninit(m);
+        m->procfn = procfn;

[dvyukov, 2011/11/07 10:35:02]

It is quite fragile. See newm comment in time.goc.

 
         if(runtime·iscgo) {
                 CgoThreadStart ts;
 
                 if(libcgo_thread_start == nil)
                         runtime·throw("libcgo_thread_start missing");
                 // pthread_create will make us a stack.
                 m->g0 = runtime·malg(-1);
                 ts.m = m;
                 ts.g = m->g0;
@@ skipping 905 matching lines @@
         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]);
 }