code review 5697066: runtime/pprof: support OS X CPU profiling

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 "defs_GOOS_GOARCH.h"
 #include "malloc.h"
 #include "os_GOOS.h"
 #include "stack.h"
@@ skipping 320 matching lines @@
 {
         m->id = runtime·sched.mcount++;
         m->fastrand = 0x49f6428aUL + m->id + runtime·cputicks();
         m->stackalloc = runtime·malloc(sizeof(*m->stackalloc));
         runtime·FixAlloc_Init(m->stackalloc, FixedStack, runtime·SysAlloc, nil, nil);
 
         if(m->mcache == nil)
                 m->mcache = runtime·allocmcache();
 
         runtime·callers(1, m->createstack, nelem(m->createstack));
-        
+
         // Add to runtime·allm so garbage collector doesn't free m
         // when it is just in a register or thread-local storage.
         m->alllink = runtime·allm;
         // runtime·NumCgoCall() iterates over allm w/o schedlock,
         // so we need to publish it safely.
         runtime·atomicstorep(&runtime·allm, m);
 }
 
 // Try to increment mcpu.  Report whether succeeded.
 static bool
@@ skipping 369 matching lines @@
 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·asminit();
         runtime·minit();
         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*);
 
@@ skipping 167 matching lines @@
 // entersyscall is going to return immediately after.
 // It's okay to call matchmg and notewakeup even after
 // decrementing mcpu, because we haven't released the
 // sched lock yet, so the garbage collector cannot be running.
 #pragma textflag 7
 void
 runtime·entersyscall(void)
 {
         uint32 v;
 
+        if(m->profilehz > 0)
+                runtime·setprof(false);
+
         // Leave SP around for gc and traceback.
         runtime·gosave(&g->sched);
         g->gcsp = g->sched.sp;
         g->gcstack = g->stackbase;
         g->gcguard = g->stackguard;
         g->status = Gsyscall;
         if(g->gcsp < g->gcguard-StackGuard || g->gcstack < g->gcsp) {
                 // runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
                 //      g->gcsp, g->gcguard-StackGuard, g->gcstack);
                 runtime·throw("entersyscall");
@@ skipping 43 matching lines @@
         // find that we still have mcpu <= mcpumax, then we can
         // start executing Go code immediately, without having to
         // schedlock/schedunlock.
         v = runtime·xadd(&runtime·sched.atomic, (1<<mcpuShift));
         if(m->profilehz == runtime·sched.profilehz && atomic_mcpu(v) <= atomic_mcpumax(v)) {
                 // There's a cpu for us, so we can run.
                 g->status = Grunning;
                 // Garbage collector isn't running (since we are),
                 // so okay to clear gcstack.
                 g->gcstack = nil;
+
+                if(m->profilehz > 0)
+                        runtime·setprof(true);
                 return;
         }
 
         // Tell scheduler to put g back on the run queue:
         // mostly equivalent to g->status = Grunning,
         // but keeps the garbage collector from thinking
         // that g is running right now, which it's not.
         g->readyonstop = 1;
 
         // All the cpus are taken.
@@ skipping 769 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]);
 }