func BenchmarkCpuProfile(b *testing.B) { f, err := os.Open("testdata/cpu.prof") if err != nil { b.Fatal(err) } defer f.Close() p, err := parser.NewCpuProfParser(f) if err != nil { b.Fatal(err) } bsize := int64(0) for i := 0; i < b.N; i++ { trace, count, err := p.ReadTrace() if trace == nil && err == io.EOF { // rewind. bsize += tell(f) f.Seek(0, 0) p, _ = parser.NewCpuProfParser(f) continue } _ = count } bsize += tell(f) b.SetBytes(bsize / int64(b.N)) }
func TestCpuProfileReport(t *testing.T) { syms := readSymbols("testdata/cpu.prof.symbols") resolve := func(u uint64) string { s, _ := lookup(u, syms); return s } f, err := os.Open("testdata/cpu.prof") if err != nil { t.Fatal(err) } defer f.Close() p, err := parser.NewCpuProfParser(f) if err != nil { t.Fatal(err) } reporter := &Reporter{Resolver: resolve} for { trace, count, err := p.ReadTrace() if trace == nil && err == io.EOF { break } reporter.Add(trace, int64(count)) } entries := reporter.ReportByFunc(ColCPU) buf := new(bytes.Buffer) w := tabwriter.NewWriter(buf, 0, 8, 2, ' ', 0) fmt.Fprintf(w, "\nSelf\tCumul\tName\n") for _, e := range entries { fmt.Fprintf(w, "%.3g\t%.3g\t%s\n", e.Self[ColCPU], e.Cumul[ColCPU], e.Name) } w.Flush() t.Log(buf.String()) }
func TestCpuProfile(t *testing.T) { f, err := os.Open("testdata/cpu.prof") if err != nil { t.Fatal(err) } defer f.Close() p, err := parser.NewCpuProfParser(f) if err != nil { t.Fatal(err) } syms := readSymbols("testdata/cpu.prof.symbols") printed := 0 for { trace, count, err := p.ReadTrace() if trace == nil && err == io.EOF { break } s := stringify(trace, syms) if printed < 10 { printed++ t.Logf("%d× %v", count, s) } } }
func TestCpuProfileGraph(t *testing.T) { syms := readSymbols("testdata/cpu.prof.symbols") resolve := func(u uint64) string { s, _ := lookup(u, syms); return s } f, err := os.Open("testdata/cpu.prof") if err != nil { t.Fatal(err) } defer f.Close() p, err := parser.NewCpuProfParser(f) if err != nil { t.Fatal(err) } reporter := &Reporter{Resolver: resolve} total := int64(0) for { trace, count, err := p.ReadTrace() if trace == nil && err == io.EOF { break } reporter.Add(trace, int64(count)) total += int64(count) } g := reporter.GraphByFunc(ColCPU) t.Logf("%#v", g) report := GraphReport{ Prog: "pprof.test", Total: total, Unit: "samples", Graph: g, } buf := new(bytes.Buffer) err = graphvizTpl.Execute(buf, report) if err != nil { t.Fatal(err) } t.Log(buf.String()) }
func LoadProfile(r *report.Reporter, f io.ReadCloser) { defer f.Close() buf := bufio.NewReader(f) magic, _ := buf.Peek(4) switch string(magic) { case "heap": // Heap profile. p, err := parser.NewHeapProfParser(buf) if err != nil { log.Fatal(err) } for { rec, err := p.ReadRecord() if err == io.EOF { break } p.AdjustRecord(&rec, func(uint64) string { return "" }) r.Add(rec.Trace, rec.LiveObj, rec.LiveBytes, rec.AllocObj, rec.AllocBytes) } default: // CPU Profile. p, err := parser.NewCpuProfParser(buf) if err != nil { log.Fatal(err) } for { trace, count, err := p.ReadTrace() if trace == nil && err == io.EOF { break } r.Add(trace, int64(count)) } } }
cpuProfilePath = tmpDir + "/cpu.pprof" memProfilePath = tmpDir + "/mem.pprof" }) Describe("cpu profiling", func() { It("profiles cpu usage", func() { profiler := profiler.New(cpuProfilePath, "", 1*time.Millisecond, logger) profiler.Profile() profiler.Stop() f, err := os.Open(cpuProfilePath) Expect(err).NotTo(HaveOccurred()) _, err = parser.NewCpuProfParser(f) Expect(err).NotTo(HaveOccurred()) memProfile := profiler.GetMemProfileHandle() Expect(memProfile).To(BeNil()) }) It("panics when there is an error", func() { filePath := "/tmp/asdf/asdf.pprof" profiler := profiler.New(filePath, "", 1*time.Millisecond, logger) Expect(profiler.Profile).To(Panic()) }) }) Describe("memory profiling", func() { It("profiles memory usage", func() {