Introduce CpuProfiler, CpuProfile, and CpuProfileNode

cpuprofile.go

@@ -0,0 +1,28 @@
+// Copyright 2019 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"
+
+// CPUProfile contains a CPU profile in a form of top-down call tree
+// (from main() down to functions that do all the work).
+type CPUProfile struct {
+	ptr C.CpuProfilePtr
+	iso *Isolate
+}
+
+// Returns the root node of the top down call tree.
+func (c *CPUProfile) GetTopDownRoot() *CPUProfileNode {
+	ptr := C.CpuProfileGetTopDownRoot(c.ptr)
+	return &CPUProfileNode{ptr: ptr, iso: c.iso}
+}
+
+// Returns CPU profile title.
+func (c *CPUProfile) GetTitle() string {
+	str := C.CpuProfileGetTitle(c.iso.ptr, c.ptr)
+	return C.GoString(str)
+}

cpuprofile_test.go

@@ -0,0 +1,51 @@
+// Copyright 2019 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_test
+
+import (
+	"testing"
+
+	"rogchap.com/v8go"
+)
+
+func TestCPUProfile(t *testing.T) {
+	t.Parallel()
+
+	ctx, _ := v8go.NewContext(nil)
+	iso := ctx.Isolate()
+	defer iso.Dispose()
+	defer ctx.Close()
+
+	cpuProfiler := v8go.NewCPUProfiler(iso)
+	defer cpuProfiler.Dispose()
+
+	cpuProfiler.StartProfiling("cpuprofiletest")
+
+	_, err := ctx.RunScript(profileScript, "script.js")
+	failIf(t, err)
+	val, err := ctx.Global().Get("start")
+	failIf(t, err)
+	fn, err := val.AsFunction()
+	failIf(t, err)
+	_, err = fn.Call()
+	failIf(t, err)
+
+	cpuProfile := cpuProfiler.StopProfiling("cpuprofiletest")
+	if cpuProfile == nil {
+		t.Fatal("expected profiler not to be nil")
+	}
+
+	if cpuProfile.GetTitle() != "cpuprofiletest" {
+		t.Errorf("expected cpuprofiletest, but got %v", cpuProfile.GetTitle())
+	}
+
+	root := cpuProfile.GetTopDownRoot()
+	if root == nil {
+		t.Fatal("expected root not to be nil")
+	}
+	if root.GetFunctionName() != "(root)" {
+		t.Errorf("expected (root), but got %v", root.GetFunctionName())
+	}
+}

cpuprofilenode.go

@@ -0,0 +1,55 @@
+// Copyright 2019 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"
+
+// CPUProfileNode represents a node in a call graph.
+type CPUProfileNode struct {
+	ptr C.CpuProfileNodePtr
+	iso *Isolate
+}
+
+// Returns function name (empty string for anonymous functions.)
+func (c *CPUProfileNode) GetFunctionName() string {
+	str := C.CpuProfileNodeGetFunctionName(c.ptr)
+	return C.GoString(str)
+}
+
+// Retrieves number of children.
+func (c *CPUProfileNode) GetChildrenCount() int {
+	i := C.CpuProfileNodeGetChildrenCount(c.ptr)
+	return int(i)
+}
+
+// Retrieves a child node by index.
+func (c *CPUProfileNode) GetChild(index int) *CPUProfileNode {
+	count := c.GetChildrenCount()
+	if index < 0 || index > count {
+		return nil
+	}
+	ptr := C.CpuProfileNodeGetChild(c.ptr, C.int(index))
+	return &CPUProfileNode{ptr: ptr, iso: c.iso}
+}
+
+// Retrieves the ancestor node, or null if the root.
+func (c *CPUProfileNode) GetParent() *CPUProfileNode {
+	ptr := C.CpuProfileNodeGetParent(c.ptr)
+	return &CPUProfileNode{ptr: ptr, iso: c.iso}
+}
+
+// Returns the number, 1-based, of the line where the function originates.
+func (c *CPUProfileNode) GetLineNumber() int {
+	i := C.CpuProfileNodeGetLineNumber(c.ptr)
+	return int(i)
+}
+
+//  Returns 1-based number of the column where the function originates.
+func (c *CPUProfileNode) GetColumnNumber() int {
+	i := C.CpuProfileNodeGetColumnNumber(c.ptr)
+	return int(i)
+}

