Introduce CpuProfiler, CpuProfile, and CpuProfileNode

README.md

@@ -101,7 +101,7 @@ go func() {
 
 select {
 case val := <- vals:
-    // sucess
+    // success
 case err := <- errs:
     // javascript error
 case <- time.After(200 * time.Milliseconds):
@@ -111,6 +111,47 @@ case <- time.After(200 * time.Milliseconds):
 }
 ```
 
+### CPU Profiler
+
+```
+func createProfile() {
+  cpuProfiler := v8.NewCPUProfiler(v8.NewIsolate()) // create a new profiler
+  cpuProfiler.StartProfiling("my-profile") // start profiling
+
+  ctx.RunScript(src, filename) # src is the profile script from cpuprofiler_test.go
+
+  cpuProfile := cpuProfiler.StopProfiling("my-profile") // stop profiling returns a cpu profile
+
+  printTree("", cpuProfile.Root) // a helper function for printing the tree
+}
+
+func printTree(nest string, node *v8.CPUProfileNode) {
+	fmt.Printf("%s%s %s:%d:%d\n", nest, node.FunctionName, node.ScriptResourceName, node.LineNumber, node.ColumnNumber)
+	if len(node.Children) == 0 {
+		return
+	}
+	nest = fmt.Sprintf("%s  ", nest)
+	for _, c := range node.Children {
+		printTree(nest, c)
+	}
+}
+
+<!-- Top Down Root -->
+<!-- (root) :0:0 -->
+<!--   (program) :0:0 -->
+<!--   start script.js:23:15 -->
+<!--     foo script.js:15:13 -->
+<!--       delay script.js:12:15 -->
+<!--         loop script.js:1:14 -->
+<!--       bar script.js:13:13 -->
+<!--         delay script.js:12:15 -->
+<!--           loop script.js:1:14 -->
+<!--       baz script.js:14:13 -->
+<!--         delay script.js:12:15 -->
+<!--           loop script.js:1:14 -->
+<!--   (garbage collector) :0:0 -->
+```
+
 ## Documentation
 
 Go Reference & more examples: https://pkg.go.dev/rogchap.com/v8go

cpuprofiler.go

@@ -0,0 +1,122 @@
+// Copyright 2021 Roger Chapman and the v8go contributors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package v8go
+
+/*
+#include <stdlib.h>
+#include "v8go.h"
+*/
+import "C"
+import (
+	"time"
+	"unsafe"
+)
+
+type CPUProfiler struct {
+	p   *C.CPUProfiler
+	iso *Isolate
+}
+
+// CPUProfiler is used to control CPU profiling.
+func NewCPUProfiler(iso *Isolate) *CPUProfiler {
+	profiler := C.NewCPUProfiler(iso.ptr)
+	return &CPUProfiler{
+		p:   (*C.CPUProfiler)(unsafe.Pointer(profiler)),
+		iso: iso,
+	}
+}
+
+// Dispose will dispose the profiler.
+func (c *CPUProfiler) Dispose() {
+	if c.p == nil {
+		return
+	}
+
+	C.CPUProfilerDispose((*C.CPUProfiler)(unsafe.Pointer(c.p)))
+	c.p = nil
+}
+
+// StartProfiling starts collecting a CPU profile. Title may be an empty string. Several
+// profiles may be collected at once. Attempts to start collecting several
+// profiles with the same title are silently ignored.
+func (c *CPUProfiler) StartProfiling(title string) {
+	if c.p == nil || c.iso.ptr == nil {
+		return
+	}
+
+	tstr := C.CString(title)
+	defer C.free(unsafe.Pointer(tstr))
+
+	C.CPUProfilerStartProfiling((*C.CPUProfiler)(unsafe.Pointer(c.p)), tstr)
+}
+
+// Stops collecting CPU profile with a given title and returns it.
+// If the title given is empty, finishes the last profile started.
+func (c *CPUProfiler) StopProfiling(title string) *CPUProfile {
+	if c.p == nil || c.iso.ptr == nil {
+		return nil
+	}
+
+	tstr := C.CString(title)
+	defer C.free(unsafe.Pointer(tstr))
+
+	profile := C.CPUProfilerStopProfiling((*C.CPUProfiler)(unsafe.Pointer(c.p)), tstr)
+	p := (*C.CPUProfile)(unsafe.Pointer(profile))
+
+	return &CPUProfile{
+		p:         p,
+		Title:     C.GoString(p.title),
+		Root:      NewCPUProfileNode(p.root, nil),
+		StartTime: time.Unix(0, int64(p.startTime)/1000),
+		EndTime:   time.Unix(0, int64(p.endTime)/1000),
+	}
+}
+
+type CPUProfile struct {
+	p *C.CPUProfile
+
+	Title     string
+	Root      *CPUProfileNode
+	StartTime time.Time
+	EndTime   time.Time
+}
+
+type CPUProfileNode struct {
+	p *C.CPUProfileNode
+
+	ScriptResourceName string
+	FunctionName       string
+	LineNumber         int
+	ColumnNumber       int
+	Children           []*CPUProfileNode
+	Parent             *CPUProfileNode
+}
+
+func NewCPUProfileNode(node *C.CPUProfileNode, parent *CPUProfileNode) *CPUProfileNode {
+	n := &CPUProfileNode{
+		p:                  node,
+		ScriptResourceName: C.GoString(node.scriptResourceName),
+		FunctionName:       C.GoString(node.functionName),
+		LineNumber:         int(node.lineNumber),
+		ColumnNumber:       int(node.columnNumber),
+		Parent:             parent,
+	}
+
+	if node.childrenCount > 0 {
+		for _, child := range (*[1 << 28]*C.CPUProfileNode)(unsafe.Pointer(node.children))[:node.childrenCount:node.childrenCount] {
+			n.Children = append(n.Children, NewCPUProfileNode(child, n))
+		}
+	}
+
+	return n
+}
+
+func (c *CPUProfile) Delete() {
+	if c.p == nil {
+		return
+	}
+	C.CPUProfileDelete(c.p)
+	c.p = nil
+}