2-/4 No compression bench

clients/feeder/feeder.go

@@ -11,10 +11,10 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-	"testing"
 	"time"
 
 	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/db/pebble"
 	"github.com/NethermindEth/juno/starknet"
 	"github.com/NethermindEth/juno/utils"
 	"github.com/stretchr/testify/assert"
@@ -92,9 +92,9 @@ func NopBackoff(d time.Duration) time.Duration {
 }
 
 // NewTestClient returns a client and a function to close a test server.
-func NewTestClient(t *testing.T, network *utils.Network) *Client {
-	srv := newTestServer(t, network)
-	t.Cleanup(srv.Close)
+func NewTestClient(tb pebble.TestBench, network *utils.Network) *Client {
+	srv := newTestServer(tb, network)
+	tb.Cleanup(srv.Close)
 	ua := "Juno/v0.0.1-test Starknet Implementation"
 	apiKey := "API_KEY"
 
@@ -117,19 +117,19 @@ func NewTestClient(t *testing.T, network *utils.Network) *Client {
 	return c
 }
 
-func newTestServer(t *testing.T, network *utils.Network) *httptest.Server {
+func newTestServer(tb pebble.TestBench, network *utils.Network) *httptest.Server {
 	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		queryMap, err := url.ParseQuery(r.URL.RawQuery)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
 
-		assert.Equal(t, []string{"API_KEY"}, r.Header["X-Throttling-Bypass"])
-		assert.Equal(t, []string{"Juno/v0.0.1-test Starknet Implementation"}, r.Header["User-Agent"])
+		assert.Equal(tb, []string{"API_KEY"}, r.Header["X-Throttling-Bypass"])
+		assert.Equal(tb, []string{"Juno/v0.0.1-test Starknet Implementation"}, r.Header["User-Agent"])
 
 		wd, err := os.Getwd()
-		require.NoError(t, err)
+		require.NoError(tb, err)
 
 		base := wd[:strings.LastIndex(wd, "juno")+4]
 		queryArg := ""

db/pebble/db.go

@@ -2,7 +2,6 @@
 
 import (
 	"sync"
-	"testing"
 
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/utils"
@@ -31,6 +30,7 @@
 		Logger:       logger,
 		Cache:        pebble.NewCache(int64(cache * utils.Megabyte)),
 		MaxOpenFiles: maxOpenFiles,
+		Levels:       []pebble.LevelOptions{{Compression: pebble.NoCompression}},
 	})
 	if err != nil {
 		return nil, err
@@ -41,19 +41,27 @@
 // NewMem opens a new in-memory database
 func NewMem() (db.DB, error) {
 	return newPebble("", &pebble.Options{
-		FS: vfs.NewMem(),
+		FS:     vfs.NewMem(),
+		Levels: []pebble.LevelOptions{{Compression: pebble.NoCompression}},
 	})
 }
 
+type TestBench interface {
+	Fatalf(format string, args ...interface{})
+	Errorf(format string, args ...interface{})
+	Cleanup(func())
+	FailNow()
+}
+
 // NewMemTest opens a new in-memory database, panics on error
-func NewMemTest(t *testing.T) db.DB {
+func NewMemTest(tb TestBench) db.DB {
 	memDB, err := NewMem()
 	if err != nil {
-		t.Fatalf("create in-memory db: %v", err)
+		tb.Fatalf("create in-memory db: %v", err)
 	}
-	t.Cleanup(func() {
+	tb.Cleanup(func() {
 		if err := memDB.Close(); err != nil {
-			t.Errorf("close in-memory db: %v", err)
+			tb.Errorf("close in-memory db: %v", err)
 		}
 	})
 	return memDB

sync/sync_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/db/pebble"
 	"github.com/NethermindEth/juno/mocks"
+	"github.com/NethermindEth/juno/rpc"
 	adaptfeeder "github.com/NethermindEth/juno/starknetdata/feeder"
 	"github.com/NethermindEth/juno/sync"
 	"github.com/NethermindEth/juno/utils"
@@ -225,3 +226,68 @@ func TestSubscribeNewHeads(t *testing.T) {
 	require.Equal(t, want.Header, got)
 	sub.Unsubscribe()
 }
+
+func BenchmarkSync(b *testing.B) {
+	mockCtrl := gomock.NewController(b)
+	defer mockCtrl.Finish()
+
+	client := feeder.NewTestClient(b, &utils.Mainnet)
+	gw := adaptfeeder.New(client)
+	log := utils.NewNopZapLogger()
+
+	testDB := pebble.NewMemTest(b)
+	bc := blockchain.New(testDB, &utils.Sepolia)
+	b0, err := gw.BlockByNumber(context.Background(), 0)
+	require.NoError(b, err)
+	s0, err := gw.StateUpdate(context.Background(), 0)
+	require.NoError(b, err)
+	require.NoError(b, bc.Store(b0, &core.BlockCommitments{}, s0, nil))
+
+	synchronizer := sync.New(bc, gw, log, time.Duration(0), false)
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for i := 0; i < b.N; i++ {
+		ctx, cancel := context.WithTimeout(context.Background(), timeout)
+		err := synchronizer.Run(ctx)
+		if err != nil {
+			b.Error("failed to synchronise: ", err)
+		}
+		cancel()
+	}
+}
+
+func BenchmarkRPC(b *testing.B) {
+	mockCtrl := gomock.NewController(b)
+	defer mockCtrl.Finish()
+
+	client := feeder.NewTestClient(b, &utils.Mainnet)
+	gw := adaptfeeder.New(client)
+	log := utils.NewNopZapLogger()
+
+	testDB := pebble.NewMemTest(b)
+	bc := blockchain.New(testDB, &utils.Sepolia)
+	b0, err := gw.BlockByNumber(context.Background(), 0)
+	require.NoError(b, err)
+	s0, err := gw.StateUpdate(context.Background(), 0)
+	require.NoError(b, err)
+	require.NoError(b, bc.Store(b0, &core.BlockCommitments{}, s0, nil))
+
+	synchronizer := sync.New(bc, gw, log, time.Duration(0), false)
+	handler := rpc.New(bc, synchronizer, nil, "", &utils.Mainnet, nil)
+
+	ctxSync, cancelSync := context.WithTimeout(context.Background(), timeout)
+	require.NoError(b, synchronizer.Run(ctxSync))
+	cancelSync()
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for i := 0; i < b.N; i++ {
+		_, err := handler.BlockTransactionCount(rpc.BlockID{Latest: true})
+		if err != nil {
+			b.Error("RPC call failed: ", err)
+		}
+	}
+}