feat: gnovm benchmarking tool

examples/gno.land/r/x/benchmark/storage/boards.gno

@@ -0,0 +1,97 @@
+package storage
+
+import (
+	"strconv"
+
+	"gno.land/p/demo/avl"
+)
+
+var boards avl.Tree
+
+type Board interface {
+	AddPost(title, content string)
+	GetPost(id int) (Post, bool)
+	Size() int
+}
+
+// posts are persisted in an avl tree
+type TreeBoard struct {
+	id    int
+	posts *avl.Tree
+}
+
+func (b *TreeBoard) AddPost(title, content string) {
+	n := b.posts.Size()
+	p := Post{n, title, content}
+	b.posts.Set(strconv.Itoa(n), p)
+}
+
+func (b *TreeBoard) GetPost(id int) (Post, bool) {
+	p, ok := b.posts.Get(strconv.Itoa(id))
+	if ok {
+		return p.(Post), ok
+	} else {
+		return Post{}, ok
+	}
+}
+
+func (b *TreeBoard) Size() int {
+	return b.posts.Size()
+}
+
+// posts are persisted in a map
+type MapBoard struct {
+	id    int
+	posts map[int]Post
+}
+
+func (b *MapBoard) AddPost(title, content string) {
+	n := len(b.posts)
+	p := Post{n, title, content}
+	b.posts[n] = p
+}
+
+func (b *MapBoard) GetPost(id int) (Post, bool) {
+	p, ok := b.posts[id]
+	if ok {
+		return p, ok
+	} else {
+		return Post{}, ok
+	}
+}
+
+func (b *MapBoard) Size() int {
+	return len(b.posts)
+}
+
+// posts are persisted in a slice
+type SliceBoard struct {
+	id    int
+	posts []Post
+}
+
+func (b *SliceBoard) AddPost(title, content string) {
+	n := len(b.posts)
+	p := Post{n, title, content}
+	b.posts = append(b.posts, p)
+}
+
+func (b *SliceBoard) GetPost(id int) (Post, bool) {
+	if id < len(b.posts) {
+		p := b.posts[id]
+
+		return p, true
+	} else {
+		return Post{}, false
+	}
+}
+
+func (b *SliceBoard) Size() int {
+	return len(b.posts)
+}
+
+type Post struct {
+	id      int
+	title   string
+	content string
+}

examples/gno.land/r/x/benchmark/storage/forum.gno

@@ -0,0 +1,64 @@
+package storage
+
+import (
+	"strconv"
+
+	"gno.land/p/demo/avl"
+)
+
+func init() {
+	// we write to three common data structure for persistence
+	// avl.Tree, map and slice.
+	posts0 := avl.NewTree()
+	b0 := &TreeBoard{0, posts0}
+	boards.Set(strconv.Itoa(0), b0)
+
+	posts1 := make(map[int]Post)
+	b1 := &MapBoard{1, posts1}
+	boards.Set(strconv.Itoa(1), b1)
+
+	posts2 := []Post{}
+	b2 := &SliceBoard{2, posts2}
+	boards.Set(strconv.Itoa(2), b2)
+}
+
+// post to all boards.
+func AddPost(title, content string) {
+	for i := 0; i < boards.Size(); i++ {
+		boardId := strconv.Itoa(i)
+		b, ok := boards.Get(boardId)
+		if ok {
+			b.(Board).AddPost(title, content)
+		}
+	}
+}
+
+func GetPost(boardId, postId int) string {
+	b, ok := boards.Get(strconv.Itoa(boardId))
+	var res string
+
+	if ok {
+		p, ok := b.(Board).GetPost(postId)
+		if ok {
+			res = p.title + "," + p.content
+		}
+	}
+	return res
+}
+
+func GetPostSize(boardId int) int {
+	b, ok := boards.Get(strconv.Itoa(boardId))
+	var res int
+
+	if ok {
+		res = b.(Board).Size()
+	} else {
+		res = -1
+	}
+
+	return res
+}
+
+func GetBoardSize() int {
+	return boards.Size()
+}

examples/gno.land/r/x/benchmark/storage/gno.mod

@@ -0,0 +1,3 @@
+module gno.land/r/x/benchmark/storage
+
+require gno.land/p/demo/avl v0.0.0-latest

gnovm/pkg/benchops/Makefile

