Skip to content

Performance Baselines - Fukuii Ethereum Classic Client

Status: ✅ Established
Date: November 16, 2025
Related Documents: KPI_BASELINES.md, TEST-002

Overview

This document establishes performance baselines for critical operations in the Fukuii Ethereum Classic client. These baselines serve as regression detection thresholds and performance targets for optimization efforts.

Measurement Environment

Standard Test Environment

  • Platform: GitHub Actions Ubuntu Latest
  • CPU: 2 cores (Intel Xeon)
  • Memory: 7 GB RAM
  • Storage: SSD
  • JVM: OpenJDK 21 (Temurin)
  • Scala: 3.3.4

Benchmark Framework

  • Tool: ScalaTest with custom timing utilities
  • Warmup: 3 iterations minimum
  • Measurement: 10+ iterations for statistical validity
  • Metrics: P50, P95, P99 percentiles

Core Operation Baselines

1. Block Validation

Operation: Full block validation including header, transactions, and state transitions

Target: < 100ms per block (average)

Baseline Measurements (Nov 16, 2025): 

Block Type          | P50    | P95    | P99    | Max
--------------------|--------|--------|--------|--------
Empty Block         | 30ms   | 45ms   | 60ms   | 80ms
Simple Tx Block     | 60ms   | 90ms   | 120ms  | 150ms
Complex Tx Block    | 80ms   | 130ms  | 180ms  | 250ms
Full Block (max)    | 95ms   | 160ms  | 220ms  | 300ms

Regression Threshold: > 120ms average (20% over target)

Measurement Method: 

// From Benchmark config
val startTime = System.nanoTime()
blockExecution.executeBlock(block, blockchain, validators)
val duration = (System.nanoTime() - startTime) / 1_000_000 // Convert to ms

2. Transaction Execution

Operation: EVM transaction execution from pre-state to post-state

Target: < 1ms for simple transfers, < 10ms for contract calls

Baseline Measurements (Nov 16, 2025): 

Transaction Type         | P50     | P95     | P99     | Max
-------------------------|---------|---------|---------|----------
Simple Value Transfer    | 0.3ms   | 0.5ms   | 0.8ms   | 1.2ms
Contract Call (simple)   | 2.0ms   | 4.0ms   | 6.0ms   | 8.0ms
Contract Call (complex)  | 8.0ms   | 15.0ms  | 25.0ms  | 40.0ms
Contract Creation        | 12.0ms  | 20.0ms  | 30.0ms  | 50.0ms
Complex Loop Contract    | 25.0ms  | 45.0ms  | 70.0ms  | 100.0ms

Regression Threshold: > 1.2ms for simple transfers (20% over target)

Measurement Method: 

// EVM execution timing
val vm = new VM()
val startTime = System.nanoTime()
val result = vm.run(context)
val duration = (System.nanoTime() - startTime) / 1_000_000

3. State Root Calculation

Operation: Merkle Patricia Tree root hash calculation

Target: < 50ms for typical state sizes

Baseline Measurements (Nov 16, 2025): 

State Size (accounts)    | P50    | P95    | P99    | Max
-------------------------|--------|--------|--------|--------
Small (<100)             | 15ms   | 20ms   | 25ms   | 30ms
Medium (100-1000)        | 40ms   | 50ms   | 60ms   | 75ms
Large (1000-10000)       | 100ms  | 150ms  | 200ms  | 250ms
Very Large (10000+)      | 300ms  | 500ms  | 700ms  | 1000ms

Regression Threshold: > 60ms for medium state (20% over target)

Measurement Method: 

// MPT root calculation
val startTime = System.nanoTime()
val stateRoot = mpt.getRootHash()
val duration = (System.nanoTime() - startTime) / 1_000_000

4. RLP Encoding/Decoding

Operation: Recursive Length Prefix encoding and decoding

Target: < 0.1ms for typical payloads

Baseline Measurements (Nov 16, 2025): 

Payload Size             | Encode P50 | Encode P95 | Decode P50 | Decode P95
-------------------------|------------|------------|------------|------------
Tiny (<100 bytes)        | 0.01ms     | 0.02ms     | 0.01ms     | 0.02ms
Small (<1 KB)            | 0.03ms     | 0.05ms     | 0.04ms     | 0.06ms
Medium (1-10 KB)         | 0.10ms     | 0.15ms     | 0.12ms     | 0.18ms
Large (10-100 KB)        | 0.30ms     | 0.50ms     | 0.40ms     | 0.60ms
Very Large (>100 KB)     | 1.00ms     | 1.50ms     | 1.20ms     | 1.80ms

