p256k1/bench/BENCHMARK_REPORT.md

Benchmark Comparison Report

Signer Implementation Comparison

This report compares three signer implementations for secp256k1 operations:

1. P256K1Signer - This repository's new port from Bitcoin Core secp256k1 (pure Go)
2. BtcecSigner - Pure Go wrapper around btcec/v2
3. NextP256K Signer - CGO version using next.orly.dev/pkg/crypto/p256k (CGO bindings to libsecp256k1)

Generated: 2025-11-02 (Updated after ECDH optimization with windowed multiplication)
Platform: linux/amd64
CPU: AMD Ryzen 5 PRO 4650G with Radeon Graphics
Go Version: go1.25.3

Key Optimizations:

• Implemented 8-bit byte-based precomputed tables matching btcec's approach, resulting in 4x improvement in pubkey derivation and 4.3x improvement in signing.
• Optimized windowed multiplication for verification (5-bit windows, Jacobian coordinate table building): 20% improvement (186,054 → 149,511 ns/op).
• Optimized ECDH with windowed multiplication (5-bit windows): 33% improvement (163,356 → 109,068 ns/op), now fastest for ECDH.

---

Summary Results

Operation	P256K1Signer	BtcecSigner	NextP256K	Winner
Pubkey Derivation	58,383 ns/op	62,909 ns/op	417,383 ns/op	P256K1 (8% faster than Btcec)
Sign	63,421 ns/op	218,085 ns/op	52,273 ns/op	NextP256K (1.2x faster than P256K1)
Verify	149,511 ns/op	163,396 ns/op	40,208 ns/op	NextP256K (3.7x faster)
ECDH	109,068 ns/op	127,739 ns/op	124,039 ns/op	P256K1 (1.1x faster than NextP256K)

---

Detailed Results

Public Key Derivation

Deriving public key from private key (32 bytes → 32 bytes x-only pubkey).

Implementation	Time per op	Memory	Allocations	Speedup vs P256K1
P256K1Signer	58,383 ns/op	256 B/op	4 allocs/op	1.0x (baseline)
BtcecSigner	62,909 ns/op	368 B/op	7 allocs/op	0.9x slower
NextP256K	417,383 ns/op	983,395 B/op	9 allocs/op	0.1x slower

Analysis:

• P256K1 is fastest (8% faster than Btcec) after implementing 8-bit byte-based precomputed tables
• Massive improvement: 4x faster than previous implementation (232,922 → 58,618 ns/op)
• NextP256K is slowest, likely due to CGO overhead for small operations
• P256K1 has lowest memory allocation overhead

Signing (Schnorr)

Creating BIP-340 Schnorr signatures (32-byte message → 64-byte signature).

Implementation	Time per op	Memory	Allocations	Speedup vs P256K1
P256K1Signer	63,421 ns/op	1,152 B/op	17 allocs/op	1.0x (baseline)
BtcecSigner	218,085 ns/op	2,193 B/op	38 allocs/op	0.3x slower
NextP256K	52,273 ns/op	128 B/op	3 allocs/op	1.2x faster

Analysis:

• NextP256K is fastest (1.2x faster than P256K1), benefiting from optimized C implementation
• P256K1 is second fastest (3.4x faster than Btcec)
• Btcec is slowest, likely due to more allocations and pure Go overhead
• NextP256K has lowest memory usage (128 B vs 1,152 B)

Verification (Schnorr)

Verifying BIP-340 Schnorr signatures (32-byte message + 64-byte signature).

Implementation	Time per op	Memory	Allocations	Speedup vs P256K1
P256K1Signer	149,511 ns/op	576 B/op	9 allocs/op	1.0x (baseline)
BtcecSigner	163,396 ns/op	1,121 B/op	18 allocs/op	0.9x slower
NextP256K	40,208 ns/op	96 B/op	2 allocs/op	3.7x faster

Analysis:

• NextP256K is dramatically fastest (3.7x faster), showcasing CGO advantage for verification
• P256K1 is fastest pure Go implementation (8% faster than Btcec) after optimized windowed multiplication
• 20% improvement over previous implementation (186,054 → 149,511 ns/op)
• Optimizations: 5-bit windowed multiplication with efficient Jacobian coordinate table building
• NextP256K has minimal memory footprint (96 B vs 576 B)

ECDH (Shared Secret Generation)

Generating shared secret using Elliptic Curve Diffie-Hellman.

Implementation	Time per op	Memory	Allocations	Speedup vs P256K1
P256K1Signer	109,068 ns/op	241 B/op	6 allocs/op	1.0x (baseline)
BtcecSigner	127,739 ns/op	832 B/op	13 allocs/op	0.9x slower
NextP256K	124,039 ns/op	160 B/op	3 allocs/op	0.9x slower

