code review 5191044: runtime: fix spurious deadlock reporting

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 583 matching lines @@
                 m->helpgc = 0;
                 runtime·lock(&runtime·sched);
                 goto top;
         }
         if((gp = m->nextg) == nil)
                 runtime·throw("bad m->nextg in nextgoroutine");
         m->nextg = nil;
         return gp;
 }
 
-static int32
-maxgcprocs(void)
-{
-        int32 max;
+int32
+runtime·helpgc(bool *extra)
+{
+        M *mp;
+        int32 n, max;
 
         // Figure out how many CPUs to use.
         // Limited by gomaxprocs, number of actual CPUs, and MaxGcproc.
         max = runtime·gomaxprocs;
         if(max > runtime·ncpu)
                 max = runtime·ncpu;
         if(max > MaxGcproc)
                 max = MaxGcproc;
-        return max;
-}
-
-int32
-runtime·helpgc(void)
-{
-        M *mp;
-        int32 n, max;
-
-        max = maxgcprocs();
 
         // We're going to use one CPU no matter what.
         // Figure out the max number of additional CPUs.
         max--;
 
         runtime·lock(&runtime·sched);
         n = 0;
         while(n < max && (mp = mget(nil)) != nil) {
                 n++;
                 mp->helpgc = 1;
                 mp->waitnextg = 0;
                 runtime·notewakeup(&mp->havenextg);
         }
         runtime·unlock(&runtime·sched);
+        if(extra)
+                *extra = n != max;
         return n;
 }
 
 void
 runtime·stoptheworld(void)
 {
         uint32 v;
 
         schedlock();
         runtime·gcwaiting = 1;
@@ skipping 20 matching lines @@
 
                 schedunlock();
                 runtime·notesleep(&runtime·sched.stopped);
                 schedlock();
         }
         runtime·singleproc = runtime·gomaxprocs == 1;
         schedunlock();
 }
 
 void
-runtime·starttheworld(void)
+runtime·starttheworld(bool extra)
 {
         M *m;
 
         schedlock();
         runtime·gcwaiting = 0;
         setmcpumax(runtime·gomaxprocs);
         matchmg();
-        // 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.
-        if(runtime·sched.mcount < maxgcprocs() && canaddmcpu()) {
+        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();
@@ skipping 981 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]);
 }