WIP Ops and Storage Benchmarks

benchmarking/cmd/main.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"encoding/binary"
+	"flag"
+	"fmt"
+	"os"
+	"sync"
+
+	"github.com/gnolang/gno/benchmarking"
+	"github.com/gnolang/gno/gnovm/pkg/gnolang"
+)
+
+const recordSize int = 10
+
+var pathFlag = flag.String("path", "", "the path to the benchmark file")
+
+func main() {
+	flag.Parse()
+
+	file, err := os.Open(*pathFlag)
+	if err != nil {
+		panic("could not create benchmark file: " + err.Error())
+	}
+	defer file.Close()
+
+	inputCh := make(chan []byte, 10000)
+	outputCh := make(chan string, 10000)
+	wg := sync.WaitGroup{}
+	numWorkers := 1
+	wg.Add(numWorkers)
+
+	doneCh := make(chan struct{})
+
+	for i := 0; i < numWorkers; i++ {
+		go func() {
+			for {
+				record, ok := <-inputCh
+				if !ok {
+					break
+				}
+
+				opName := gnolang.Op(record[0]).String()
+				if record[1] != 0 {
+					opName = benchmarking.StoreCodeString(record[1])
+				}
+
+				elapsedTime := binary.LittleEndian.Uint32(record[2:])
+				size := binary.LittleEndian.Uint32(record[6:])
+				outputCh <- opName + "," + fmt.Sprint(elapsedTime) + "," + fmt.Sprint(size)
+			}
+			wg.Done()
+		}()
+	}
+
+	go func() {
+		out, err := os.Create("results.csv")
+		if err != nil {
+			panic("could not create readable output file: " + err.Error())
+		}
+		defer out.Close()
+		fmt.Fprintln(out, "op,elapsedTime,diskIOBytes")
+
+		for {
+			output, ok := <-outputCh
+			if !ok {
+				break
+			}
+
+			fmt.Fprintln(out, output)
+		}
+
+		out.Close()
+		doneCh <- struct{}{}
+	}()
+
+	var i int
+
+	bufSize := recordSize * 100000
+	buf := make([]byte, bufSize)
+
+	for {
+		nbytes, err := file.Read(buf)
+
+		if err != nil && nbytes == 0 {
+			break
+		}
+		n := nbytes / recordSize
+
+		for j := 0; j < n; j++ {
+			inputCh <- buf[j*recordSize : (j+1)*recordSize]
+		}
+
+		i += bufSize / recordSize
+		if i%1000 == 0 {
+			fmt.Println(i)
+		}
+	}
+
+	close(inputCh)
+	wg.Wait()
+	close(outputCh)
+	<-doneCh
+	close(doneCh)
+
+	fmt.Println("done")
+}

benchmarking/exporter.go

@@ -0,0 +1,46 @@
+package benchmarking
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"time"
+)
+
+var fileWriter *exporter
+
+func initExporter(fileName string) {
+	file, err := os.Create(fileName)
+	if err != nil {
+		panic("could not create benchmark file: " + err.Error())
+	}
+
+	fileWriter = &exporter{
+		file: file,
+	}
+}
+
+type exporter struct {
+	file *os.File
+}
+
+func (e *exporter) export(code Code, elapsedTime time.Duration, size uint32) {
+	buf := []byte{code[0], code[1], 0, 0, 0, 0, 0, 0, 0, 0}
+	binary.LittleEndian.PutUint32(buf[2:], uint32(elapsedTime))
+	binary.LittleEndian.PutUint32(buf[6:], size)
+	_, err := e.file.Write(buf)
+	if err != nil {
+		panic("could not write to benchmark file: " + err.Error())
+	}
+}
+
+func (e *exporter) close() {
+	e.file.Sync()
+	e.file.Close()
+}
+
+func Finish() {
+	fmt.Println("## StackSize: ", stackSize)
+
+	fileWriter.close()
+}

benchmarking/init.go

@@ -0,0 +1,6 @@
+package benchmarking
+
+func Init(filepath string) {
+	initExporter(filepath)
+	initStack()
+}

benchmarking/measurement.go

@@ -0,0 +1,37 @@
+package benchmarking
+
+import (
+	"time"
+)
+
+type measurement struct {
+	*timer
+	code       Code
+	allocation uint32
+}
+
+func startNewMeasurement(code Code) *measurement {
+	return &measurement{
+		timer: &timer{startTime: time.Now()},
+		code:  code,
+	}
+}
+
+func (m *measurement) pause() {
+	m.stop()
+}
+
+func (m *measurement) resume() {
+	m.start()
+}
+
+func (m *measurement) end(size uint32) {
+	m.stop()
+	if size != 0 && m.allocation != 0 {
+		panic("measurement cannot have both allocation and size")
+	} else if size == 0 {
+		size = m.allocation
+	}
+
+	fileWriter.export(m.code, m.elapsedTime, size)
+}

benchmarking/ops.go

