Simple benchmarking tool

Author: setavenger

Makefile

@@ -0,0 +1,26 @@
+# Benchmark targets
+.PHONY: benchmark
+benchmark: build-benchmark
+	@echo "Running benchmark..."
+	./bin/benchmark $(ARGS)
+
+.PHONY: benchmark-v1
+benchmark-v1: build-benchmark
+	@echo "Running v1 HTTP benchmark only..."
+	./bin/benchmark -v1 -v2=false $(ARGS)
+
+.PHONY: benchmark-v2
+benchmark-v2: build-benchmark
+	@echo "Running v2 gRPC benchmark only..."
+	./bin/benchmark -v1=false -v2 $(ARGS)
+
+.PHONY: build-benchmark
+build-benchmark:
+	@echo "Building benchmark tool..."
+	@mkdir -p bin
+	go build -o bin/benchmark ./cmd/benchmark
+
+# Example usage:
+# make benchmark ARGS="-startheight=100 -endheight=200"
+# make benchmark-v1 ARGS="-startheight=100 -endheight=200"
+# make benchmark-v2 ARGS="-startheight=100 -endheight=200"

cmd/benchmark/README.md

@@ -0,0 +1,62 @@
+# Oracle Benchmark Tool
+
+This tool benchmarks the performance difference between v1 (HTTP) and v2 (gRPC streaming) APIs for fetching block data.
+
+## Building
+
+```bash
+make build-benchmark
+```
+
+## Usage
+
+### Run both benchmarks
+```bash
+./bin/benchmark -startheight=100 -endheight=200
+```
+
+### Run only v1 HTTP benchmark
+```bash
+./bin/benchmark -v1 -v2=false -startheight=100 -endheight=200
+```
+
+### Run only v2 gRPC benchmark
+```bash
+./bin/benchmark -v1=false -v2 -startheight=100 -endheight=200
+```
+
+### Using Makefile
+```bash
+# Run both
+make benchmark ARGS="-startheight=100 -endheight=200"
+
+# Run only v1
+make benchmark-v1 ARGS="-startheight=100 -endheight=200"
+
+# Run only v2
+make benchmark-v2 ARGS="-startheight=100 -endheight=200"
+```
+
+## Command Line Flags
+
+- `-startheight`: Start block height (default: 1)
+- `-endheight`: End block height (default: 10)
+- `-http`: HTTP API base URL (default: "http://127.0.0.1:8000")
+- `-grpc`: gRPC server host:port (default: "127.0.0.1:50051")
+- `-v1`: Run v1 HTTP benchmark (default: true)
+- `-v2`: Run v2 gRPC benchmark (default: true)
+
+## What it measures
+
+The benchmark fetches block data (tweaks, filters) for each block height in the range and measures:
+
+- Total time to fetch all blocks
+- Blocks processed per second
+- Individual block fetch times
+
+## Expected Results
+
+- **v1 (HTTP)**: Makes individual HTTP requests for each block, good for small ranges
+- **v2 (gRPC)**: Uses streaming to fetch all blocks in one connection, better for large ranges
+
+The gRPC streaming approach should show better performance for larger block ranges due to reduced connection overhead and better batching.

cmd/benchmark/main.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"flag"
+
+	"github.com/rs/zerolog"
+	"github.com/setavenger/blindbit-lib/logging"
+	"github.com/setavenger/blindbit-oracle/internal/benchmark"
+)
+
+func main() {
+	var (
+		startHeight = flag.Uint64("startheight", 1, "Start block height")
+		endHeight   = flag.Uint64("endheight", 10, "End block height")
+		httpURL     = flag.String("http", "http://127.0.0.1:8000", "HTTP API base URL")
+		grpcHost    = flag.String("grpc", "127.0.0.1:50051", "gRPC server host:port")
+		runV1       = flag.Bool("v1", true, "Run v1 HTTP benchmark")
+		runV2       = flag.Bool("v2", true, "Run v2 gRPC benchmark")
+	)
+	flag.Parse()
+
+	// Setup logging
+	logging.SetLogLevel(zerolog.InfoLevel)
+
+	logging.L.Info().
+		Uint64("start_height", *startHeight).
+		Uint64("end_height", *endHeight).
+		Msg("Starting benchmark")
+
+	if *runV1 {
+		logging.L.Info().Msg("=== Running V1 HTTP Benchmark ===")
+		benchmark.BenchmarkV1(*startHeight, *endHeight, *httpURL)
+	}
+
+	if *runV2 {
+		logging.L.Info().Msg("=== Running V2 gRPC Streaming Benchmark ===")
+		benchmark.BenchmarkV2(*startHeight, *endHeight, *grpcHost)
+	}
+
+	logging.L.Info().Msg("Benchmark completed")
+}

internal/benchmark/benchmark_v1.go