@@ -0,0 +1,28 @@
+.PHONY: opcode storage build_opcode build_storage
+
+# Build target
+build_opcode:
+	go build -tags "benchmarkingops" -o build/gnobench ./cmd
+
+# Build target
+build_storage:
+	go build -tags "benchmarkingstorage" -o build/gnobench ./cmd
+
+
+# Run target
+opcode: build_opcode
+	./build/gnobench
+
+# Run target
+storage: build_storage
+	./build/gnobench
+
+# command to run dependency utilities, like goimports.
+rundep=go run -modfile ../misc/devdeps/go.mod
+
+# flags for `make fmt`. -w will write the result to the destination files.
+GOFMT_FLAGS ?= -w
+
+.PHONY: fmt
+fmt:
+	$(rundep) mvdan.cc/gofumpt $(GOFMT_FLAGS) .

gnovm/pkg/benchops/README.md

@@ -0,0 +1,90 @@
+# `gnobench`  the time consumed for GnoVM OpCode execution and store access
+
+`gnobench` benchmarks the time consumed for each VM CPU OpCode and persistent access to the store, including marshalling and unmarshalling of realm objects.
+
+## Usage
+
+### Simple mode
+
+The benchmark only involves the GnoVM and the persistent store. It benchmarks the bare minimum components, and the results are isolated from other components. We use standardize gno contract to perform the benchmarking.
+
+This mode is the best for benchmarking each major release and/or changes in GnoVM.
+
+    make opcode
+    make storage
+
+### Production mode
+
+It benchmarks the node in the production environment with minimum overhead.
+We can not only benchmark with standardize the contract but also capture the live usage in production environment.
+It gives us a complete picture of the node perform.
+
+
+  1. Build the production node with benchmarking flags:
+
+  `go build -tags "benchmarkingstorage benchmarkingops" gno.land/cmd/gnoland`
+
+  2. Run the node in the production environment. It will dump benchmark data to a benchmarks.bin file.
+
+  3. call the realm contracts at `gno.land/r/x/benchmark/opcodes` and `gno.land/r/x/benchmark/storage`
+
+  4. Stop the server after the benchmarking session is complete.
+
+  5. Run the following command to convert the binary dump:
+
+  `gnobench -bin path_to_benchmarks.bin`
+
+    it converts the binary dump to results.csv and results_stats.csv.
+
+
+## Results
+
+The benchmarking results are stored in two files:
+  1. The raw results are saved in results.csv.
+
+  | Operation       | Elapsed Time | Disk IO Bytes |
+  |-----------------|--------------|---------------|
+  | OpEval          | 40333        | 0             |
+  | OpPopBlock      | 208          | 0             |
+  | OpHalt          | 167          | 0             |
+  | OpEval          | 500          | 0             |
+  | OpInterfaceType | 458          | 0             |
+  | OpPopBlock      | 166          | 0             |
+  | OpHalt          | 125          | 0             |
+  | OpInterfaceType | 21125        | 0             |
+  | OpEval          | 541          | 0             |
+  | OpEval          | 209          | 0             |
+  | OpInterfaceType | 334          | 0             |
+
+
+
+  2. The averages and standard deviations are summarized in results_stats.csv.
+
+  | Operation      | Avg Time | Avg Size | Time Std Dev | Count |
+|----------------|----------|----------|--------------|-------|
+| OpAdd          | 101      | 0        | 45           | 300   |
+| OpAddAssign    | 309      | 0        | 1620         | 100   |
+| OpArrayLit     | 242      | 0        | 170          | 700   |
+| OpArrayType    | 144      | 0        | 100          | 714   |
+| OpAssign       | 136      | 0        | 95           | 2900  |
+| OpBand         | 92       | 0        | 30           | 100   |
+| OpBandAssign   | 127      | 0        | 62           | 100   |
+| OpBandn        | 97       | 0        | 54           | 100   |
+| OpBandnAssign  | 125      | 0        | 113          | 100   |
+| OpBinary1      | 128      | 0        | 767          | 502   |
+| OpBody         | 127      | 0        | 145          | 13700 |
+
+## Design consideration
+
+### Minimum Overhead and Footprint
+
+- Constant build flags enable benchmarking.
+- Encode operations and measurements in binary.
+- Dump to a local file in binary.
+- No logging, printout, or network access involved.
+
+### Accurate
+
+- Pause the timer for storage access while performing VM opcode benchmarking.
+- Measure each OpCode execution in nanoseconds.
+- Store access includes the duration for Amino marshalling and unmarshalling.