@@ -0,0 +1,62 @@
+package benchmarking
+
+// store code
+const (
+	StoreGetObject     byte = 0x01 // get value and unmarshl to object from store
+	StoreSetObject     byte = 0x02 // marshal object and set value in store
+	StoreDeleteObject  byte = 0x03 // delete value from store
+	StoreGetPackage    byte = 0x04 // get package from store
+	StoreSetPackage    byte = 0x05 // get package from store
+	StoreGetType       byte = 0x06 // get type from store
+	StoreSetType       byte = 0x07 // set type in store
+	StoreGetBlockNode  byte = 0x08 // get block node from store
+	StoreSetBlockNode  byte = 0x09 // set block node in store
+	StoreAddMemPackage byte = 0x0A // add mempackage to store
+	StoreGetMemPackage byte = 0x0B // get mempackage from store
+	FinalizeTx         byte = 0x0C // finalize realm transaction
+
+	AminoMarshal   byte = 0x0D // marshal go object to binary value
+	AminoUnMarshal byte = 0x0E // unmarshl binary value to go object
+
+	StoreGet byte = 0x0F // Get binary value by key
+	StoreSet byte = 0x10 // Set binary value by key
+
+	invalidStoreCode string = "StoreInvalid"
+)
+
+var storeCodeNames = []string{
+	invalidStoreCode,
+	"StoreGetObject",
+	"StoreSetObject",
+	"StoreDeleteObject",
+	"StoreGetPackage",
+	"StoreSetPackage",
+	"StoreGetType",
+	"StoreSetType",
+	"StoreGetBlockNode",
+	"StoreSetBlockNode",
+	"StoreAddMemPackage",
+	"StoreGetMemPackage",
+	"FinalizeTx",
+	"AminoMarshal",
+	"AminoUnMarshal",
+	"StoreGet",
+	"StoreSet",
+}
+
+type Code [2]byte
+
+func VMOpCode(opCode byte) Code {
+	return [2]byte{opCode, 0x00}
+}
+
+func StoreCode(storeCode byte) Code {
+	return [2]byte{0x00, storeCode}
+}
+
+func StoreCodeString(storeCode byte) string {
+	if int(storeCode) >= len(storeCodeNames) {
+		return invalidStoreCode
+	}
+	return storeCodeNames[storeCode]
+}

benchmarking/ops_disabled.go

@@ -0,0 +1,5 @@
+//go:build !benchmarkingops
+
+package benchmarking
+
+const OpsEnabled = false

benchmarking/ops_enabled.go

@@ -0,0 +1,5 @@
+//go:build benchmarkingops
+
+package benchmarking
+
+const OpsEnabled = true

benchmarking/stack.go

@@ -0,0 +1,66 @@
+package benchmarking
+
+const initStackSize int = 64
+
+var (
+	measurementStack []*measurement
+	stackSize        int
+)
+
+func initStack() {
+	measurementStack = make([]*measurement, initStackSize)
+}
+
+func StartMeasurement(code Code) {
+	if stackSize != 0 {
+		measurementStack[stackSize-1].pause()
+	}
+
+	if stackSize == len(measurementStack) {
+		newStack := make([]*measurement, stackSize*2)
+		copy(newStack, measurementStack)
+		measurementStack = newStack
+	}
+
+	measurementStack[stackSize] = startNewMeasurement(code)
+	stackSize++
+}
+
+// Pause pauses current measurement on the stack
+func Pause() {
+	if stackSize != 0 {
+		measurementStack[stackSize-1].pause()
+	}
+}
+
+// Resume resumes current measurement on the stack
+func Resume() {
+	if stackSize != 0 {
+		measurementStack[stackSize-1].resume()
+	}
+}
+
+// StopMeasurement ends the current measurement and resumes the previous one
+// if one exists. It accepts the number of bytes that were read/written to/from
+// the store. This value is zero if the operation is not a read or write.
+func StopMeasurement(size uint32) {
+	if stackSize == 0 {
+		return
+	}
+
+	measurementStack[stackSize-1].end(size)
+
+	stackSize--
+
+	if stackSize != 0 {
+		measurementStack[stackSize-1].resume()
+	}
+}
+
+func RecordAllocation(size uint32) {
+	if stackSize == 0 {
+		return
+	}
+
+	measurementStack[stackSize-1].allocation += size
+}

benchmarking/storage_disabled.go

@@ -0,0 +1,5 @@
+//go:build !benchmarkingstorage
+
+package benchmarking
+
+const StorageEnabled = false

benchmarking/storage_enabled.go

@@ -0,0 +1,5 @@
+//go:build benchmarkingstorage
+
+package benchmarking
+
+const StorageEnabled = true

benchmarking/timer.go

@@ -0,0 +1,22 @@
+package benchmarking
+
+import "time"
+
+type timer struct {
+	startTime   time.Time
+	elapsedTime time.Duration
+	isStopped   bool
+}
+
+func (t *timer) start() {
+	t.startTime = time.Now()
+}
+
+func (t *timer) stop() {
+	if t.isStopped {
+		return
+	}
+
+	t.elapsedTime += time.Since(t.startTime)
+	t.isStopped = true
+}

gno.land/cmd/gnoland/start.go

@@ -9,6 +9,7 @@
 	"strings"
 	"time"
 
+	bm "github.com/gnolang/gno/benchmarking"
 	"github.com/gnolang/gno/gno.land/pkg/gnoland"
 	"github.com/gnolang/gno/gno.land/pkg/log"
 	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
@@ -201,6 +202,10 @@
 }
 
 func execStart(c *startCfg, io commands.IO) error {
+	if bm.OpsEnabled || bm.StorageEnabled {
+		bm.Init("benchmarks.bin")
+	}
+
 	// Get the absolute path to the node's data directory
 	nodeDir, err := filepath.Abs(c.dataDir)
 	if err != nil {