Merge branch 'main' into julien/cache

Author: julienrbrt

.github/workflows/benchmark.yml

@@ -103,7 +103,7 @@ jobs:
   # single job to push all results to gh-pages sequentially, avoiding race conditions
   publish-benchmarks:
     name: Publish Benchmark Results
-    needs: [evm-benchmark, spamoor-benchmark]
+    needs: [evm-benchmark]
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -115,11 +115,6 @@ jobs:
         uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: evm-benchmark-results
-      - name: Download Spamoor benchmark results
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
-        with:
-          name: spamoor-benchmark-results
-          path: test/e2e/benchmark/
 
       # only update the benchmark baseline on push/dispatch, not on PRs
       - name: Store EVM Contract Roundtrip result
@@ -154,22 +149,3 @@ jobs:
           alert-threshold: '150%'
           fail-on-alert: true
           comment-on-alert: true
-
-      # delete local gh-pages so the next benchmark action step fetches fresh from remote
-      - name: Reset local gh-pages branch
-        if: always()
-        run: git branch -D gh-pages || true
-
-      - name: Store Spamoor Trace result
-        if: always()
-        uses: benchmark-action/github-action-benchmark@a7bc2366eda11037936ea57d811a43b3418d3073 # v1.21.0
-        with:
-          name: Spamoor Trace Benchmarks
-          tool: 'customSmallerIsBetter'
-          output-file-path: test/e2e/benchmark/spamoor_bench.json
-          auto-push: ${{ github.event_name != 'pull_request' }}
-          save-data-file: ${{ github.event_name != 'pull_request' }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          alert-threshold: '150%'
-          fail-on-alert: false
-          comment-on-alert: true

CHANGELOG.md

@@ -23,6 +23,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     By using one or the other, you are losing the ability to rollback or replay transactions earlier than `HEAD-n`.
     When using _classic pruning_, you aren't able to fetch blocks prior to `HEAD-n`.
 
+### Fixed
+
+- Fix block timer to account for execution time. Previously, the block timer reset to the full `block_time` duration after `ProduceBlock` completed, making the effective interval `block_time + execution_time`. Now the timer subtracts elapsed execution time so blocks are produced at the configured cadence.
+
 ### Changes
 
 - Store pending blocks separately from executed blocks key. [#3073](https://github.com/evstack/ev-node/pull/3073)

block/internal/executing/executor.go

@@ -415,12 +415,18 @@ func (e *Executor) executionLoop() {
 				continue
 			}
 
+			start := time.Now()
 			if err := e.blockProducer.ProduceBlock(e.ctx); err != nil {
 				e.logger.Error().Err(err).Msg("failed to produce block")
 			}
 			txsAvailable = false
-			// Always reset block timer to keep ticking
-			blockTimer.Reset(e.config.Node.BlockTime.Duration)
+			// reset timer accounting for time spent producing the block
+			elapsed := time.Since(start)
+			remaining := e.config.Node.BlockTime.Duration - elapsed
+			if remaining <= 0 {
+				remaining = 0
+			}
+			blockTimer.Reset(remaining)
 
 		case <-lazyTimerCh:
 			e.logger.Debug().Msg("Lazy timer triggered block production")

block/internal/executing/executor_logic_test.go

@@ -4,12 +4,13 @@ import (
 	"context"
 	crand "crypto/rand"
 	"errors"
+	"sync"
 	"testing"
 	"testing/synctest"
 	"time"
 
 	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/sync"
+	dssync "github.com/ipfs/go-datastore/sync"
 	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
@@ -245,7 +246,7 @@ type executorTestFixture struct {
 func setupTestExecutor(t *testing.T, pendingLimit uint64) executorTestFixture {
 	t.Helper()
 
-	ds := sync.MutexWrap(datastore.NewMapDatastore())
+	ds := dssync.MutexWrap(datastore.NewMapDatastore())
 	memStore := store.New(ds)
 
 	cacheManager, err := cache.NewManager(config.DefaultConfig(), memStore, zerolog.Nop())
@@ -342,3 +343,86 @@ func assertProduceBlockInvariantWithTxs(t *testing.T, txs [][]byte) {
 	err = prevState.AssertValidForNextState(header, data)
 	require.NoError(t, err, "Produced block failed AssertValidForNextState")
 }
+
+// stubBlockProducer records ProduceBlock call times and simulates execution by sleeping.
+type stubBlockProducer struct {
+	mu        sync.Mutex
+	callTimes []time.Time
+	execTime  time.Duration
+}
+
+func (s *stubBlockProducer) ProduceBlock(ctx context.Context) error {
+	s.mu.Lock()
+	s.callTimes = append(s.callTimes, time.Now())
+	s.mu.Unlock()
+	timer := time.NewTimer(s.execTime)
+	defer timer.Stop()
+	select {
+	case <-timer.C:
+	case <-ctx.Done():
+	}
+	return nil
+}
+
+func (s *stubBlockProducer) RetrieveBatch(context.Context) (*BatchData, error) {
+	panic("unexpected call")
+}
+
+func (s *stubBlockProducer) CreateBlock(context.Context, uint64, *BatchData) (*types.SignedHeader, *types.Data, error) {
+	panic("unexpected call")
+}
+
+func (s *stubBlockProducer) ApplyBlock(context.Context, types.Header, *types.Data) (types.State, error) {
+	panic("unexpected call")
+}
+
+func (s *stubBlockProducer) getCalls() []time.Time {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	out := make([]time.Time, len(s.callTimes))
+	copy(out, s.callTimes)
+	return out
+}
+
+// TestExecutionLoop_BlockInterval verifies that the block timer accounts for
+// execution time so that the interval between block starts equals blockTime,
+// not blockTime + executionTime.
+func TestExecutionLoop_BlockInterval(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		const (
+			blockTime     = 100 * time.Millisecond
+			executionTime = 50 * time.Millisecond
+			wantBlocks    = 5
+		)
+
+		fx := setupTestExecutor(t, 1000)
+		defer fx.Cancel()
+
+		fx.Exec.config.Node.BlockTime = config.DurationWrapper{Duration: blockTime}
+
+		stub := &stubBlockProducer{execTime: executionTime}
+		fx.Exec.SetBlockProducer(stub)
+
+		done := make(chan struct{})
+		go func() {
+			fx.Exec.executionLoop()
+			close(done)
+		}()
+
+		// advance fake time enough for wantBlocks blocks
+		time.Sleep(blockTime + time.Duration(wantBlocks)*blockTime)
+
+		fx.Cancel()
+		<-done
+
+		calls := stub.getCalls()
+		require.GreaterOrEqual(t, len(calls), wantBlocks,
+			"expected at least %d blocks, got %d", wantBlocks, len(calls))
+
+		for i := 1; i < len(calls); i++ {
+			interval := calls[i].Sub(calls[i-1])
+			assert.Equal(t, blockTime, interval,
+				"block %d: interval between block starts should equal blockTime", i)
+		}
+	})
+}