func main() {
flag.Parse()
if arguments.pprof {
log.Println("pprof enabled")
go func() {
log.Println(http.ListenAndServe("localhost:6060", nil))
}()
fp, err := os.Create("backend.pprof")
if err != nil {
panic(err)
}
defer fp.Close()
pprof.StartCPUProfile(fp)
defer pprof.StopCPUProfile()
}
if err := loadTree(arguments.tree); err != nil {
log.Println(err)
os.Exit(-1)
}
http.Handle("/", http.FileServer(http.Dir(arguments.web)))
http.Handle("/render", websocket.Handler(renderServer))
log.Println("waiting for connections...")
if err := http.ListenAndServe(fmt.Sprintf(":%v", arguments.port), nil); err != nil {
log.Println(err)
os.Exit(-1)
}
}
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)
}
})
}
}
func main() {
list_T := make([]*buffered.Token, M)
list_D := make([]*buffered.Data, M)
t := time.Now()
f, _ := os.Create("with_bufferManager.prof")
pprof.StartCPUProfile(f)
m := buffered.NewBufferManager(M * 2)
for i := 0; i < N; i++ {
for j := 0; j < M; j++ {
t := m.GetToken()
t.Data.Str = "haha"
list_T[j] = t
}
for j := 0; j < M; j++ {
list_T[j].Return()
}
}
fmt.Printf("With bufferManager: %v\n", time.Since(t))
pprof.StopCPUProfile()
t = time.Now()
f, _ = os.Create("without_bufferManager.prof")
pprof.StartCPUProfile(f)
for i := 0; i < N; i++ {
for j := 0; j < M; j++ {
d := new(buffered.Data)
d.Str = "haha"
list_D[j] = d
}
}
fmt.Printf("Without buffermanager (Relying on GC): %v\n", time.Since(t))
pprof.StopCPUProfile()
}
// Merges all packages in *unpackedPath into a big index shard.
func mergeToShard() {
names := packageNames()
indexFiles := make([]string, 0, len(names))
for _, name := range names {
if strings.HasSuffix(name, ".idx") && name != "full.idx" {
indexFiles = append(indexFiles, filepath.Join(*unpackedPath, name))
}
}
filesInIndex.Set(float64(len(indexFiles)))
log.Printf("Got %d index files\n", len(indexFiles))
if len(indexFiles) < 2 {
return
}
tmpIndexPath, err := ioutil.TempFile(*unpackedPath, "newshard")
if err != nil {
log.Fatal(err)
}
if *cpuProfile != "" {
f, err := os.Create(*cpuProfile)
if err != nil {
log.Fatal(err)
}
defer f.Close()
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
t0 := time.Now()
index.ConcatN(tmpIndexPath.Name(), indexFiles...)
t1 := time.Now()
log.Printf("merged in %v\n", t1.Sub(t0))
//for i := 1; i < len(indexFiles); i++ {
// log.Printf("merging %s with %s\n", indexFiles[i-1], indexFiles[i])
// t0 := time.Now()
// index.Concat(tmpIndexPath.Name(), indexFiles[i-1], indexFiles[i])
// t1 := time.Now()
// log.Printf("merged in %v\n", t1.Sub(t0))
//}
log.Printf("merged into shard %s\n", tmpIndexPath.Name())
// If full.idx does not exist (i.e. on initial deployment), just move the
// new index to full.idx, the dcs-index-backend will not be running anyway.
fullIdxPath := filepath.Join(*unpackedPath, "full.idx")
if _, err := os.Stat(fullIdxPath); os.IsNotExist(err) {
if err := os.Rename(tmpIndexPath.Name(), fullIdxPath); err != nil {
log.Fatal(err)
}
return
}
successfulMerges.Inc()
// Replace the current index with the newly created index.
if _, err := indexBackend.ReplaceIndex(context.Background(), &proto.ReplaceIndexRequest{ReplacementPath: filepath.Base(tmpIndexPath.Name())}); err != nil {
log.Fatalf("dcs-index-backend ReplaceIndex failed: %v", err)
}
}
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())
}
// Starts all profiles set on the options.
func benchStartProfiling(options *BenchOptions) {
var err error
// Start CPU profiling.
if options.CPUProfile != "" {
cpuprofile, err = os.Create(options.CPUProfile)
if err != nil {
fatal("bench: could not create cpu profile %q: %v", options.CPUProfile, err)
}
pprof.StartCPUProfile(cpuprofile)
}
// Start memory profiling.
if options.MemProfile != "" {
memprofile, err = os.Create(options.MemProfile)
if err != nil {
fatal("bench: could not create memory profile %q: %v", options.MemProfile, err)
}
runtime.MemProfileRate = 4096
}
// Start fatal profiling.
if options.BlockProfile != "" {
blockprofile, err = os.Create(options.BlockProfile)
if err != nil {
fatal("bench: could not create block profile %q: %v", options.BlockProfile, err)
}
runtime.SetBlockProfileRate(1)
}
}
func RunCompress(codec encoding.Integer, in []int32, length int, prof bool) (duration int64, out []int32, err error) {
out = make([]int32, length*2)
inpos := cursor.New()
outpos := cursor.New()
now := time.Now()
if prof {
f, e := os.Create("cpu.compress.pprof")
if e != nil {
log.Fatal(e)
}
defer f.Close()
pprof.StartCPUProfile(f)
}
if err = codec.Compress(in, inpos, len(in), out, outpos); err != nil {
return 0, nil, err
}
since := time.Since(now).Nanoseconds()
if prof {
pprof.StopCPUProfile()
}
return since, out[:outpos.Get()], nil
}
// 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)
}
}
}
// 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)
}
}()
}
}
func main() {
c := initConfig()
offset := 0
if c.Offset {
offset = 1
}
if c.CPUProfile != "" {
f, err := os.Create(c.CPUProfile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if c.SortPoints {
c.Points.SortPoints()
}
t := smt.InitTree(&c.Points)
optimize(t, offset, c.Iteration)
}
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()
}
}
}
// Starts all profiles set on the options.
func (cmd *BenchCommand) startProfiling(options *BenchOptions) {
var err error
// Start CPU profiling.
if options.CPUProfile != "" {
cpuprofile, err = os.Create(options.CPUProfile)
if err != nil {
fmt.Fprintf(cmd.Stderr, "bench: could not create cpu profile %q: %v\n", options.CPUProfile, err)
os.Exit(1)
}
pprof.StartCPUProfile(cpuprofile)
}
// Start memory profiling.
if options.MemProfile != "" {
memprofile, err = os.Create(options.MemProfile)
if err != nil {
fmt.Fprintf(cmd.Stderr, "bench: could not create memory profile %q: %v\n", options.MemProfile, err)
os.Exit(1)
}
runtime.MemProfileRate = 4096
}
// Start fatal profiling.
if options.BlockProfile != "" {
blockprofile, err = os.Create(options.BlockProfile)
if err != nil {
fmt.Fprintf(cmd.Stderr, "bench: could not create block profile %q: %v\n", options.BlockProfile, err)
os.Exit(1)
}
runtime.SetBlockProfileRate(1)
}
}
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 main() {
defer tlog.FuncLog(tlog.Func("main"))
cpuProfile := flag.String("cpu-profile", "", "write cpu profile to file")
isServerProcess := flag.Bool("s", false, "start hialin server only")
flag.Parse()
if *cpuProfile != "" {
f, err := os.Create(*cpuProfile)
if err != nil {
tlog.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if *isServerProcess {
serverMain()
} else if singleProcess {
go serverMain()
client.Main(serverAddress)
} else {
findOrExecServer()
client.Main(serverAddress)
}
}
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() {
flag.Parse()
fmt.Printf("CONCURRENT: %d SAMPLES: %d REQUESTS: %d\n\n", *C, *R, *N)
if *cpuprof != "" {
file, err := os.OpenFile(*cpuprof, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
fmt.Fprintln(os.Stderr, err.Error())
os.Exit(1)
}
defer file.Close()
pprof.StartCPUProfile(file)
defer pprof.StopCPUProfile()
}
redis.MaxConnections = *C
for _, name := range flag.Args() {
run(name)
}
println("ConnSum:", redis.ConnSum)
stats := new(runtime.MemStats)
runtime.ReadMemStats(stats)
}
// Parses non-configuration flags.
func parseFlags() {
var versionFlag bool
var cpuprofile string
f := flag.NewFlagSet(os.Args[0], -1)
f.SetOutput(ioutil.Discard)
f.BoolVar(&versionFlag, "version", false, "print the version and exit")
f.StringVar(&cpuprofile, "cpuprofile", "", "write cpu profile to file")
f.Parse(os.Args[1:])
// Print version if necessary.
if versionFlag {
fmt.Println(server.ReleaseVersion)
os.Exit(0)
}
// Begin CPU profiling if specified.
if cpuprofile != "" {
f, err := os.Create(cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
sig := <-c
log.Infof("captured %v, stopping profiler and exiting..", sig)
pprof.StopCPUProfile()
os.Exit(1)
}()
}
}
func (c *CommandCPUProf) run(args []string) string {
if len(args) == 0 {
return c.usage()
}
switch args[0] {
case "start":
fn := profileName() + ".cpuprof"
f, err := os.Create(fn)
if err != nil {
return err.Error()
}
err = pprof.StartCPUProfile(f)
if err != nil {
f.Close()
return err.Error()
}
return fn
case "stop":
pprof.StopCPUProfile()
return ""
default:
return c.usage()
}
}
func main() {
f, _ := os.Create("lrutest.cpuprofile")
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
cache := lru1.NewCache(1000)
count := 0
miss := 0
in := bufio.NewScanner(os.Stdin)
for in.Scan() {
f := strings.Split(in.Text(), "|")
if len(f) > 2 {
email := strings.Split(f[2], "@")
if len(email) > 1 {
domain := email[1]
if i := cache.Get(domain); i == nil {
cache.Put(domain, f[2])
miss += 1
}
count += 1
}
}
}
fmt.Printf("%d total %d misses\n", count, miss)
}
func main() {
flag.Parse()
needed := requirements()
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
for steps := range square1.Sequences(square1.PossibleMoves) {
if square1.Satisfies(needed, steps) {
names := []string{}
move := steps
for {
names = append(names, move.Name)
if move.Next != nil {
move = move.Next
} else {
break
}
}
fmt.Println(names)
return
}
}
}
func main() {
kingpin.Version("0.0.7")
kingpin.Parse()
//go tool pprof --pdf saxer cpu.pprof > callgraph.pdf
//evince callgraph.pdf
if *cpuProfile {
f, err := os.Create("cpu.pprof")
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
fmt.Println("profiling!")
defer pprof.StopCPUProfile()
}
if strings.TrimSpace(*filename) != "" {
absFilename, err := abs(*filename)
if err != nil {
fmt.Printf("Error finding file: %s\n", absFilename)
}
file, err := os.Open(absFilename)
if err != nil {
fmt.Printf("Error opening file: %s\n", absFilename)
}
defer file.Close()
SaxXmlInput(file)
} else {
reader := bufio.NewReader(os.Stdin)
SaxXmlInput(reader)
}
}
func main() {
svr := &service.Server{
KeepAlive: keepAlive,
ConnectTimeout: connectTimeout,
AckTimeout: ackTimeout,
TimeoutRetries: timeoutRetries,
SessionsProvider: sessionsProvider,
TopicsProvider: topicsProvider,
}
var f *os.File
var err error
if cpuprofile != "" {
f, err = os.Create(cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
}
sigchan := make(chan os.Signal, 1)
signal.Notify(sigchan, os.Interrupt, os.Kill)
go func() {
sig := <-sigchan
glog.Errorf("Existing due to trapped signal; %v", sig)
if f != nil {
glog.Errorf("Stopping profile")
pprof.StopCPUProfile()
f.Close()
}
svr.Close()
os.Exit(0)
}()
mqttaddr := "tcp://:1883"
if len(wsAddr) > 0 || len(wssAddr) > 0 {
addr := "tcp://127.0.0.1:1883"
AddWebsocketHandler("/mqtt", addr)
/* start a plain websocket listener */
if len(wsAddr) > 0 {
go ListenAndServeWebsocket(wsAddr)
}
/* start a secure websocket listener */
if len(wssAddr) > 0 && len(wssCertPath) > 0 && len(wssKeyPath) > 0 {
go ListenAndServeWebsocketSecure(wssAddr, wssCertPath, wssKeyPath)
}
}
/* create plain MQTT listener */
err = svr.ListenAndServe(mqttaddr)
if err != nil {
glog.Errorf("surgemq/main: %v", err)
}
}
func main() {
flag.Parse()
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
h := bh.NewHive()
openflow.StartOpenFlow(h)
controller.RegisterNOMController(h)
discovery.RegisterDiscovery(h)
// Register a switch:
// switching.RegisterSwitch(h, bh.Persistent(1))
// or a hub:
// switching.RegisterHub(h, bh.NonTransactional())
// routing.InstallRouter(h, bh.Persistent(1))
routing.InstallLoadBalancer(h, bh.Persistent(1))
h.Start()
}
// start cpu profile monitor
func StartCPUProfile() {
f, err := os.Create("cpu-" + strconv.Itoa(pid) + ".pprof")
if err != nil {
log.Fatal(err)
}
runtimePprof.StartCPUProfile(f)
}
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")
}
}
}
// before runs before all testing.
func before() {
if *memProfileRate > 0 {
runtime.MemProfileRate = *memProfileRate
}
if *cpuProfile != "" {
f, err := os.Create(toOutputDir(*cpuProfile))
if err != nil {
fmt.Fprintf(os.Stderr, "testing: %s", err)
return
}
if err := pprof.StartCPUProfile(f); err != nil {
fmt.Fprintf(os.Stderr, "testing: can't start cpu profile: %s", err)
f.Close()
return
}
// Could save f so after can call f.Close; not worth the effort.
}
if *blockProfile != "" && *blockProfileRate >= 0 {
runtime.SetBlockProfileRate(*blockProfileRate)
}
if *coverProfile != "" && cover.Mode == "" {
fmt.Fprintf(os.Stderr, "testing: cannot use -test.coverprofile because test binary was not built with coverage enabled\n")
os.Exit(2)
}
}
func omain() {
f, err := os.Create("profile.out")
if err != nil {
log.Fatal("Cannot create profile")
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
var sieve euler.SieveHeap
num := start
for {
prime := sieve.Next()
if num == prime {
fmt.Printf("%d\n", prime)
break
}
// Divide out the prime as many times as possible.
for num%prime == 0 {
num /= prime
}
}
// for i := 0; i < 100; i++ {
// fmt.Printf("%8d\n", sieve.Next())
// }
bench()
}
// StartProfile initializes the cpu and memory profile, if specified.
func startProfile(cpuprofile, memprofile string) {
if cpuprofile != "" {
f, err := os.Create(cpuprofile)
if err != nil {
log.Fatalf("cpuprofile: %v", err)
}
log.Printf("writing CPU profile to: %s\n", cpuprofile)
prof.cpu = f
pprof.StartCPUProfile(prof.cpu)
}
if memprofile != "" {
f, err := os.Create(memprofile)
if err != nil {
log.Fatalf("memprofile: %v", err)
}
log.Printf("writing mem profile to: %s\n", memprofile)
prof.mem = f
runtime.MemProfileRate = 4096
}
go func() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c
stopProfile()
os.Exit(0)
}()
}
func SetupCPUProfile(app *cli.App) {
app.Flags = append(app.Flags, cli.StringFlag{
Name: "cpuprofile",
Usage: "write cpu profile to file",
EnvVar: "CPU_PROFILE",
})
appBefore := app.Before
appAfter := app.After
app.Before = func(c *cli.Context) error {
if cpuProfile := c.String("cpuprofile"); cpuProfile != "" {
f, err := os.Create(cpuProfile)
if err != nil {
return err
}
pprof.StartCPUProfile(f)
}
if appBefore != nil {
return appBefore(c)
}
return nil
}
app.After = func(c *cli.Context) error {
pprof.StopCPUProfile()
if appAfter != nil {
return appAfter(c)
}
return nil
}
}
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()
}