@@ -0,0 +1,110 @@
+package benchmark
+
+import (
+	"sync"
+	"time"
+
+	"github.com/setavenger/blindbit-lib/logging"
+	"github.com/setavenger/blindbit-lib/networking"
+)
+
+// BenchmarkV1 runs the v1 HTTP API benchmark using the existing ClientBlindBit
+func BenchmarkV1(startHeight, endHeight uint64, baseURL string) {
+	logging.L.Info().Msgf("Starting v1 HTTP benchmark from height %d to %d", startHeight, endHeight)
+
+	// Create client using existing networking code
+	client := &networking.ClientBlindBit{BaseURL: baseURL}
+
+	startTime := time.Now()
+
+	// Fetch data for each height
+	for height := startHeight; height <= endHeight; height++ {
+		blockData, err := fetchBlockDataV1(height, client)
+		if err != nil {
+			logging.L.Err(err).Uint64("height", height).Msg("failed to fetch block data")
+			continue
+		}
+
+		logging.L.Debug().Uint64("height", height).Msg("fetched block data")
+		_ = blockData // Use blockData to avoid compiler warning
+	}
+
+	duration := time.Since(startTime)
+	blocksProcessed := endHeight - startHeight + 1
+
+	logging.L.Info().
+		Uint64("start_height", startHeight).
+		Uint64("end_height", endHeight).
+		Uint64("blocks_processed", blocksProcessed).
+		Dur("total_duration", duration).
+		Float64("blocks_per_second", float64(blocksProcessed)/duration.Seconds()).
+		Msg("v1 HTTP benchmark completed")
+}
+
+// fetchBlockDataV1 fetches block data for a single height using existing ClientBlindBit
+func fetchBlockDataV1(height uint64, client *networking.ClientBlindBit) (*BlockDataV1, error) {
+	var wg sync.WaitGroup
+	wg.Add(3)
+
+	errChan := make(chan error, 3)
+
+	var filterNew, filterSpent *networking.Filter
+	var tweaks [][33]byte
+
+	// Fetch new UTXOs filter
+	go func() {
+		defer wg.Done()
+		var err error
+		filterNew, err = client.GetFilter(height, networking.NewUTXOFilterType)
+		if err != nil {
+			logging.L.Err(err).Msg("failed to get new utxos filter")
+			errChan <- err
+		}
+	}()
+
+	// Fetch spent outpoints filter
+	go func() {
+		defer wg.Done()
+		var err error
+		filterSpent, err = client.GetFilter(height, networking.SpentOutpointsFilterType)
+		if err != nil {
+			logging.L.Err(err).Msg("failed to get spent outpoints filter")
+			errChan <- err
+		}
+	}()
+
+	// Fetch tweaks
+	go func() {
+		defer wg.Done()
+		var err error
+		tweaks, err = client.GetTweaks(height, 0) // 0 = no dust limit
+		if err != nil {
+			logging.L.Err(err).Msg("failed to pull tweaks")
+			errChan <- err
+		}
+	}()
+
+	wg.Wait()
+
+	select {
+	case err := <-errChan:
+		return nil, err
+	default:
+		// No errors
+	}
+
+	return &BlockDataV1{
+		Height:      height,
+		FilterNew:   filterNew,
+		FilterSpent: filterSpent,
+		Tweaks:      tweaks,
+	}, nil
+}
+
+// BlockDataV1 represents the block data structure for v1
+type BlockDataV1 struct {
+	Height      uint64
+	FilterNew   *networking.Filter
+	FilterSpent *networking.Filter
+	Tweaks      [][33]byte
+}

internal/benchmark/benchmark_v2.go

@@ -0,0 +1,72 @@
+package benchmark
+
+import (
+	"context"
+	"time"
+
+	"github.com/setavenger/blindbit-lib/logging"
+	"github.com/setavenger/blindbit-lib/proto/pb"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+// BenchmarkV2 runs the v2 gRPC streaming benchmark
+func BenchmarkV2(startHeight, endHeight uint64, grpcHost string) {
+	logging.L.Info().Msgf("Starting v2 gRPC streaming benchmark from height %d to %d", startHeight, endHeight)
+
+	// Connect to gRPC server
+	conn, err := grpc.Dial(grpcHost, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	if err != nil {
+		logging.L.Err(err).Msg("failed to connect to gRPC server")
+		return
+	}
+	defer conn.Close()
+
+	client := pb.NewOracleServiceClient(conn)
+
+	startTime := time.Now()
+
+	// Use streaming API to fetch all blocks at once
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+
+	req := &pb.RangedBlockHeightRequest{
+		Start: startHeight,
+		End:   endHeight,
+	}
+
+	stream, err := client.StreamBlockBatchSlim(ctx, req)
+	if err != nil {
+		logging.L.Err(err).Msg("failed to start streaming")
+		return
+	}
+
+	blocksProcessed := uint64(0)
+
+	for {
+		batch, err := stream.Recv()
+		if err != nil {
+			if err.Error() == "EOF" {
+				break
+			}
+			logging.L.Err(err).Msg("failed to receive batch")
+			break
+		}
+
+		blocksProcessed++
+		logging.L.Debug().Uint64("height", uint64(batch.BlockIdentifier.BlockHeight)).Msg("received block batch")
+
+		// Use batch to avoid compiler warning
+		_ = batch
+	}
+
+	duration := time.Since(startTime)
+
+	logging.L.Info().
+		Uint64("start_height", startHeight).
+		Uint64("end_height", endHeight).
+		Uint64("blocks_processed", blocksProcessed).
+		Dur("total_duration", duration).
+		Float64("blocks_per_second", float64(blocksProcessed)/duration.Seconds()).
+		Msg("v2 gRPC streaming benchmark completed")
+}