1 files changed, 108 insertions, 0 deletions
diff --git a/libgo/go/runtime/pprof/pprof.go b/libgo/go/runtime/pprof/pprof.go
new file mode 100644
index 000000000..d0cc73089
--- /dev/null
+++ b/libgo/go/runtime/pprof/pprof.go
@@ -0,0 +1,108 @@
+// Copyright 2010 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.
+
+// Package pprof writes runtime profiling data in the format expected
+// by the pprof visualization tool.
+// For more information about pprof, see
+// http://code.google.com/p/google-perftools/.
+package pprof
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+)
+
+// WriteHeapProfile writes a pprof-formatted heap profile to w.
+// If a write to w returns an error, WriteHeapProfile returns that error.
+// Otherwise, WriteHeapProfile returns nil.
+func WriteHeapProfile(w io.Writer) os.Error {
+	// Find out how many records there are (MemProfile(nil, false)),
+	// allocate that many records, and get the data.
+	// There's a race—more records might be added between
+	// the two calls—so allocate a few extra records for safety
+	// and also try again if we're very unlucky.
+	// The loop should only execute one iteration in the common case.
+	var p []runtime.MemProfileRecord
+	n, ok := runtime.MemProfile(nil, false)
+	for {
+		// Allocate room for a slightly bigger profile,
+		// in case a few more entries have been added
+		// since the call to MemProfile.
+		p = make([]runtime.MemProfileRecord, n+50)
+		n, ok = runtime.MemProfile(p, false)
+		if ok {
+			p = p[0:n]
+			break
+		}
+		// Profile grew; try again.
+	}
+
+	var total runtime.MemProfileRecord
+	for i := range p {
+		r := &p[i]
+		total.AllocBytes += r.AllocBytes
+		total.AllocObjects += r.AllocObjects
+		total.FreeBytes += r.FreeBytes
+		total.FreeObjects += r.FreeObjects
+	}
+
+	// Technically the rate is MemProfileRate not 2*MemProfileRate,
+	// but early versions of the C++ heap profiler reported 2*MemProfileRate,
+	// so that's what pprof has come to expect.
+	b := bufio.NewWriter(w)
+	fmt.Fprintf(b, "heap profile: %d: %d [%d: %d] @ heap/%d\n",
+		total.InUseObjects(), total.InUseBytes(),
+		total.AllocObjects, total.AllocBytes,
+		2*runtime.MemProfileRate)
+
+	for i := range p {
+		r := &p[i]
+		fmt.Fprintf(b, "%d: %d [%d: %d] @",
+			r.InUseObjects(), r.InUseBytes(),
+			r.AllocObjects, r.AllocBytes)
+		for _, pc := range r.Stack() {
+			fmt.Fprintf(b, " %#x", pc)
+		}
+		fmt.Fprintf(b, "\n")
+	}
+
+	// Print memstats information too.
+	// Pprof will ignore, but useful for people.
+	s := &runtime.MemStats
+	fmt.Fprintf(b, "\n# runtime.MemStats\n")
+	fmt.Fprintf(b, "# Alloc = %d\n", s.Alloc)
+	fmt.Fprintf(b, "# TotalAlloc = %d\n", s.TotalAlloc)
+	fmt.Fprintf(b, "# Sys = %d\n", s.Sys)
+	fmt.Fprintf(b, "# Lookups = %d\n", s.Lookups)
+	fmt.Fprintf(b, "# Mallocs = %d\n", s.Mallocs)
+
+	fmt.Fprintf(b, "# HeapAlloc = %d\n", s.HeapAlloc)
+	fmt.Fprintf(b, "# HeapSys = %d\n", s.HeapSys)
+	fmt.Fprintf(b, "# HeapIdle = %d\n", s.HeapIdle)
+	fmt.Fprintf(b, "# HeapInuse = %d\n", s.HeapInuse)
+
+	fmt.Fprintf(b, "# Stack = %d / %d\n", s.StackInuse, s.StackSys)
+	fmt.Fprintf(b, "# MSpan = %d / %d\n", s.MSpanInuse, s.MSpanSys)
+	fmt.Fprintf(b, "# MCache = %d / %d\n", s.MCacheInuse, s.MCacheSys)
+	fmt.Fprintf(b, "# MHeapMapSys = %d\n", s.MHeapMapSys)
+	fmt.Fprintf(b, "# BuckHashSys = %d\n", s.BuckHashSys)
+
+	fmt.Fprintf(b, "# NextGC = %d\n", s.NextGC)
+	fmt.Fprintf(b, "# PauseNs = %d\n", s.PauseNs)
+	fmt.Fprintf(b, "# NumGC = %d\n", s.NumGC)
+	fmt.Fprintf(b, "# EnableGC = %v\n", s.EnableGC)
+	fmt.Fprintf(b, "# DebugGC = %v\n", s.DebugGC)
+
+	fmt.Fprintf(b, "# BySize = Size * (Active = Mallocs - Frees)\n")
+	fmt.Fprintf(b, "# (Excluding large blocks.)\n")
+	for _, t := range s.BySize {
+		if t.Mallocs > 0 {
+			fmt.Fprintf(b, "#   %d * (%d = %d - %d)\n", t.Size, t.Mallocs-t.Frees, t.Mallocs, t.Frees)
+		}
+	}
+	return b.Flush()
+}