cpuprofilenode_test.go

@@ -0,0 +1,101 @@
+// Copyright 2019 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_test
+
+import (
+	"testing"
+
+	"rogchap.com/v8go"
+)
+
+func TestCPUProfileNode(t *testing.T) {
+	t.Parallel()
+
+	ctx, _ := v8go.NewContext(nil)
+	iso := ctx.Isolate()
+	defer iso.Dispose()
+	defer ctx.Close()
+
+	cpuProfiler := v8go.NewCPUProfiler(iso)
+	defer cpuProfiler.Dispose()
+
+	cpuProfiler.StartProfiling("cpuprofilenodetest")
+
+	_, err := ctx.RunScript(profileScript, "script.js")
+	failIf(t, err)
+	val, err := ctx.Global().Get("start")
+	failIf(t, err)
+	fn, err := val.AsFunction()
+	failIf(t, err)
+	_, err = fn.Call()
+	failIf(t, err)
+
+	cpuProfile := cpuProfiler.StopProfiling("cpuprofilenodetest")
+	if cpuProfile == nil {
+		t.Fatal("expected profile not to be nil")
+	}
+
+	root := cpuProfile.GetTopDownRoot()
+	if root == nil {
+		t.Fatal("expected top down root not to be nil")
+	}
+	if root.GetFunctionName() != "(root)" {
+		t.Errorf("expected (root), but got %v", root.GetFunctionName())
+	}
+	checkChildren(t, root, []string{"(program)", "start", "(garbage collector)"})
+
+	invalidChild := root.GetChild(4)
+	if invalidChild != nil {
+		t.Errorf("expected nil child, but got %v", invalidChild.GetFunctionName())
+	}
+
+	startNode := root.GetChild(1)
+	if startNode.GetFunctionName() != "start" {
+		t.Errorf("expected start, but got %v", startNode.GetFunctionName())
+	}
+	checkChildren(t, startNode, []string{"foo"})
+	checkPosition(t, startNode, 23, 15)
+
+	parentName := startNode.GetParent().GetFunctionName()
+	if parentName != "(root)" {
+		t.Errorf("expected (root), but got %v", parentName)
+	}
+
+	fooNode := startNode.GetChild(0)
+	checkChildren(t, fooNode, []string{"delay", "bar", "baz"})
+	checkPosition(t, fooNode, 15, 13)
+
+	delayNode := fooNode.GetChild(0)
+	checkChildren(t, delayNode, []string{"loop"})
+	checkPosition(t, delayNode, 12, 15)
+
+	barNode := fooNode.GetChild(1)
+	checkChildren(t, barNode, []string{"delay"})
+
+	bazNode := fooNode.GetChild(2)
+	checkChildren(t, bazNode, []string{"delay"})
+}
+
+func checkChildren(t *testing.T, node *v8go.CPUProfileNode, names []string) {
+	nodeName := node.GetFunctionName()
+	if node.GetChildrenCount() != len(names) {
+		t.Fatalf("expected child count for node %s to equal length of child names", nodeName)
+	}
+	for i, n := range names {
+		if node.GetChild(i).GetFunctionName() != n {
+			t.Errorf("expected %s child %d to have name %s", nodeName, i, n)
+		}
+	}
+}
+
+func checkPosition(t *testing.T, node *v8go.CPUProfileNode, line, column int) {
+	nodeName := node.GetFunctionName()
+	if node.GetLineNumber() != line {
+		t.Errorf("expected node %s at line %d, but got %d", nodeName, line, node.GetLineNumber())
+	}
+	if node.GetColumnNumber() != column {
+		t.Errorf("expected node %s at column %d, but got %d", nodeName, column, node.GetColumnNumber())
+	}
+}