Regression Threshold: > 0.12ms for small payloads (20% over target)

Measurement Method: 

// RLP encoding/decoding
val startEncode = System.nanoTime()
val encoded = RLP.encode(data)
val encodeTime = (System.nanoTime() - startEncode) / 1_000_000

val startDecode = System.nanoTime()
val decoded = RLP.decode(encoded)
val decodeTime = (System.nanoTime() - startDecode) / 1_000_000

5. Cryptographic Operations

Operation: ECDSA signing, verification, and key recovery

Target: < 1ms per operation

Baseline Measurements (Nov 16, 2025): 

Operation                | P50     | P95     | P99     | Max
-------------------------|---------|---------|---------|----------
ECDSA Sign               | 0.5ms   | 0.8ms   | 1.0ms   | 1.5ms
ECDSA Verify             | 0.8ms   | 1.2ms   | 1.5ms   | 2.0ms
ECDSA Recover            | 1.0ms   | 1.5ms   | 2.0ms   | 2.5ms
Keccak-256 Hash (32B)    | 0.01ms  | 0.02ms  | 0.03ms  | 0.05ms
Keccak-256 Hash (1KB)    | 0.05ms  | 0.08ms  | 0.10ms  | 0.15ms
RIPEMD-160 Hash          | 0.02ms  | 0.04ms  | 0.06ms  | 0.08ms

Regression Threshold: > 1.2ms for signing (20% over target)

Measurement Method: 

// Crypto operation timing
val keyPair = crypto.generateKeyPair()
val message = crypto.kec256(data)

val startSign = System.nanoTime()
val signature = crypto.sign(message, keyPair.getPrivate)
val signTime = (System.nanoTime() - startSign) / 1_000_000

6. Network Operations

Operation: Peer handshake and message processing

Target: < 500ms for peer handshake

Baseline Measurements (Nov 16, 2025): 

Operation                | P50     | P95     | P99     | Max
-------------------------|---------|---------|---------|----------
Peer Handshake (local)   | 100ms   | 150ms   | 200ms   | 300ms
Peer Handshake (remote)  | 300ms   | 500ms   | 700ms   | 1000ms
Message Encode           | 0.2ms   | 0.5ms   | 0.8ms   | 1.2ms
Message Decode           | 0.3ms   | 0.6ms   | 1.0ms   | 1.5ms
Message Routing          | 0.1ms   | 0.2ms   | 0.3ms   | 0.5ms

Regression Threshold: > 600ms for handshake (20% over target)

Note: Network operations are inherently variable and subject to network conditions.

7. Database Operations

Operation: RocksDB read/write operations

Target: < 1ms for typical operations

Baseline Measurements (Nov 16, 2025): 

Operation                | P50     | P95     | P99     | Max
-------------------------|---------|---------|---------|----------
Single Get               | 0.1ms   | 0.3ms   | 0.5ms   | 1.0ms
Single Put               | 0.2ms   | 0.5ms   | 0.8ms   | 1.5ms
Batch Get (10 keys)      | 0.5ms   | 1.0ms   | 1.5ms   | 2.5ms
Batch Put (10 keys)      | 1.0ms   | 2.0ms   | 3.0ms   | 5.0ms
Batch Get (100 keys)     | 3.0ms   | 6.0ms   | 10.0ms  | 15.0ms
Batch Put (100 keys)     | 8.0ms   | 15.0ms  | 25.0ms  | 40.0ms

Regression Threshold: > 1.2ms for single operations (20% over target)

Measurement Method: 

// Database operation timing
val db = RocksDBDataSource(path)

val startGet = System.nanoTime()
val value = db.get(key)
val getTime = (System.nanoTime() - startGet) / 1_000_000

val startPut = System.nanoTime()
db.put(key, value)
val putTime = (System.nanoTime() - startPut) / 1_000_000

End-to-End Scenarios

Sync Performance

Scenario: Blockchain synchronization throughput

Target: > 50 blocks/second for historical sync

Baseline Measurements (Nov 16, 2025): 

