Subversion Repositories openrisc

// 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 serves via its HTTP server 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/.

//

// The package is typically only imported for the side effect of

// registering its HTTP handlers.

// The handled paths all begin with /debug/pprof/.

//

// To use pprof, link this package into your program:

//      import _ "http/pprof"

//

// Then use the pprof tool to look at the heap profile:

//

//      pprof http://localhost:6060/debug/pprof/heap

//

// Or to look at a 30-second CPU profile:

//

//      pprof http://localhost:6060/debug/pprof/profile

//

package pprof

import (

        "bufio"

        "bytes"

        "fmt"

        "io"

        "net/http"

        "os"

        "runtime"

        "runtime/pprof"

        "strconv"

        "strings"

        "time"

)

func init() {

        http.Handle("/debug/pprof/cmdline", http.HandlerFunc(Cmdline))

        http.Handle("/debug/pprof/profile", http.HandlerFunc(Profile))

        http.Handle("/debug/pprof/heap", http.HandlerFunc(Heap))

        http.Handle("/debug/pprof/symbol", http.HandlerFunc(Symbol))

}

// Cmdline responds with the running program's

// command line, with arguments separated by NUL bytes.

// The package initialization registers it as /debug/pprof/cmdline.

func Cmdline(w http.ResponseWriter, r *http.Request) {

        w.Header().Set("Content-Type", "text/plain; charset=utf-8")

        fmt.Fprintf(w, strings.Join(os.Args, "\x00"))

}

// Heap responds with the pprof-formatted heap profile.

// The package initialization registers it as /debug/pprof/heap.

func Heap(w http.ResponseWriter, r *http.Request) {

        w.Header().Set("Content-Type", "text/plain; charset=utf-8")

        pprof.WriteHeapProfile(w)

}

// Profile responds with the pprof-formatted cpu profile.

// The package initialization registers it as /debug/pprof/profile.

func Profile(w http.ResponseWriter, r *http.Request) {

        sec, _ := strconv.ParseInt(r.FormValue("seconds"), 10, 64)

        if sec == 0 {

                sec = 30

        }

        // Set Content Type assuming StartCPUProfile will work,

        // because if it does it starts writing.

        w.Header().Set("Content-Type", "application/octet-stream")

        if err := pprof.StartCPUProfile(w); err != nil {

                // StartCPUProfile failed, so no writes yet.

                // Can change header back to text content

                // and send error code.

                w.Header().Set("Content-Type", "text/plain; charset=utf-8")

                w.WriteHeader(http.StatusInternalServerError)

                fmt.Fprintf(w, "Could not enable CPU profiling: %s\n", err)

                return

        }

        time.Sleep(time.Duration(sec) * time.Second)

        pprof.StopCPUProfile()

}

// Symbol looks up the program counters listed in the request,

// responding with a table mapping program counters to function names.

// The package initialization registers it as /debug/pprof/symbol.

func Symbol(w http.ResponseWriter, r *http.Request) {

        w.Header().Set("Content-Type", "text/plain; charset=utf-8")

        // We have to read the whole POST body before

        // writing any output.  Buffer the output here.

        var buf bytes.Buffer

        // We don't know how many symbols we have, but we

        // do have symbol information.  Pprof only cares whether

        // this number is 0 (no symbols available) or > 0.

        fmt.Fprintf(&buf, "num_symbols: 1\n")

        var b *bufio.Reader

        if r.Method == "POST" {

                b = bufio.NewReader(r.Body)

        } else {

                b = bufio.NewReader(strings.NewReader(r.URL.RawQuery))

        }

        for {

                word, err := b.ReadSlice('+')

                if err == nil {

                        word = word[0 : len(word)-1] // trim +

                }

                pc, _ := strconv.ParseUint(string(word), 0, 64)

                if pc != 0 {

                        f := runtime.FuncForPC(uintptr(pc))

                        if f != nil {

                                fmt.Fprintf(&buf, "%#x %s\n", pc, f.Name())

                        }

                }

                // Wait until here to check for err; the last

                // symbol will have an err because it doesn't end in +.

                if err != nil {

                        if err != io.EOF {

                                fmt.Fprintf(&buf, "reading request: %v\n", err)

                        }

                        break

                }

        }

        w.Write(buf.Bytes())

}