func startProfile() { if cpuprofile != "" { f, err := os.Create(cpuprofile) if err != nil { log.Fatalf("%v", err) } if err := pprof.StartCPUProfile(f); err != nil { log.Fatalf("%v", err) } AtExit(pprof.StopCPUProfile) } if memprofile != "" { if memprofilerate != 0 { runtime.MemProfileRate = int(memprofilerate) } f, err := os.Create(memprofile) if err != nil { log.Fatalf("%v", err) } AtExit(func() { runtime.GC() // profile all outstanding allocations if err := pprof.WriteHeapProfile(f); err != nil { log.Fatalf("%v", err) } }) } }
// runBenchmarkOnce runs f once and collects all performance metrics and profiles. func runBenchmarkOnce(f func(uint64), N uint64) Result { latencyInit(N) runtime.GC() mstats0 := new(runtime.MemStats) runtime.ReadMemStats(mstats0) ss := InitSysStats(N) res := MakeResult() res.N = N res.Files["memprof0"] = tempFilename("memprof") memprof0, err := os.Create(res.Files["memprof0"]) if err != nil { log.Fatalf("Failed to create profile file '%v': %v", res.Files["memprof0"], err) } pprof.WriteHeapProfile(memprof0) memprof0.Close() res.Files["cpuprof"] = tempFilename("cpuprof") cpuprof, err := os.Create(res.Files["cpuprof"]) if err != nil { log.Fatalf("Failed to create profile file '%v': %v", res.Files["cpuprof"], err) } defer cpuprof.Close() pprof.StartCPUProfile(cpuprof) t0 := time.Now() f(N) res.Duration = time.Since(t0) res.RunTime = uint64(time.Since(t0)) / N res.Metrics["time"] = res.RunTime pprof.StopCPUProfile() latencyCollect(&res) ss.Collect(&res) res.Files["memprof"] = tempFilename("memprof") memprof, err := os.Create(res.Files["memprof"]) if err != nil { log.Fatalf("Failed to create profile file '%v': %v", res.Files["memprof"], err) } pprof.WriteHeapProfile(memprof) memprof.Close() mstats1 := new(runtime.MemStats) runtime.ReadMemStats(mstats1) res.Metrics["allocated"] = (mstats1.TotalAlloc - mstats0.TotalAlloc) / N res.Metrics["allocs"] = (mstats1.Mallocs - mstats0.Mallocs) / N res.Metrics["sys-total"] = mstats1.Sys res.Metrics["sys-heap"] = mstats1.HeapSys res.Metrics["sys-stack"] = mstats1.StackSys res.Metrics["gc-pause-total"] = (mstats1.PauseTotalNs - mstats0.PauseTotalNs) / N collectGo12MemStats(&res, mstats0, mstats1) numGC := uint64(mstats1.NumGC - mstats0.NumGC) if numGC == 0 { res.Metrics["gc-pause-one"] = 0 } else { res.Metrics["gc-pause-one"] = (mstats1.PauseTotalNs - mstats0.PauseTotalNs) / numGC } return res }
func main() { inputPath := flag.String("input", "-", "Input filename, '-' for stdin") cpuprofile := flag.String("cpuprofile", "", "Write CPU profile to file") memprofile := flag.String("memprofile", "", "Write memory profile to file") flag.Parse() if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { log.Println(err.Error()) os.Exit(1) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() defer f.Close() } if *memprofile != "" { f, err := os.Create(*memprofile) if err != nil { log.Println(err.Error()) os.Exit(1) } go func() { for { time.Sleep(5 * time.Second) pprof.WriteHeapProfile(f) } }() defer pprof.WriteHeapProfile(f) defer f.Close() } sigIntChan := make(chan os.Signal, 1) signal.Notify(sigIntChan, syscall.SIGINT) go func() { <-sigIntChan os.Exit(1) }() // Initialize input reading log.Println("Reading from", *inputPath) var inputFile *os.File = os.Stdin if *inputPath != "-" { var err error inputFile, err = os.Open(*inputPath) if err != nil { log.Println(err.Error()) os.Exit(1) } defer inputFile.Close() } input := bufio.NewReader(inputFile) // TODO output := os.Stdout process(Config, input, output) }
func main() { go func() { if *memprofile != "" { written := false for { if written { os.Remove(*memprofile) } f, err := os.Create(*memprofile) if err != nil { log.Fatal(err) } pprof.WriteHeapProfile(f) time.Sleep(1 * time.Millisecond) f.Close() } } }() args, err := GetLegacyArguments() if err != nil { fmt.Println(err.Error()) return } if args.Help { flag.Usage() return } legacy, err := args.GetLegacy() if err != nil { log.Println(err) return } legacy.SetupLogging() legacy.Run() if *memprofile != "" { f, err := os.Create(*memprofile) if err != nil { log.Fatal(err) } pprof.WriteHeapProfile(f) f.Close() return } legacy.ShutdownLogging() }
// initConfig is run by cobra after initialising the flags func initConfig() { // Log file output if *logFile != "" { f, err := os.OpenFile(*logFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0640) if err != nil { log.Fatalf("Failed to open log file: %v", err) } _, err = f.Seek(0, os.SEEK_END) if err != nil { fs.ErrorLog(nil, "Failed to seek log file to end: %v", err) } log.SetOutput(f) fs.DebugLogger.SetOutput(f) redirectStderr(f) } // Load the rest of the config now we have started the logger fs.LoadConfig() // Write the args for debug purposes fs.Debug("rclone", "Version %q starting with parameters %q", fs.Version, os.Args) // Setup CPU profiling if desired if *cpuProfile != "" { fs.Log(nil, "Creating CPU profile %q\n", *cpuProfile) f, err := os.Create(*cpuProfile) if err != nil { fs.Stats.Error() log.Fatal(err) } err = pprof.StartCPUProfile(f) if err != nil { fs.Stats.Error() log.Fatal(err) } defer pprof.StopCPUProfile() } // Setup memory profiling if desired if *memProfile != "" { defer func() { fs.Log(nil, "Saving Memory profile %q\n", *memProfile) f, err := os.Create(*memProfile) if err != nil { fs.Stats.Error() log.Fatal(err) } err = pprof.WriteHeapProfile(f) if err != nil { fs.Stats.Error() log.Fatal(err) } err = f.Close() if err != nil { fs.Stats.Error() log.Fatal(err) } }() } }
// Profile starts CPU and memory profiling and returns a function that will stop that. // // // Writes "cpu" + filename and "mem" + filename. // // Usage: // // defer Profile("logfast.prof")() // func Profile(filename string) func() { cpu, err := os.Create("cpu" + filename) if err != nil { panic(err) } mem, err := os.Create("mem" + filename) if err != nil { panic(err) } then := time.Now() log.Printf("Profile starting %s\n", filename) pprof.StartCPUProfile(cpu) pprof.WriteHeapProfile(mem) return func() { elapsed := time.Now().Sub(then) log.Printf("Profile stopping %s (elapsed %v)\n", filename, elapsed) pprof.StopCPUProfile() if err := mem.Close(); err != nil { log.Printf("error closing mem profile (%v)", err) } } }
func saveHeapProfiles() { runtime.MemProfileRate = 1 var memstats, prevMemstats runtime.MemStats t0 := time.Now() for t := range time.NewTicker(250 * time.Millisecond).C { startms := int(t.Sub(t0).Seconds() * 1000) runtime.ReadMemStats(&memstats) if memstats.HeapInuse > prevMemstats.HeapInuse { fd, err := os.Create(fmt.Sprintf("heap-%05d-%07d.pprof", syscall.Getpid(), startms)) if err != nil { panic(err) } err = pprof.WriteHeapProfile(fd) if err != nil { panic(err) } err = fd.Close() if err != nil { panic(err) } prevMemstats = memstats } } }
func main() { flag.Parse() log.SetFlags(log.Lshortfile | log.Ltime) fmt.Printf( `lldb: version exp Keys: 16 bytes each Values: 100 bytes each (50 bytes after compression) Entries: 1000000 RawSize: 110.6 MB (estimated) FileSize: 62.9 MB (estimated) ------------------------------------------------ `) if *memprofile != "" { runtime.MemProfileRate = 1 } fillseq() if *memprofile != "" { f, err := os.Create(*memprofile) if err != nil { log.Fatal(err) } pprof.WriteHeapProfile(f) f.Close() return } }
func main() { flag.Parse() if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { fmt.Println("Error: ", err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } if *memprofile != "" { f, err := os.Create(*memprofile) if err != nil { fmt.Println("Error: ", err) } pprof.WriteHeapProfile(f) } var wg sync.WaitGroup cidrs, err := parseCidrs("./hosts.json") if err != nil { log.Fatal(err) } servers := make([]Server, 0, 10) for k := range cidrs.Cidrs { servers = append(servers, Server{Cidr: cidrs.Cidrs[k]}) } fmt.Println(len(servers)) for k := range servers { wg.Add(1) go servers[k].checkIP(&wg) } wg.Wait() }
func main() { f, err := os.Create("cpuprofile.prof") if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() fmt.Printf("GoHM Software Version [%s]\n", TLibCommon.NV_VERSION) if len(os.Args) <= 2 { fmt.Printf("Usage: \n") fmt.Printf(" HM Encoder: gohm.exe -c encoder.cfg [trace.txt]\n") fmt.Printf(" HM Decoder: gohm.exe -d test.bin test.yuv [n trace.txt]\n") } else { if os.Args[1] == "-c" { Encoder() } else if os.Args[1] == "-d" { Decoder() } else { fmt.Printf("Unknown argment %s\n", os.Args[1]) } } m, err := os.Create("memprofile.prof") if err != nil { log.Fatal(err) } pprof.WriteHeapProfile(m) m.Close() }
func main() { argParse() runtime.GOMAXPROCS(runtime.NumCPU()) // start cpu profile. fname := "client.pprof" fd, err := os.Create(fname) if err != nil { log.Fatalf("unable to create %q: %v\n", fname, err) } defer fd.Close() pprof.StartCPUProfile(fd) defer pprof.StopCPUProfile() doTransport() // take memory profile. fname = "client.mprof" fd, err = os.Create(fname) if err != nil { log.Fatal(err) } defer fd.Close() pprof.WriteHeapProfile(fd) }
func cleanup() { Debug("cleanup") // write memory profile if *flag_memprof != "" { f, err := os.Create(*flag_memprof) if err != nil { Log(err) } Log("Writing memory profile to", *flag_memprof) pprof.WriteHeapProfile(f) f.Close() } // write cpu profile if *flag_cpuprof != "" { Log("Flushing CPU profile", *flag_cpuprof) pprof.StopCPUProfile() } // print timers if *flag_debug { PrintTimers() } cuda.DeviceReset() // kill subprocess? }
// Start starts listeners func (s *Service) Start() error { s.Dispatcher.Run() f, err := os.Create("cpu.prof") if err != nil { log.Fatal("could not create CPU profile: ", err) } if err := pprof.StartCPUProfile(f); err != nil { log.Fatal("could not start CPU profile: ", err) } defer pprof.StopCPUProfile() f2, err := os.Create("mem.prof") if err != nil { log.Fatal("could not create memory profile: ", err) } runtime.GC() // get up-to-date statistics if err := pprof.WriteHeapProfile(f2); err != nil { log.Fatal("could not write memory profile: ", err) } f2.Close() server := &http.Server{ Addr: fmt.Sprintf("%s:%d", s.config.Interface, s.config.Port), Handler: &myHandler{}, ReadTimeout: 2 * time.Second, WriteTimeout: 2 * time.Second, MaxHeaderBytes: 1 << 20, } mux = make(map[string]func(http.ResponseWriter, *http.Request)) mux["/v1/events"] = s.eventConsumerHandler return server.ListenAndServe() }
func doprofile(fn string) { var err error var fc, fh, ft *os.File for i := 1; i > 0; i++ { fc, err = os.Create(fn + "-cpu-" + strconv.Itoa(i) + ".prof") if err != nil { log.Fatal(err) } pprof.StartCPUProfile(fc) time.Sleep(300 * time.Second) pprof.StopCPUProfile() fc.Close() fh, err = os.Create(fn + "-heap-" + strconv.Itoa(i) + ".prof") if err != nil { log.Fatal(err) } pprof.WriteHeapProfile(fh) fh.Close() ft, err = os.Create(fn + "-threadcreate-" + strconv.Itoa(i) + ".prof") if err != nil { log.Fatal(err) } pprof.Lookup("threadcreate").WriteTo(ft, 0) ft.Close() log.Println("Created CPU, heap and threadcreate profile of 300 seconds") } }
// after runs after all testing. func after() { if *cpuProfile != "" { pprof.StopCPUProfile() // flushes profile to disk } if *memProfile != "" { f, err := os.Create(*memProfile) if err != nil { fmt.Fprintf(os.Stderr, "testing: %s", err) return } if err = pprof.WriteHeapProfile(f); err != nil { fmt.Fprintf(os.Stderr, "testing: can't write %s: %s", *memProfile, err) } f.Close() } if *blockProfile != "" && *blockProfileRate >= 0 { f, err := os.Create(*blockProfile) if err != nil { fmt.Fprintf(os.Stderr, "testing: %s", err) return } if err = pprof.Lookup("block").WriteTo(f, 0); err != nil { fmt.Fprintf(os.Stderr, "testing: can't write %s: %s", *blockProfile, err) } f.Close() } }
func main() { flag.Parse() if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } lsgraph := NewLSG() cfgraph := NewCFG() cfgraph.CreateNode(0) // top cfgraph.CreateNode(1) // bottom NewBasicBlockEdge(cfgraph, 0, 2) for dummyloop := 0; dummyloop < 15000; dummyloop++ { FindHavlakLoops(cfgraph, NewLSG()) } n := 2 for parlooptrees := 0; parlooptrees < 10; parlooptrees++ { cfgraph.CreateNode(n + 1) buildConnect(cfgraph, 2, n+1) n = n + 1 for i := 0; i < 100; i++ { top := n n = buildStraight(cfgraph, n, 1) for j := 0; j < 25; j++ { n = buildBaseLoop(cfgraph, n) } bottom := buildStraight(cfgraph, n, 1) buildConnect(cfgraph, n, top) n = bottom } buildConnect(cfgraph, n, 1) } FindHavlakLoops(cfgraph, lsgraph) if *memprofile != "" { f, err := os.Create(*memprofile) if err != nil { log.Fatal(err) } pprof.WriteHeapProfile(f) f.Close() return } for i := 0; i < 50; i++ { FindHavlakLoops(cfgraph, NewLSG()) } fmt.Printf("# of loops: %d (including 1 artificial root node)\n", lsgraph.NumLoops()) lsgraph.CalculateNestingLevel() }
func main() { flag.Parse() t := &trie.Tree{} f, err := os.Open(*file) if err != nil { log.Fatalf("os.Open error: %v", err) } reader := bufio.NewReader(f) line, isPrefix, err := reader.ReadLine() for err == nil { if isPrefix { log.Fatalf("line bigger than buffer") } t.Add(string(line)) line, isPrefix, err = reader.ReadLine() } runtime.GC() if *memprofile != "" { f, err := os.Create(*memprofile) if err != nil { log.Fatal(err) } pprof.WriteHeapProfile(f) f.Close() } fmt.Fprintf(os.Stdout, "Done building ternary search tree\n") <-time.After(time.Hour * 24) }
// ShutdownContext shuts context down func ShutdownContext() { if aptly.EnableDebug { if context.fileMemProfile != nil { pprof.WriteHeapProfile(context.fileMemProfile) context.fileMemProfile.Close() context.fileMemProfile = nil } if context.fileCPUProfile != nil { pprof.StopCPUProfile() context.fileCPUProfile.Close() context.fileCPUProfile = nil } if context.fileMemProfile != nil { context.fileMemProfile.Close() context.fileMemProfile = nil } } if context.database != nil { context.database.Close() } if context.downloader != nil { context.downloader.Shutdown() } if context.progress != nil { context.progress.Shutdown() } }
func main() { runtime.GOMAXPROCS(8) flag.Parse() if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { fmt.Errorf("%s\n", err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } file, _ := os.Create("./log.txt") os.Stdout = file os.Stderr = file os.Stdin = file defer file.Close() Start() if *memprofile != "" { f, err := os.Create(*memprofile) if err != nil { fmt.Errorf("%s\n", err) } pprof.WriteHeapProfile(f) f.Close() return } }
func waitForSignals(stoppable Stoppable, filename string, stopped <-chan bool) { ch := make(chan os.Signal) signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT) outer: for { sig := <-ch log.Info("Received signal: %s", sig.String()) switch sig { case syscall.SIGINT, syscall.SIGTERM: runtime.SetCPUProfileRate(0) f, err := os.OpenFile(fmt.Sprintf("%s.mem", filename), os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0600) if err != nil { log.Error("Cannot open memory profile: %s", err) break outer } if err := pprof.WriteHeapProfile(f); err != nil { log.Error("Cannot write memory profile: %s", err) } f.Close() stopCHeapProfiler() // stopCCpuProfiler() stoppable.Stop() break outer // make sure everything stopped before exiting } } // wait for all logging messages to be printed <-stopped time.Sleep(5 * time.Second) os.Exit(0) }
func test() { f, _ := os.Create("ls.prof") flag.Parse() if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer func() { pprof.StopCPUProfile() }() } // ... t := &T{} for i := 0; i < 1000000; i++ { v := reflect.ValueOf(t) if v.Kind() == reflect.Ptr { v = v.Elem() } t.B = append(t.B, i) t.A = append(t.A, sumtest()) } // var buffer bytes.Buffer pprof.WriteHeapProfile(f) // fmt.Println(buffer.String()) }
// -- main func main() { flag.Parse() if *version { fmt.Println(simplepush.VERSION) return } runtime.GOMAXPROCS(runtime.NumCPU()) // Only create profiles if requested. To view the application profiles, // see http://blog.golang.org/profiling-go-programs if *profile != "" { log.Printf("Creating profile...") f, err := os.Create(*profile) if err != nil { log.Fatal(err) } defer func() { log.Printf("Closing profile...") pprof.StopCPUProfile() }() pprof.StartCPUProfile(f) } if *memProfile != "" { defer func() { profFile, err := os.Create(*memProfile) if err != nil { log.Fatalln(err) } pprof.WriteHeapProfile(profFile) profFile.Close() }() } // Load the app from the config file app, err := simplepush.LoadApplicationFromFileName(*configFile, *logging) if err != nil { log.Fatal(err.Error()) } // Report what the app believes the current host to be, and what version. log.Printf("CurrentHost: %s, Version: %s", app.Hostname(), simplepush.VERSION) // wait for sigint sigChan := make(chan os.Signal) signal.Notify(sigChan, syscall.SIGINT, syscall.SIGHUP, SIGUSR1) // And we're underway! errChan := app.Run() select { case err = <-errChan: case <-sigChan: app.Logger().Info("main", "Recieved signal, shutting down.", nil) } app.Stop() if err != nil { panic("Run: " + err.Error()) } }
func bench(cmd *cobra.Command, args []string) { if memProfilefile != "" { f, err := os.Create(memProfilefile) if err != nil { panic(err) } for i := 0; i < benchmarkTimes; i++ { _ = buildSite() } pprof.WriteHeapProfile(f) f.Close() } else { if cpuProfilefile == "" { cpuProfilefile = "/tmp/hugo-cpuprofile" } f, err := os.Create(cpuProfilefile) if err != nil { panic(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() for i := 0; i < benchmarkTimes; i++ { _ = buildSite() } } }
func main() { flag.Parse() if *cpuProfile != "" { f, err := os.Create(*cpuProfile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } g, err := Open(*logPath) if err != nil { panic(err) } if *freebaseDumpPath != "" { if err := g.ReadFreebase(*freebaseDumpPath); err != nil { panic(err) } } log.Println("done!") if *heapProfile != "" { f, err := os.Create(*heapProfile) if err != nil { log.Fatal(err) } runtime.GC() pprof.WriteHeapProfile(f) } }
// HandleError is the actual error handler and will store the error details in analytics if analytics processing is enabled. func (e ErrorHandler) HandleError(w http.ResponseWriter, r *http.Request, err string, errCode int) { if config.EnableAnalytics { t := time.Now() // Track the key ID if it exists authHeaderValue := context.Get(r, AuthHeaderValue) keyName := "" if authHeaderValue != nil { keyName = authHeaderValue.(string) } version := e.Spec.getVersionFromRequest(r) if version == "" { version = "Non Versioned" } if e.TykMiddleware.Spec.APIDefinition.Proxy.StripListenPath { r.URL.Path = strings.Replace(r.URL.Path, e.TykMiddleware.Spec.Proxy.ListenPath, "", 1) } OauthClientID := "" thisSessionState := context.Get(r, SessionData) if thisSessionState != nil { OauthClientID = thisSessionState.(SessionState).OauthClientID } thisRecord := AnalyticsRecord{ r.Method, r.URL.Path, r.ContentLength, r.Header.Get("User-Agent"), t.Day(), t.Month(), t.Year(), t.Hour(), errCode, keyName, t, version, e.Spec.APIDefinition.Name, e.Spec.APIDefinition.APIID, e.Spec.APIDefinition.OrgID, OauthClientID} go analytics.RecordHit(thisRecord) } w.Header().Add("Content-Type", "application/json") w.Header().Add("X-Generator", "tyk.io") log.Debug("Returning error header") w.WriteHeader(errCode) thisError := APIError{fmt.Sprintf("%s", err)} templates.ExecuteTemplate(w, "error.json", &thisError) if doMemoryProfile { pprof.WriteHeapProfile(profileFile) } // Clean up context.Clear(r) }
func main() { flag.Parse() if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { fmt.Errorf("%s\n", err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } file, _ := os.Create("./log.txt") os.Stdout = file os.Stderr = file os.Stdin = file defer file.Close() go Start() engine.Terminated() if *memprofile != "" { f, err := os.Create(*memprofile) if err != nil { fmt.Errorf("%s\n", err) } pprof.WriteHeapProfile(f) f.Close() return } }
func main() { f, err := os.Create("cpuprofile") if err != nil { panic(err.Error()) } f2, err := os.Create("memprofile") if err != nil { panic(err.Error()) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() defer pprof.WriteHeapProfile(f2) m := radix.NewTree() var k []byte for i := 0; i < 100000; i++ { k = murmur.HashString(fmt.Sprint(i)) m.Put(k, k, 1) x, _, _ := m.Get(k) if bytes.Compare(x, k) != 0 { panic("humbug") } } }
func main() { f, err := os.Create("cpuprofile") if err != nil { panic(err.Error()) } f2, err := os.Create("memprofile") if err != nil { panic(err.Error()) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() defer pprof.WriteHeapProfile(f2) benchNode := NewNodeDir("127.0.0.1:1231", "127.0.0.1:1231", "") benchNode.MustStart() var k []byte for i := 0; i < 100000; i++ { k = murmur.HashString(fmt.Sprint(i)) benchNode.Put(common.Item{ Key: k, Value: k, }) } }
// Stop profiling and output results to a file. Also dump a memory profile. func (pro *Prof) Stop() error { pprof.StopCPUProfile() pro.fd.Close() profileDir := "Profile-" + time.Now().Format("Jan_02_2006-15.04.05") if err := os.Mkdir(profileDir, 0777); err != nil { return err } cpuProfilePath := filepath.Join(profileDir, pro.fname) if err := os.Rename(pro.fname+".tmp", cpuProfilePath); err != nil { return fmt.Errorf("failed to rename tmp file: %s", err) } memProfilePath := filepath.Join(profileDir, pro.fname+".mem") memFile, err := os.Create(memProfilePath) if err != nil { return fmt.Errorf("failed to create mem file: %s", err) } defer memFile.Close() runtime.GC() if err := pprof.WriteHeapProfile(memFile); err != nil { return fmt.Errorf("failed to write heap profile: %s", err) } return nil }
// after runs after all testing. func after() { if *cpuProfile != "" { pprof.StopCPUProfile() // flushes profile to disk } if *memProfile != "" { f, err := os.Create(toOutputDir(*memProfile)) if err != nil { fmt.Fprintf(os.Stderr, "testing: %s\n", err) os.Exit(2) } if err = pprof.WriteHeapProfile(f); err != nil { fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *memProfile, err) os.Exit(2) } f.Close() } if *blockProfile != "" && *blockProfileRate >= 0 { f, err := os.Create(toOutputDir(*blockProfile)) if err != nil { fmt.Fprintf(os.Stderr, "testing: %s\n", err) os.Exit(2) } if err = pprof.Lookup("block").WriteTo(f, 0); err != nil { fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *blockProfile, err) os.Exit(2) } f.Close() } if cover.Mode != "" { coverReport() } }