code review 132440043: runtime: convert cpuprof from C to Go

src/pkg/runtime/cpuprof.go

 // 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.
 
 // CPU profiling.
 // Based on algorithms and data structures used in
 // http://code.google.com/p/google-perftools/.
 //
 // The main difference between this code and the google-perftools
 // code is that this code is written to allow copying the profile data
@@ skipping 35 matching lines @@
 // If that were the end of the story then we would not need to manipulate
 // handoff using atomic operations.  The operations are needed, however,
 // in order to let the log closer set the high bit to indicate "EOF" safely
 // in the situation when normally the goroutine "owns" handoff.
 
 package runtime
 
 import "unsafe"
 
 const (
-        numBuckets = 1 << 10
-        logSize    = 1 << 17
-        assoc      = 4
-        maxStack   = 64
+        numBuckets      = 1 << 10
+        logSize         = 1 << 17
+        assoc           = 4
+        maxCPUProfStack = 64
 )
 
 type cpuprofEntry struct {
         count uintptr
         depth uintptr
-        stack [maxStack]uintptr
+        stack [maxCPUProfStack]uintptr
 }
 
 type cpuProfile struct {
         on     bool    // profiling is on
         wait   note    // goroutine waits here
         count  uintptr // tick count
         evicts uintptr // eviction count
         lost   uintptr // lost ticks that need to be logged
 
         // Active recent stack traces.
@@ skipping 18 matching lines @@
         eodSent  bool // special end-of-data record sent; => flushing
 }
 
 var (
         cpuprofLock mutex
         cpuprof     *cpuProfile
 
         eod = [3]uintptr{0, 1, 0}
 )
 
-func setcpuprofilerate(int32)
+func setcpuprofilerate(int32) // proc.c
 
 // lostProfileData is a no-op function used in profiles
 // to mark the number of profiling stack traces that were
 // discarded due to slow data writers.
 func lostProfileData() {}
 
 // SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
 // If hz <= 0, SetCPUProfileRate turns off profiling.
 // If the profiler is on, the rate cannot be changed without first turning it off.
 //
-// Most clients should use the runtime/cpuprof package or
+// Most clients should use the runtime/pprof package or
 // the testing package's -test.cpuprofile flag instead of calling
 // SetCPUProfileRate directly.
 func SetCPUProfileRate(hz int) {
         // Clamp hz to something reasonable.
         if hz < 0 {
                 hz = 0
         }
         if hz > 1000000 {
                 hz = 1000000
         }
 
         lock(&cpuprofLock)
         if hz > 0 {
                 if cpuprof == nil {
-                        cpuprof = &cpuProfile{}
+                        cpuprof = (*cpuProfile)(sysAlloc(unsafe.Sizeof(cpuProfile{}), &memstats.other_sys))
+                        if cpuprof == nil {
+                                print("runtime: cpu profiling cannot allocate memory\n")
+                                unlock(&cpuprofLock)
+                                return
+                        }
                 }
                 if cpuprof.on || cpuprof.handoff != 0 {
-                        printstring("runtime: cannot set cpu profile rate until previous profile has finished.\n")
+                        print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
                         unlock(&cpuprofLock)
                         return
                 }
 
                 cpuprof.on = true
                 // pprof binary header format.
                 // http://code.google.com/p/google-perftools/source/browse/trunk/src/profiledata.cc#117
                 p := &cpuprof.log[0]
                 p[0] = 0                 // count for header
                 p[1] = 3                 // depth for header
@@ skipping 11 matching lines @@
                 setcpuprofilerate(int32(hz))
         } else if cpuprof != nil && cpuprof.on {
                 setcpuprofilerate(0)
                 cpuprof.on = false
 
                 // Now add is not running anymore, and getprofile owns the entire log.
                 // Set the high bit in prof->handoff to tell getprofile.
                 for {
                         n := cpuprof.handoff
                         if n&0x80000000 != 0 {
-                                printstring("runtime: setcpuprofile(off) twice")
+                                print("runtime: setcpuprofile(off) twice\n")
                         }
                         if cas(&cpuprof.handoff, n, n|0x80000000) {
                                 if n == 0 {
                                         // we did the transition from 0 -> nonzero so we wake getprofile
                                         notewakeup(&cpuprof.wait)
                                 }
                                 break
                         }
                 }
         }
         unlock(&cpuprofLock)
 }
 
 func cpuproftick(pc *uintptr, n int32) {
-        if n > maxStack {
-                n = maxStack
-        }
-        s := (*[maxStack]uintptr)(unsafe.Pointer(pc))[:n]
+        if n > maxCPUProfStack {
+                n = maxCPUProfStack
+        }
+        s := (*[maxCPUProfStack]uintptr)(unsafe.Pointer(pc))[:n]
         cpuprof.add(s)
 }
 
 // add adds the stack trace to the profile.
 // It is called from signal handlers and other limited environments
 // and cannot allocate memory or acquire locks that might be
 // held at the time of the signal, nor can it use substantial amounts
 // of stack.  It is allowed to call evict.
 func (p *cpuProfile) add(pc []uintptr) {
         // Compute hash.
@@ skipping 33 matching lines @@
                         // Could not evict entry.  Record lost stack.
                         p.lost++
                         return
                 }
                 p.evicts++
         }
 
         // Reuse the newly evicted entry.
         e.depth = uintptr(len(pc))
         e.count = 1