cpuprofiler.go

@@ -0,0 +1,54 @@
+// Copyright 2019 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 (
+	"unsafe"
+)
+
+type CPUProfiler struct {
+	ptr C.CpuProfilerPtr
+	iso *Isolate
+}
+
+// CPUProfiler is used to control CPU profiling.
+func NewCPUProfiler(iso *Isolate) *CPUProfiler {
+	return &CPUProfiler{
+		ptr: C.NewCpuProfiler(iso.ptr),
+		iso: iso,
+	}
+}
+
+// Dispose will dispose the profiler; subsequent calls will panic.
+func (c *CPUProfiler) Dispose() {
+	if c.ptr == nil {
+		return
+	}
+	C.CpuProfilerDispose(c.ptr)
+	c.ptr = 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) {
+	tstr := C.CString(title)
+	defer C.free(unsafe.Pointer(tstr))
+	C.CpuProfilerStartProfiling(c.iso.ptr, c.ptr, 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 {
+	tstr := C.CString(title)
+	defer C.free(unsafe.Pointer(tstr))
+	return &CPUProfile{
+		ptr: C.CpuProfilerStopProfiling(c.iso.ptr, c.ptr, tstr),
+		iso: c.iso,
+	}
+}

cpuprofiler_test.go

@@ -0,0 +1,89 @@
+// Copyright 2019 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_test
+
+import (
+	"testing"
+
+	"rogchap.com/v8go"
+)
+
+func TestCPUProfilerDispose(t *testing.T) {
+	t.Parallel()
+
+	iso, _ := v8go.NewIsolate()
+	defer iso.Dispose()
+	cpuProfiler := v8go.NewCPUProfiler(iso)
+
+	cpuProfiler.Dispose()
+	// noop when called multiple times
+	cpuProfiler.Dispose()
+}
+
+func TestCPUProfiler(t *testing.T) {
+	t.Parallel()
+
+	ctx, _ := v8go.NewContext(nil)
+	iso := ctx.Isolate()
+	defer iso.Dispose()
+	defer ctx.Close()
+
+	cpuProfiler := v8go.NewCPUProfiler(iso)
+	defer cpuProfiler.Dispose()
+
+	cpuProfiler.StartProfiling("cpuprofilertest")
+
+	_, err := ctx.RunScript(profileScript, "script.js")
+	failIf(t, err)
+	val, err := ctx.Global().Get("start")
+	failIf(t, err)
+	fn, err := val.AsFunction()
+	failIf(t, err)
+	_, err = fn.Call()
+	failIf(t, err)
+
+	cpuProfile := cpuProfiler.StopProfiling("cpuprofilertest")
+	if cpuProfile == nil {
+		t.Fatal("expected profiler not to be nil")
+	}
+	root := cpuProfile.GetTopDownRoot()
+	if root == nil {
+		t.Fatal("expected root not to be nil")
+	}
+	if root.GetFunctionName() != "(root)" {
+		t.Errorf("expected (root), but got %v", root.GetFunctionName())
+	}
+}
+
+const profileScript = `function loop(timeout) {
+  this.mmm = 0;
+  var start = Date.now();
+  while (Date.now() - start < timeout) {
+    var n = 100;
+    while(n > 1) {
+      n--;
+      this.mmm += n * n * n;
+    }
+  }
+}
+function delay() { try { loop(10); } catch(e) { } }
+function bar() { delay(); }
+function baz() { delay(); }
+function foo() {
+    try {
+       delay();
+       bar();
+       delay();
+       baz();
+    } catch (e) { }
+}
+function start(timeout) {
+  var start = Date.now();
+  do {
+    foo();
+    var duration = Date.now() - start;
+  } while (duration < timeout);
+  return duration;
+};`