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

src/pkg/runtime/lock_sema.c

 // Copyright 2011 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.
 
 // +build darwin netbsd openbsd plan9 windows
 
 #include "runtime.h"
 
 // This implementation depends on OS-specific implementations of
 //
@@ skipping 136 matching lines @@
 runtime·notesleep(Note *n)
 {
         if(m->waitsema == 0)
                 m->waitsema = runtime·semacreate();
         if(!runtime·casp(&n->waitm, nil, m)) {  // must be LOCKED (got wakeup)
                 if(n->waitm != (void*)LOCKED)
                         runtime·throw("notesleep - waitm out of sync");
                 return;
         }
         // Queued.  Sleep.
+        if(m->profilehz > 0)
+                runtime·setprof(false);
         runtime·semasleep(-1);
+        if(m->profilehz > 0)
+                runtime·setprof(true);
 }
 
 void
 runtime·notetsleep(Note *n, int64 ns)
 {
         M *mp;
         int64 deadline, now;
 
         if(ns < 0) {
                 runtime·notesleep(n);
                 return;
         }
 
         if(m->waitsema == 0)
                 m->waitsema = runtime·semacreate();
 
         // Register for wakeup on n->waitm.
         if(!runtime·casp(&n->waitm, nil, m)) {  // must be LOCKED (got wakeup already)
                 if(n->waitm != (void*)LOCKED)
                         runtime·throw("notetsleep - waitm out of sync");
                 return;
         }
 
+        if(m->profilehz > 0)
+                runtime·setprof(false);
         deadline = runtime·nanotime() + ns;
         for(;;) {
                 // Registered.  Sleep.
                 if(runtime·semasleep(ns) >= 0) {
                         // Acquired semaphore, semawakeup unregistered us.
                         // Done.
+                        if(m->profilehz > 0)
+                                runtime·setprof(true);
                         return;
                 }
 
                 // Interrupted or timed out.  Still registered.  Semaphore not acquired.
                 now = runtime·nanotime();
                 if(now >= deadline)
                         break;
 
                 // Deadline hasn't arrived.  Keep sleeping.
                 ns = deadline - now;
         }
+
+        if(m->profilehz > 0)
+                runtime·setprof(true);
 
         // Deadline arrived.  Still registered.  Semaphore not acquired.
         // Want to give up and return, but have to unregister first,
         // so that any notewakeup racing with the return does not
         // try to grant us the semaphore when we don't expect it.
         for(;;) {
                 mp = runtime·atomicloadp(&n->waitm);
                 if(mp == m) {
                         // No wakeup yet; unregister if possible.
                         if(runtime·casp(&n->waitm, mp, nil))
                                 return;
                 } else if(mp == (M*)LOCKED) {
                         // Wakeup happened so semaphore is available.
                         // Grab it to avoid getting out of sync.
                         if(runtime·semasleep(-1) < 0)
                                 runtime·throw("runtime: unable to acquire - semaphore out of sync");
                         return;
                 } else {
                         runtime·throw("runtime: unexpected waitm - semaphore out of sync");
                 }
         }
 }