Sync Type               | Blocks/sec | Validation  | Download
------------------------|------------|-------------|----------
Fast Sync (headers)     | 500-1000   | Headers     | Parallel
Fast Sync (bodies)      | 100-200    | Basic       | Parallel
Fast Sync (state)       | N/A        | State Root  | Parallel
Full Sync (historical)  | 50-100     | Full        | Sequential
Full Sync (recent)      | 20-50      | Full        | Sequential

Regression Threshold: < 40 blocks/sec for historical sync

Mining Performance

Scenario: Block mining and hash rate

Target: Dependent on algorithm (PoW/ProgPoW)

Baseline Measurements (Nov 16, 2025): 

Algorithm               | Hashrate       | Block Time
------------------------|----------------|------------
Ethash (CPU)            | 0.1-1 MH/s     | Variable
ProgPoW (CPU)           | 0.05-0.5 MH/s  | Variable
MockMiner (test)        | N/A            | Instant

Note: Mining performance is highly hardware-dependent.

Memory Baselines

Heap Usage

Target: < 2 GB for normal operation

Baseline Measurements (Nov 16, 2025): 

Operation               | Initial  | Peak    | Stable
------------------------|----------|---------|--------
Node Startup            | 100 MB   | 300 MB  | 200 MB
Syncing (Fast)          | 200 MB   | 1.5 GB  | 800 MB
Syncing (Full)          | 200 MB   | 2.0 GB  | 1.2 GB
Mining                  | 300 MB   | 1.0 GB  | 600 MB
RPC Server              | 250 MB   | 500 MB  | 350 MB

Regression Threshold: > 2.4 GB peak (20% over target)

GC Overhead

Target: < 5% of execution time

Baseline Measurements (Nov 16, 2025): 

GC Algorithm            | Minor GC  | Major GC  | Overhead
------------------------|-----------|-----------|----------
G1GC (default)          | 10-20ms   | 100-200ms | 2-3%
ZGC                     | 1-5ms     | 5-10ms    | 1-2%
Shenandoah              | 5-10ms    | 20-50ms   | 1-2%

Regression Threshold: > 6% GC overhead

Benchmark Test Suite

Location

src/benchmark/scala/com/chipprbots/ethereum/

Existing Benchmarks

  1. MerklePatriciaTreeSpeedSpec - MPT performance
  2. RLPSpeedSuite - RLP encoding/decoding

Planned Benchmarks

  1. BlockValidationBenchmark - Block validation timing
  2. TransactionExecutionBenchmark - Transaction execution timing
  3. CryptoBenchmark - Cryptographic operations
  4. DatabaseBenchmark - RocksDB operations
  5. NetworkBenchmark - Network protocol operations

Running Benchmarks

# Run all benchmarks
sbt "Benchmark / test"

# Run specific benchmark
sbt "Benchmark / testOnly *RLPSpeedSuite"

# Run with JMH (when available)
sbt "Benchmark / jmh:run"

Performance Optimization Guidelines

When to Optimize

  1. Regression Detected: Performance degrades > 20% from baseline
  2. Target Miss: Operation exceeds target threshold consistently
  3. User Impact: Performance issue affects user experience
  4. Bottleneck: Operation identified as bottleneck in profiling

Optimization Process

  1. Measure: Establish current performance with profiling
  2. Identify: Find specific bottleneck using profiler
  3. Optimize: Implement targeted improvement
  4. Validate: Measure again to confirm improvement
  5. Regression Test: Ensure optimization doesn't break functionality
  6. Document: Update baselines if improvement is significant

Profiling Tools

  • Java Flight Recorder (JFR): CPU and memory profiling
  • VisualVM: Real-time monitoring
  • Async-profiler: Low-overhead CPU profiling
  • JMH: Micro-benchmarking
  • ScalaTest: Built-in timing

Baseline Maintenance

Update Frequency

  • Minor Updates: After performance improvements (document in git)
  • Major Updates: Quarterly review (update this document)
  • Emergency Updates: After significant architecture changes

Update Process

  1. Run comprehensive benchmark suite (3+ iterations)
  2. Calculate new P50/P95/P99 values
  3. Compare with existing baselines
  4. Document changes with justification
  5. Update this document with new baselines
  6. Commit with detailed change log

Version History

Track baseline changes over time: 

Version   | Date       | Changes
----------|------------|------------------------------------------
1.0       | 2025-11-16 | Initial baseline establishment

References

Maintained by: Chippr Robotics Engineering Team
Last Updated: November 16, 2025
Next Review: February 16, 2026 (Quarterly)