Analysis:

• P256K1 is fastest (1.1x faster than NextP256K) after optimizing with windowed multiplication
• 33% improvement over previous implementation (163,356 → 109,068 ns/op)
• Optimizations: 5-bit windowed multiplication with efficient Jacobian coordinate table building
• P256K1 has lowest memory usage (241 B)

---

Performance Analysis

Overall Winner: Mixed (P256K1 wins 2/4 operations, NextP256K wins 2/4 operations)

After optimized windowed multiplication for ECDH:

• P256K1Signer wins in 2 out of 4 operations:
  • Pubkey Derivation: Fastest (8% faster than Btcec)
  • ECDH: Fastest (1.1x faster than NextP256K) - 33% improvement!
• NextP256K wins in 2 operations:
  • Signing: Fastest (1.2x faster than P256K1)
  • Verification: Fastest (3.7x faster than P256K1, CGO advantage)

Best Pure Go: P256K1Signer

For pure Go implementations:

• P256K1 wins for key derivation (8% faster than Btcec)
• P256K1 wins for signing (3.4x faster than Btcec)
• P256K1 wins for verification (8% faster than Btcec) - fastest pure Go!
• P256K1 wins for ECDH (1.2x faster than Btcec) - now fastest pure Go!

Memory Efficiency

Implementation	Avg Memory per Operation	Notes
P256K1Signer	~500 B avg	Low memory footprint, consistent across operations
NextP256K	~300 KB avg	Very efficient, minimal allocations (except pubkey derivation overhead)
BtcecSigner	~1.1 KB avg	Higher allocations, but acceptable

Note: NextP256K shows high memory in pubkey derivation (983 KB) due to one-time CGO initialization overhead, but this is amortized across operations.

---

Recommendations

Use NextP256K (CGO) when:

• Maximum performance is critical
• CGO is acceptable in your build environment
• Low memory footprint is important
• Verification speed is critical (4.7x faster)

Use P256K1Signer when:

• Pure Go is required (no CGO)
• Pubkey derivation, signing, verification, or ECDH performance is critical (now fastest pure Go for all operations!)
• Lower memory allocations are preferred
• You want to avoid external C dependencies
• You need the best overall pure Go performance

Use BtcecSigner when:

• Pure Go is required
• You're already using btcec in your project
• Note: P256K1Signer is faster across all operations

---

Conclusion

The benchmarks demonstrate that:

1. After optimized windowed multiplication for ECDH, P256K1Signer achieves:

   • Fastest pubkey derivation among all implementations (58,383 ns/op)
   • Fastest ECDH among all implementations (109,068 ns/op) - 33% improvement (163,356 → 109,068 ns/op)
   • Fastest pure Go verification (149,511 ns/op) - 20% improvement (186,054 → 149,511 ns/op)
   • Fastest pure Go signing (63,421 ns/op) - 3.4x faster than Btcec

2. Windowed multiplication optimization results:

   • Implemented 5-bit windowed multiplication with efficient Jacobian coordinate table building
   • Kept all operations in Jacobian coordinates to avoid expensive affine conversions
   • Reduced iterations from 256 (bit-by-bit) to ~52 (5-bit windows)
   • ECDH: 33% improvement (163,356 → 109,068 ns/op)
   • Verification: 20% improvement (186,054 → 149,511 ns/op)

3. CGO implementations (NextP256K) still provide advantages for verification (3.7x faster) and signing (1.2x faster)

4. Pure Go implementations are highly competitive, with P256K1Signer leading in 2 out of 4 operations (pubkey derivation and ECDH)

5. Memory efficiency varies by operation, with P256K1Signer maintaining low memory usage (256 B for pubkey derivation, 241 B for ECDH)

The choice between implementations depends on your specific requirements:

• Maximum performance: Use NextP256K (CGO) - fastest for verification and signing
• Best pure Go performance: Use P256K1Signer - fastest for pubkey derivation and ECDH, fastest pure Go for all operations!
• Pure Go alternative: Use BtcecSigner (but P256K1Signer is faster across all operations)

---

Running the Benchmarks

To reproduce these benchmarks:

# Run all benchmarks
CGO_ENABLED=1 go test -tags=cgo ./bench -bench=. -benchmem

# Run specific operation
CGO_ENABLED=1 go test -tags=cgo ./bench -bench=BenchmarkSign

# Run specific implementation
CGO_ENABLED=1 go test -tags=cgo ./bench -bench=Benchmark.*_P256K1

Note: All benchmarks require CGO to be enabled (CGO_ENABLED=1) and the cgo build tag.