-        copy(e.stack[:], pc)
+        for i := range pc {
+                e.stack[i] = pc[i]
+        }
 }
 
 // evict copies the given entry's data into the log, so that
 // the entry can be reused.  evict is called from add, which
 // is called from the profiling signal handler, so it must not
 // allocate memory or block.  It is safe to call flushlog.
 // evict returns true if the entry was copied to the log,
 // false if there was no room available.
 func (p *cpuProfile) evict(e *cpuprofEntry) bool {
         d := e.depth
         nslot := d + 2
         log := &p.log[p.toggle]
         if p.nlog+nslot > uintptr(len(p.log[0])) {
                 if !p.flushlog() {
                         return false
                 }
                 log = &p.log[p.toggle]
         }
 
         q := p.nlog
         log[q] = e.count
-        log[q+1] = d
+        q++
+        log[q] = d
+        q++
         for i := uintptr(0); i < d; i++ {
-                log[q+2+i] = e.stack[i]
-        }
-        p.nlog = q + 2 + d
+                log[q] = e.stack[i]
+                q++
+        }
+        p.nlog = q
         e.count = 0
         return true
 }
 
 // flushlog tries to flush the current log and switch to the other one.
 // flushlog is called from evict, called from add, called from the signal handler,
 // so it cannot allocate memory or block.  It can try to swap logs with
 // the writing goroutine, as explained in the comment at the top of this file.
 func (p *cpuProfile) flushlog() bool {
         if !cas(&p.handoff, 0, uint32(p.nlog)) {
@@ skipping 23 matching lines @@
         if p == nil {
                 return nil
         }
 
         if p.wholding {
                 // Release previous log to signal handling side.
                 // Loop because we are racing against SetCPUProfileRate(0).
                 for {
                         n := p.handoff
                         if n == 0 {
-                                printstring("runtime: phase error during cpu profile handoff\n")
+                                print("runtime: phase error during cpu profile handoff\n")
                                 return nil
                         }
                         if n&0x80000000 != 0 {
                                 p.wtoggle = 1 - p.wtoggle
                                 p.wholding = false
                                 p.flushing = true
-                                goto flush
+                                goto Flush
                         }
                         if cas(&p.handoff, n, 0) {
                                 break
                         }
                 }
                 p.wtoggle = 1 - p.wtoggle
                 p.wholding = false
         }
 
         if p.flushing {
-                goto flush
+                goto Flush
         }
 
         if !p.on && p.handoff == 0 {
                 return nil
         }
 
         // Wait for new log.
         notetsleepg(&p.wait, -1)
         noteclear(&p.wait)
 
-        {
-                n := p.handoff
-                if n == 0 {
-                        printstring("runtime: phase error during cpu profile wait\n")
-                        return nil
-                }
-                if n == 0x80000000 {
-                        p.flushing = true
-                        goto flush
-                }
+        switch n := p.handoff; {
+        case n == 0:
+                print("runtime: phase error during cpu profile wait\n")
+                return nil
+        case n == 0x80000000:
+                p.flushing = true
+                goto Flush
+        default:
                 n &^= 0x80000000
 
                 // Return new log to caller.
                 p.wholding = true
 
-                return asByteSlice(p.log[p.wtoggle][:n])
+                return uintptrBytes(p.log[p.wtoggle][:n])
         }
 
         // In flush mode.
         // Add is no longer being called.  We own the log.
         // Also, p->handoff is non-zero, so flushlog will return false.
         // Evict the hash table into the log and return it.
-flush:
+Flush:
         for i := range p.hash {
                 b := &p.hash[i]
                 for j := range b.entry {
                         e := &b.entry[j]
                         if e.count > 0 && !p.evict(e) {
                                 // Filled the log.  Stop the loop and return what we've got.
-                                break flush
+                                break Flush
                         }
                 }
         }
 
         // Return pending log data.
         if p.nlog > 0 {
                 // Note that we're using toggle now, not wtoggle,
                 // because we're working on the log directly.
                 n := p.nlog
                 p.nlog = 0
-                return asByteSlice(p.log[p.toggle][:n])
+                return uintptrBytes(p.log[p.toggle][:n])
         }
 
         // Made it through the table without finding anything to log.
         if !p.eodSent {
                 // We may not have space to append this to the partial log buf,
                 // so we always return a new slice for the end-of-data marker.
                 p.eodSent = true
-                return asByteSlice(eod[:])
+                return uintptrBytes(eod[:])
         }
 
         // Finally done.  Clean up and return nil.
         p.flushing = false
         if !cas(&p.handoff, p.handoff, 0) {
-                printstring("runtime: profile flush racing with something\n")
+                print("runtime: profile flush racing with something\n")
         }
         return nil
 }
 
-func asByteSlice(p []uintptr) (ret []byte) {
+func uintptrBytes(p []uintptr) (ret []byte) {
         pp := (*sliceStruct)(unsafe.Pointer(&p))
         rp := (*sliceStruct)(unsafe.Pointer(&ret))
 
         rp.array = pp.array
         rp.len = pp.len * int(unsafe.Sizeof(p[0]))
         rp.cap = rp.len
 
         return
 }
 
 // CPUProfile returns the next chunk of binary CPU profiling stack trace data,
 // blocking until data is available.  If profiling is turned off and all the profile
 // data accumulated while it was on has been returned, CPUProfile returns nil.
 // The caller must save the returned data before calling CPUProfile again.
 //
-// Most clients should use the runtime/cpuprof package or
+// Most clients should use the runtime/pprof package or
 // the testing package's -test.cpuprofile flag instead of calling
 // CPUProfile directly.
 func CPUProfile() []byte {
         return cpuprof.getprofile()
 }