443 lines
12 KiB
Plaintext
443 lines
12 KiB
Plaintext
// 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
|
|
// to an arbitrary io.Writer, while the google-perftools code always
|
|
// writes to an operating system file.
|
|
//
|
|
// The signal handler for the profiling clock tick adds a new stack trace
|
|
// to a hash table tracking counts for recent traces. Most clock ticks
|
|
// hit in the cache. In the event of a cache miss, an entry must be
|
|
// evicted from the hash table, copied to a log that will eventually be
|
|
// written as profile data. The google-perftools code flushed the
|
|
// log itself during the signal handler. This code cannot do that, because
|
|
// the io.Writer might block or need system calls or locks that are not
|
|
// safe to use from within the signal handler. Instead, we split the log
|
|
// into two halves and let the signal handler fill one half while a goroutine
|
|
// is writing out the other half. When the signal handler fills its half, it
|
|
// offers to swap with the goroutine. If the writer is not done with its half,
|
|
// we lose the stack trace for this clock tick (and record that loss).
|
|
// The goroutine interacts with the signal handler by calling getprofile() to
|
|
// get the next log piece to write, implicitly handing back the last log
|
|
// piece it obtained.
|
|
//
|
|
// The state of this dance between the signal handler and the goroutine
|
|
// is encoded in the Profile.handoff field. If handoff == 0, then the goroutine
|
|
// is not using either log half and is waiting (or will soon be waiting) for
|
|
// a new piece by calling notesleep(&p->wait). If the signal handler
|
|
// changes handoff from 0 to non-zero, it must call notewakeup(&p->wait)
|
|
// to wake the goroutine. The value indicates the number of entries in the
|
|
// log half being handed off. The goroutine leaves the non-zero value in
|
|
// place until it has finished processing the log half and then flips the number
|
|
// back to zero. Setting the high bit in handoff means that the profiling is over,
|
|
// and the goroutine is now in charge of flushing the data left in the hash table
|
|
// to the log and returning that data.
|
|
//
|
|
// The handoff field is manipulated using atomic operations.
|
|
// For the most part, the manipulation of handoff is orderly: if handoff == 0
|
|
// then the signal handler owns it and can change it to non-zero.
|
|
// If handoff != 0 then the goroutine owns it and can change it to zero.
|
|
// 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
|
|
#include "runtime.h"
|
|
#include "arch.h"
|
|
#include "malloc.h"
|
|
|
|
#include "array.h"
|
|
typedef struct __go_open_array Slice;
|
|
#define array __values
|
|
#define len __count
|
|
#define cap __capacity
|
|
|
|
enum
|
|
{
|
|
HashSize = 1<<10,
|
|
LogSize = 1<<17,
|
|
Assoc = 4,
|
|
MaxStack = 64,
|
|
};
|
|
|
|
typedef struct Profile Profile;
|
|
typedef struct Bucket Bucket;
|
|
typedef struct Entry Entry;
|
|
|
|
struct Entry {
|
|
uintptr count;
|
|
uintptr depth;
|
|
uintptr stack[MaxStack];
|
|
};
|
|
|
|
struct Bucket {
|
|
Entry entry[Assoc];
|
|
};
|
|
|
|
struct Profile {
|
|
bool on; // profiling is on
|
|
Note wait; // goroutine waits here
|
|
uintptr count; // tick count
|
|
uintptr evicts; // eviction count
|
|
uintptr lost; // lost ticks that need to be logged
|
|
|
|
// Active recent stack traces.
|
|
Bucket hash[HashSize];
|
|
|
|
// Log of traces evicted from hash.
|
|
// Signal handler has filled log[toggle][:nlog].
|
|
// Goroutine is writing log[1-toggle][:handoff].
|
|
uintptr log[2][LogSize/2];
|
|
uintptr nlog;
|
|
int32 toggle;
|
|
uint32 handoff;
|
|
|
|
// Writer state.
|
|
// Writer maintains its own toggle to avoid races
|
|
// looking at signal handler's toggle.
|
|
uint32 wtoggle;
|
|
bool wholding; // holding & need to release a log half
|
|
bool flushing; // flushing hash table - profile is over
|
|
bool eod_sent; // special end-of-data record sent; => flushing
|
|
};
|
|
|
|
static Lock lk;
|
|
static Profile *prof;
|
|
|
|
static void tick(uintptr*, int32);
|
|
static void add(Profile*, uintptr*, int32);
|
|
static bool evict(Profile*, Entry*);
|
|
static bool flushlog(Profile*);
|
|
|
|
static uintptr eod[3] = {0, 1, 0};
|
|
|
|
// 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.
|
|
static void
|
|
LostProfileData(void)
|
|
{
|
|
}
|
|
|
|
extern void runtime_SetCPUProfileRate(intgo)
|
|
__asm__ (GOSYM_PREFIX "runtime.SetCPUProfileRate");
|
|
|
|
// SetCPUProfileRate sets the CPU profiling rate.
|
|
// The user documentation is in debug.go.
|
|
void
|
|
runtime_SetCPUProfileRate(intgo hz)
|
|
{
|
|
uintptr *p;
|
|
uintptr n;
|
|
|
|
// Clamp hz to something reasonable.
|
|
if(hz < 0)
|
|
hz = 0;
|
|
if(hz > 1000000)
|
|
hz = 1000000;
|
|
|
|
runtime_lock(&lk);
|
|
if(hz > 0) {
|
|
if(prof == nil) {
|
|
prof = runtime_SysAlloc(sizeof *prof, &mstats.other_sys);
|
|
if(prof == nil) {
|
|
runtime_printf("runtime: cpu profiling cannot allocate memory\n");
|
|
runtime_unlock(&lk);
|
|
return;
|
|
}
|
|
}
|
|
if(prof->on || prof->handoff != 0) {
|
|
runtime_printf("runtime: cannot set cpu profile rate until previous profile has finished.\n");
|
|
runtime_unlock(&lk);
|
|
return;
|
|
}
|
|
|
|
prof->on = true;
|
|
p = prof->log[0];
|
|
// pprof binary header format.
|
|
// http://code.google.com/p/google-perftools/source/browse/trunk/src/profiledata.cc#117
|
|
*p++ = 0; // count for header
|
|
*p++ = 3; // depth for header
|
|
*p++ = 0; // version number
|
|
*p++ = 1000000 / hz; // period (microseconds)
|
|
*p++ = 0;
|
|
prof->nlog = p - prof->log[0];
|
|
prof->toggle = 0;
|
|
prof->wholding = false;
|
|
prof->wtoggle = 0;
|
|
prof->flushing = false;
|
|
prof->eod_sent = false;
|
|
runtime_noteclear(&prof->wait);
|
|
|
|
runtime_setcpuprofilerate(tick, hz);
|
|
} else if(prof != nil && prof->on) {
|
|
runtime_setcpuprofilerate(nil, 0);
|
|
prof->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 = prof->handoff;
|
|
if(n&0x80000000)
|
|
runtime_printf("runtime: setcpuprofile(off) twice");
|
|
if(runtime_cas(&prof->handoff, n, n|0x80000000))
|
|
break;
|
|
}
|
|
if(n == 0) {
|
|
// we did the transition from 0 -> nonzero so we wake getprofile
|
|
runtime_notewakeup(&prof->wait);
|
|
}
|
|
}
|
|
runtime_unlock(&lk);
|
|
}
|
|
|
|
static void
|
|
tick(uintptr *pc, int32 n)
|
|
{
|
|
add(prof, pc, n);
|
|
}
|
|
|
|
// 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.
|
|
static void
|
|
add(Profile *p, uintptr *pc, int32 n)
|
|
{
|
|
int32 i, j;
|
|
uintptr h, x;
|
|
Bucket *b;
|
|
Entry *e;
|
|
|
|
if(n > MaxStack)
|
|
n = MaxStack;
|
|
|
|
// Compute hash.
|
|
h = 0;
|
|
for(i=0; i<n; i++) {
|
|
h = h<<8 | (h>>(8*(sizeof(h)-1)));
|
|
x = pc[i];
|
|
h += x*31 + x*7 + x*3;
|
|
}
|
|
p->count++;
|
|
|
|
// Add to entry count if already present in table.
|
|
b = &p->hash[h%HashSize];
|
|
for(i=0; i<Assoc; i++) {
|
|
e = &b->entry[i];
|
|
if(e->depth != (uintptr)n)
|
|
continue;
|
|
for(j=0; j<n; j++)
|
|
if(e->stack[j] != pc[j])
|
|
goto ContinueAssoc;
|
|
e->count++;
|
|
return;
|
|
ContinueAssoc:;
|
|
}
|
|
|
|
// Evict entry with smallest count.
|
|
e = &b->entry[0];
|
|
for(i=1; i<Assoc; i++)
|
|
if(b->entry[i].count < e->count)
|
|
e = &b->entry[i];
|
|
if(e->count > 0) {
|
|
if(!evict(p, e)) {
|
|
// Could not evict entry. Record lost stack.
|
|
p->lost++;
|
|
return;
|
|
}
|
|
p->evicts++;
|
|
}
|
|
|
|
// Reuse the newly evicted entry.
|
|
e->depth = n;
|
|
e->count = 1;
|
|
for(i=0; i<n; i++)
|
|
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.
|
|
static bool
|
|
evict(Profile *p, Entry *e)
|
|
{
|
|
int32 i, d, nslot;
|
|
uintptr *log, *q;
|
|
|
|
d = e->depth;
|
|
nslot = d+2;
|
|
log = p->log[p->toggle];
|
|
if(p->nlog+nslot > nelem(p->log[0])) {
|
|
if(!flushlog(p))
|
|
return false;
|
|
log = p->log[p->toggle];
|
|
}
|
|
|
|
q = log+p->nlog;
|
|
*q++ = e->count;
|
|
*q++ = d;
|
|
for(i=0; i<d; i++)
|
|
*q++ = e->stack[i];
|
|
p->nlog = q - log;
|
|
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.
|
|
static bool
|
|
flushlog(Profile *p)
|
|
{
|
|
uintptr *log, *q;
|
|
|
|
if(!runtime_cas(&p->handoff, 0, p->nlog))
|
|
return false;
|
|
runtime_notewakeup(&p->wait);
|
|
|
|
p->toggle = 1 - p->toggle;
|
|
log = p->log[p->toggle];
|
|
q = log;
|
|
if(p->lost > 0) {
|
|
*q++ = p->lost;
|
|
*q++ = 1;
|
|
*q++ = (uintptr)LostProfileData;
|
|
p->lost = 0;
|
|
}
|
|
p->nlog = q - log;
|
|
return true;
|
|
}
|
|
|
|
// getprofile blocks until the next block of profiling data is available
|
|
// and returns it as a []byte. It is called from the writing goroutine.
|
|
Slice
|
|
getprofile(Profile *p)
|
|
{
|
|
uint32 i, j, n;
|
|
Slice ret;
|
|
Bucket *b;
|
|
Entry *e;
|
|
|
|
ret.array = nil;
|
|
ret.len = 0;
|
|
ret.cap = 0;
|
|
|
|
if(p == nil)
|
|
return ret;
|
|
|
|
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) {
|
|
runtime_printf("runtime: phase error during cpu profile handoff\n");
|
|
return ret;
|
|
}
|
|
if(n & 0x80000000) {
|
|
p->wtoggle = 1 - p->wtoggle;
|
|
p->wholding = false;
|
|
p->flushing = true;
|
|
goto flush;
|
|
}
|
|
if(runtime_cas(&p->handoff, n, 0))
|
|
break;
|
|
}
|
|
p->wtoggle = 1 - p->wtoggle;
|
|
p->wholding = false;
|
|
}
|
|
|
|
if(p->flushing)
|
|
goto flush;
|
|
|
|
if(!p->on && p->handoff == 0)
|
|
return ret;
|
|
|
|
// Wait for new log.
|
|
runtime_notetsleepg(&p->wait, -1);
|
|
runtime_noteclear(&p->wait);
|
|
|
|
n = p->handoff;
|
|
if(n == 0) {
|
|
runtime_printf("runtime: phase error during cpu profile wait\n");
|
|
return ret;
|
|
}
|
|
if(n == 0x80000000) {
|
|
p->flushing = true;
|
|
goto flush;
|
|
}
|
|
n &= ~0x80000000;
|
|
|
|
// Return new log to caller.
|
|
p->wholding = true;
|
|
|
|
ret.array = (byte*)p->log[p->wtoggle];
|
|
ret.len = n*sizeof(uintptr);
|
|
ret.cap = ret.len;
|
|
return ret;
|
|
|
|
flush:
|
|
// 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.
|
|
for(i=0; i<HashSize; i++) {
|
|
b = &p->hash[i];
|
|
for(j=0; j<Assoc; j++) {
|
|
e = &b->entry[j];
|
|
if(e->count > 0 && !evict(p, e)) {
|
|
// Filled the log. Stop the loop and return what we've got.
|
|
goto breakflush;
|
|
}
|
|
}
|
|
}
|
|
breakflush:
|
|
|
|
// 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.
|
|
ret.array = (byte*)p->log[p->toggle];
|
|
ret.len = p->nlog*sizeof(uintptr);
|
|
ret.cap = ret.len;
|
|
p->nlog = 0;
|
|
return ret;
|
|
}
|
|
|
|
// Made it through the table without finding anything to log.
|
|
if(!p->eod_sent) {
|
|
// 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->eod_sent = true;
|
|
ret.array = (byte*)eod;
|
|
ret.len = sizeof eod;
|
|
ret.cap = ret.len;
|
|
return ret;
|
|
}
|
|
|
|
// Finally done. Clean up and return nil.
|
|
p->flushing = false;
|
|
if(!runtime_cas(&p->handoff, p->handoff, 0))
|
|
runtime_printf("runtime: profile flush racing with something\n");
|
|
return ret; // set to nil at top of function
|
|
}
|
|
|
|
// CPUProfile returns the next cpu profile block as a []byte.
|
|
// The user documentation is in debug.go.
|
|
func CPUProfile() (ret Slice) {
|
|
ret = getprofile(prof);
|
|
}
|