add transition + benchmarks

Author: gballet

core/bench_eip8032_test.go

@@ -0,0 +1,273 @@
+// Copyright 2024 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/consensus/beacon"
+	"github.com/ethereum/go-ethereum/consensus/ethash"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/tracing"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/triedb"
+	"github.com/holiman/uint256"
+)
+
+// setupTestStateWithStorage creates a test state with specified number of accounts and storage slots
+func setupTestStateWithStorage(accounts int, slotsPerAccount int) (*state.StateDB, []common.Address) {
+	db := rawdb.NewMemoryDatabase()
+	trieConfig := triedb.HashDefaults
+	tdb := triedb.NewDatabase(db, trieConfig)
+	defer tdb.Close()
+	
+	statedb, _ := state.New(types.EmptyRootHash, state.NewDatabase(tdb, nil))
+	
+	addresses := make([]common.Address, accounts)
+	
+	// Create accounts with storage
+	for i := 0; i < accounts; i++ {
+		addr := common.BigToAddress(big.NewInt(int64(i + 1)))
+		addresses[i] = addr
+		
+		statedb.CreateAccount(addr)
+		statedb.AddBalance(addr, uint256.NewInt(1000000000000000000), tracing.BalanceIncreaseGenesisBalance) // 1 ETH
+		
+		// Add storage slots to each account
+		for j := 0; j < slotsPerAccount; j++ {
+			key := common.BigToHash(big.NewInt(int64(j)))
+			value := common.BigToHash(big.NewInt(int64(j + 1)))
+			statedb.SetState(addr, key, value)
+		}
+	}
+	
+	statedb.Finalise(true)
+	return statedb, addresses
+}
+
+// createTestGenesis creates a genesis block with EIP-8032 enabled
+func createTestGenesis() *Genesis {
+	return &Genesis{
+		Config: func() *params.ChainConfig {
+			config := *params.MergedTestChainConfig
+			config.EIP8032Time = new(uint64) // Activate immediately
+			*config.EIP8032Time = 0
+			return &config
+		}(),
+		Alloc: types.GenesisAlloc{
+			crypto.PubkeyToAddress(testKey.PublicKey): types.Account{
+				Balance: big.NewInt(1000000000000000000),
+			},
+		},
+	}
+}
+
+var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+
+func BenchmarkEIP8032Transition_Stride100(b *testing.B) {
+	benchmarkEIP8032Transition(b, 100, 100, 10) // 100 accounts × 10 slots = 1,000 slots
+}
+
+func BenchmarkEIP8032Transition_Stride500(b *testing.B) {
+	benchmarkEIP8032Transition(b, 500, 100, 10) // 100 accounts × 10 slots = 1,000 slots
+}
+
+func BenchmarkEIP8032Transition_Stride1000(b *testing.B) {
+	benchmarkEIP8032Transition(b, 1000, 100, 10) // 100 accounts × 10 slots = 1,000 slots
+}
+
+func BenchmarkEIP8032Transition_Stride2500(b *testing.B) {
+	benchmarkEIP8032Transition(b, 2500, 100, 10) // 100 accounts × 10 slots = 1,000 slots
+}
+
+func BenchmarkEIP8032Transition_Stride5000(b *testing.B) {
+	benchmarkEIP8032Transition(b, 5000, 100, 10) // 100 accounts × 10 slots = 1,000 slots
+}
+
+func BenchmarkEIP8032Transition_Stride10000(b *testing.B) {
+	benchmarkEIP8032Transition(b, 10000, 100, 10) // 100 accounts × 10 slots = 1,000 slots
+}
+
+// Large state benchmarks
+func BenchmarkEIP8032Transition_Large_Stride100(b *testing.B) {
+	benchmarkEIP8032Transition(b, 100, 1000, 100) // 1,000 accounts × 100 slots = 100,000 slots
+}
+
+func BenchmarkEIP8032Transition_Large_Stride1000(b *testing.B) {
+	benchmarkEIP8032Transition(b, 1000, 1000, 100) // 1,000 accounts × 100 slots = 100,000 slots
+}
+
+func BenchmarkEIP8032Transition_Large_Stride5000(b *testing.B) {
+	benchmarkEIP8032Transition(b, 5000, 1000, 100) // 1,000 accounts × 100 slots = 100,000 slots
+}
+
+func BenchmarkEIP8032Transition_Large_Stride10000(b *testing.B) {
+	benchmarkEIP8032Transition(b, 10000, 1000, 100) // 1,000 accounts × 100 slots = 100,000 slots
+}
+
+func benchmarkEIP8032Transition(b *testing.B, strideSize uint64, accounts int, slotsPerAccount int) {
+	// Setup
+	genesis := createTestGenesis()
+	engine := beacon.New(ethash.NewFaker())
+	
+	// Generate chain with test state
+	db, blocks, _ := GenerateChainWithGenesis(genesis, engine, 2, func(i int, gen *BlockGen) {
+		if i == 0 {
+			// First block: Create accounts with storage
+			statedb := gen.statedb
+			
+			for j := 0; j < accounts; j++ {
+				addr := common.BigToAddress(big.NewInt(int64(j + 1000))) // Avoid conflicts
+				statedb.CreateAccount(addr)
+				
+				// Add storage slots
+				for k := 0; k < slotsPerAccount; k++ {
+					key := common.BigToHash(big.NewInt(int64(k)))
+					value := common.BigToHash(big.NewInt(int64(k + 1)))
+					statedb.SetState(addr, key, value)
+				}
+			}
+		}
+		if i == 1 {
+			// Second block: Trigger EIP-8032 transition
+			gen.OffsetTime(1) // Activate EIP-8032
+		}
+	})
+	
+	// Create blockchain
+	blockchain, err := NewBlockChain(db, genesis, engine, nil)
+	if err != nil {
+		b.Fatalf("failed to create blockchain: %v", err)
+	}
+	defer blockchain.Stop()
+	
+	// Insert first block to set up state
+	if _, err := blockchain.InsertChain(blocks[:1]); err != nil {
+		b.Fatalf("failed to insert setup block: %v", err)
+	}
+	
+	// Get state after setup
+	state, err := blockchain.State()
+	if err != nil {
+		b.Fatalf("failed to get state: %v", err)
+	}
+	
+	// Reset timer and start benchmark
+	b.ResetTimer()
+	b.ReportAllocs()
+	
+	// Run the benchmark
+	for i := 0; i < b.N; i++ {
+		// Create a copy of state for each iteration
+		stateCopy := state.Copy()
+		
+		// Clear any existing storage counts to simulate pre-EIP8032 state
+		for j := 0; j < accounts; j++ {
+			addr := common.BigToAddress(big.NewInt(int64(j + 1000)))
+			stateCopy.SetStorageCount(addr, 0)
+		}
+		
+		// Run transition with the specified stride size
+		totalProcessed := uint64(0)
+		iterations := 0
+		
+		for {
+			processed, hasMore := stateCopy.ProcessEIP8032Transition(strideSize)
+			totalProcessed += processed
+			iterations++
+			
+			if !hasMore {
+				break
+			}
+			
+			// Limit iterations to prevent infinite loops in case of issues
+			if iterations > 1000 {
+				b.Fatalf("too many iterations: %d", iterations)
+			}
+		}
+		
+		// Verify some slots were processed (basic sanity check)
+		if totalProcessed == 0 && accounts > 0 && slotsPerAccount > 0 {
+			b.Logf("Warning: no slots processed in transition")
+		}
+	}
+	
+	// Calculate some metrics
+	totalSlots := uint64(accounts * slotsPerAccount)
+	expectedIterations := (totalSlots + strideSize - 1) / strideSize // Ceiling division
+	
+	b.Logf("Stride: %d, Accounts: %d, Slots/Account: %d, Total Slots: %d, Expected Iterations: %d", 
+		strideSize, accounts, slotsPerAccount, totalSlots, expectedIterations)
+}
+
+// BenchmarkEIP8032TransitionIntegration tests the full block processing with EIP-8032 transition
+func BenchmarkEIP8032TransitionIntegration(b *testing.B) {
+	genesis := createTestGenesis()
+	engine := beacon.New(ethash.NewFaker())
+	
+	// Test with medium-sized state
+	accounts := 500
+	slotsPerAccount := 20
+	
+	b.ResetTimer()
+	b.ReportAllocs()
+	
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		
+		// Generate chain with transition
+		db, blocks, _ := GenerateChainWithGenesis(genesis, engine, 2, func(i int, gen *BlockGen) {
+			if i == 0 {
+				// Setup state
+				statedb := gen.statedb
+				for j := 0; j < accounts; j++ {
+					addr := common.BigToAddress(big.NewInt(int64(j + 2000)))
+					statedb.CreateAccount(addr)
+					
+					for k := 0; k < slotsPerAccount; k++ {
+						key := common.BigToHash(big.NewInt(int64(k)))
+						value := common.BigToHash(big.NewInt(int64(k + 1)))
+						statedb.SetState(addr, key, value)
+					}
+				}
+			}
+			if i == 1 {
+				gen.OffsetTime(1) // Trigger EIP-8032
+			}
+		})
+		
+		blockchain, err := NewBlockChain(db, genesis, engine, nil)
+		if err != nil {
+			b.Fatalf("failed to create blockchain: %v", err)
+		}
+		
+		b.StartTimer()
+		
+		// Benchmark the block insertion (includes transition processing)
+		if _, err := blockchain.InsertChain(blocks); err != nil {
+			b.Fatalf("failed to insert chain: %v", err)
+		}
+		
+		b.StopTimer()
+		blockchain.Stop()
+	}
+}