Sequencer is working (minimal parsing)
This commit is contained in:
Krypto Kajun
391
pkg/performance/pools.go
Normal file
391
pkg/performance/pools.go
Normal file
@@ -0,0 +1,391 @@
|
||||
package performance
|
||||
|
||||
import (
|
||||
"math/big"
|
||||
"sync"
|
||||
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/fraktal/mev-beta/pkg/events"
|
||||
"github.com/holiman/uint256"
|
||||
)
|
||||
|
||||
// ObjectPool manages reusable objects to reduce garbage collection pressure
|
||||
type ObjectPool struct {
|
||||
bigIntPool sync.Pool
|
||||
uint256Pool sync.Pool
|
||||
eventPool sync.Pool
|
||||
addressPool sync.Pool
|
||||
slicePool sync.Pool
|
||||
}
|
||||
|
||||
// NewObjectPool creates a new object pool for performance optimization
|
||||
func NewObjectPool() *ObjectPool {
|
||||
return &ObjectPool{
|
||||
bigIntPool: sync.Pool{
|
||||
New: func() interface{} {
|
||||
return new(big.Int)
|
||||
},
|
||||
},
|
||||
uint256Pool: sync.Pool{
|
||||
New: func() interface{} {
|
||||
return new(uint256.Int)
|
||||
},
|
||||
},
|
||||
eventPool: sync.Pool{
|
||||
New: func() interface{} {
|
||||
return &events.Event{}
|
||||
},
|
||||
},
|
||||
addressPool: sync.Pool{
|
||||
New: func() interface{} {
|
||||
return make([]common.Address, 0, 8)
|
||||
},
|
||||
},
|
||||
slicePool: sync.Pool{
|
||||
New: func() interface{} {
|
||||
return make([]byte, 0, 1024)
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// GetBigInt returns a reusable big.Int from the pool
|
||||
func (p *ObjectPool) GetBigInt() *big.Int {
|
||||
bi := p.bigIntPool.Get().(*big.Int)
|
||||
bi.SetInt64(0) // Reset to zero
|
||||
return bi
|
||||
}
|
||||
|
||||
// PutBigInt returns a big.Int to the pool for reuse
|
||||
func (p *ObjectPool) PutBigInt(bi *big.Int) {
|
||||
if bi != nil {
|
||||
p.bigIntPool.Put(bi)
|
||||
}
|
||||
}
|
||||
|
||||
// GetUint256 returns a reusable uint256.Int from the pool
|
||||
func (p *ObjectPool) GetUint256() *uint256.Int {
|
||||
ui := p.uint256Pool.Get().(*uint256.Int)
|
||||
ui.SetUint64(0) // Reset to zero
|
||||
return ui
|
||||
}
|
||||
|
||||
// PutUint256 returns a uint256.Int to the pool for reuse
|
||||
func (p *ObjectPool) PutUint256(ui *uint256.Int) {
|
||||
if ui != nil {
|
||||
p.uint256Pool.Put(ui)
|
||||
}
|
||||
}
|
||||
|
||||
// GetEvent returns a reusable Event from the pool
|
||||
func (p *ObjectPool) GetEvent() *events.Event {
|
||||
event := p.eventPool.Get().(*events.Event)
|
||||
// Reset event fields
|
||||
*event = events.Event{}
|
||||
return event
|
||||
}
|
||||
|
||||
// PutEvent returns an Event to the pool for reuse
|
||||
func (p *ObjectPool) PutEvent(event *events.Event) {
|
||||
if event != nil {
|
||||
p.eventPool.Put(event)
|
||||
}
|
||||
}
|
||||
|
||||
// GetAddressSlice returns a reusable address slice from the pool
|
||||
func (p *ObjectPool) GetAddressSlice() []common.Address {
|
||||
slice := p.addressPool.Get().([]common.Address)
|
||||
return slice[:0] // Reset length to 0 but keep capacity
|
||||
}
|
||||
|
||||
// PutAddressSlice returns an address slice to the pool for reuse
|
||||
func (p *ObjectPool) PutAddressSlice(slice []common.Address) {
|
||||
if slice != nil && cap(slice) > 0 {
|
||||
p.addressPool.Put(slice)
|
||||
}
|
||||
}
|
||||
|
||||
// GetByteSlice returns a reusable byte slice from the pool
|
||||
func (p *ObjectPool) GetByteSlice() []byte {
|
||||
slice := p.slicePool.Get().([]byte)
|
||||
return slice[:0] // Reset length to 0 but keep capacity
|
||||
}
|
||||
|
||||
// PutByteSlice returns a byte slice to the pool for reuse
|
||||
func (p *ObjectPool) PutByteSlice(slice []byte) {
|
||||
if slice != nil && cap(slice) > 0 {
|
||||
p.slicePool.Put(slice)
|
||||
}
|
||||
}
|
||||
|
||||
// LockFreeRingBuffer implements a lock-free ring buffer for high-performance message passing
|
||||
type LockFreeRingBuffer struct {
|
||||
buffer []interface{}
|
||||
mask uint64
|
||||
head uint64 // Padding to prevent false sharing
|
||||
_ [7]uint64
|
||||
tail uint64 // Padding to prevent false sharing
|
||||
_ [7]uint64
|
||||
}
|
||||
|
||||
// NewLockFreeRingBuffer creates a new lock-free ring buffer
|
||||
// Size must be a power of 2
|
||||
func NewLockFreeRingBuffer(size uint64) *LockFreeRingBuffer {
|
||||
// Ensure size is power of 2
|
||||
if size&(size-1) != 0 {
|
||||
// Find next power of 2
|
||||
size = 1 << (64 - countLeadingZeros(size-1))
|
||||
}
|
||||
|
||||
return &LockFreeRingBuffer{
|
||||
buffer: make([]interface{}, size),
|
||||
mask: size - 1,
|
||||
}
|
||||
}
|
||||
|
||||
// countLeadingZeros counts leading zeros in a uint64
|
||||
func countLeadingZeros(x uint64) int {
|
||||
if x == 0 {
|
||||
return 64
|
||||
}
|
||||
n := 0
|
||||
if x <= 0x00000000FFFFFFFF {
|
||||
n += 32
|
||||
x <<= 32
|
||||
}
|
||||
if x <= 0x0000FFFFFFFFFFFF {
|
||||
n += 16
|
||||
x <<= 16
|
||||
}
|
||||
if x <= 0x00FFFFFFFFFFFFFF {
|
||||
n += 8
|
||||
x <<= 8
|
||||
}
|
||||
if x <= 0x0FFFFFFFFFFFFFFF {
|
||||
n += 4
|
||||
x <<= 4
|
||||
}
|
||||
if x <= 0x3FFFFFFFFFFFFFFF {
|
||||
n += 2
|
||||
x <<= 2
|
||||
}
|
||||
if x <= 0x7FFFFFFFFFFFFFFF {
|
||||
n += 1
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// FastCache implements a high-performance cache with minimal locking
|
||||
type FastCache struct {
|
||||
shards []*CacheShard
|
||||
mask uint64
|
||||
}
|
||||
|
||||
// CacheShard represents a single cache shard to reduce lock contention
|
||||
type CacheShard struct {
|
||||
mu sync.RWMutex
|
||||
data map[string]*CacheItem
|
||||
size int
|
||||
limit int
|
||||
}
|
||||
|
||||
// CacheItem represents a cached item with metadata
|
||||
type CacheItem struct {
|
||||
Value interface{}
|
||||
AccessTime int64
|
||||
Cost int
|
||||
}
|
||||
|
||||
// NewFastCache creates a new high-performance cache
|
||||
func NewFastCache(shardCount, itemsPerShard int) *FastCache {
|
||||
// Ensure shard count is power of 2
|
||||
if shardCount&(shardCount-1) != 0 {
|
||||
shardCount = 1 << (32 - countLeadingZeros32(uint32(shardCount-1)))
|
||||
}
|
||||
|
||||
shards := make([]*CacheShard, shardCount)
|
||||
for i := 0; i < shardCount; i++ {
|
||||
shards[i] = &CacheShard{
|
||||
data: make(map[string]*CacheItem, itemsPerShard),
|
||||
limit: itemsPerShard,
|
||||
}
|
||||
}
|
||||
|
||||
return &FastCache{
|
||||
shards: shards,
|
||||
mask: uint64(shardCount - 1),
|
||||
}
|
||||
}
|
||||
|
||||
// countLeadingZeros32 counts leading zeros in a uint32
|
||||
func countLeadingZeros32(x uint32) int {
|
||||
if x == 0 {
|
||||
return 32
|
||||
}
|
||||
n := 0
|
||||
if x <= 0x0000FFFF {
|
||||
n += 16
|
||||
x <<= 16
|
||||
}
|
||||
if x <= 0x00FFFFFF {
|
||||
n += 8
|
||||
x <<= 8
|
||||
}
|
||||
if x <= 0x0FFFFFFF {
|
||||
n += 4
|
||||
x <<= 4
|
||||
}
|
||||
if x <= 0x3FFFFFFF {
|
||||
n += 2
|
||||
x <<= 2
|
||||
}
|
||||
if x <= 0x7FFFFFFF {
|
||||
n += 1
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// hash computes a hash for the key
|
||||
func (c *FastCache) hash(key string) uint64 {
|
||||
hash := uint64(0)
|
||||
for _, b := range key {
|
||||
hash = hash*31 + uint64(b)
|
||||
}
|
||||
return hash
|
||||
}
|
||||
|
||||
// getShard returns the shard for a given key
|
||||
func (c *FastCache) getShard(key string) *CacheShard {
|
||||
return c.shards[c.hash(key)&c.mask]
|
||||
}
|
||||
|
||||
// Get retrieves an item from the cache
|
||||
func (c *FastCache) Get(key string) (interface{}, bool) {
|
||||
shard := c.getShard(key)
|
||||
shard.mu.RLock()
|
||||
item, exists := shard.data[key]
|
||||
shard.mu.RUnlock()
|
||||
|
||||
if exists {
|
||||
return item.Value, true
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
|
||||
// Set stores an item in the cache
|
||||
func (c *FastCache) Set(key string, value interface{}, cost int) {
|
||||
shard := c.getShard(key)
|
||||
shard.mu.Lock()
|
||||
|
||||
// Check if we need to evict items
|
||||
if shard.size >= shard.limit && shard.data[key] == nil {
|
||||
c.evictOldest(shard)
|
||||
}
|
||||
|
||||
shard.data[key] = &CacheItem{
|
||||
Value: value,
|
||||
Cost: cost,
|
||||
}
|
||||
shard.size++
|
||||
|
||||
shard.mu.Unlock()
|
||||
}
|
||||
|
||||
// evictOldest removes the oldest item from a shard
|
||||
func (c *FastCache) evictOldest(shard *CacheShard) {
|
||||
var oldestKey string
|
||||
var oldestTime int64 = 1<<63 - 1
|
||||
|
||||
for key, item := range shard.data {
|
||||
if item.AccessTime < oldestTime {
|
||||
oldestTime = item.AccessTime
|
||||
oldestKey = key
|
||||
}
|
||||
}
|
||||
|
||||
if oldestKey != "" {
|
||||
delete(shard.data, oldestKey)
|
||||
shard.size--
|
||||
}
|
||||
}
|
||||
|
||||
// BatchProcessor processes items in batches for better performance
|
||||
type BatchProcessor struct {
|
||||
batchSize int
|
||||
flushTimeout int64 // nanoseconds
|
||||
buffer []interface{}
|
||||
processor func([]interface{}) error
|
||||
mu sync.Mutex
|
||||
}
|
||||
|
||||
// NewBatchProcessor creates a new batch processor
|
||||
func NewBatchProcessor(batchSize int, flushTimeoutNs int64, processor func([]interface{}) error) *BatchProcessor {
|
||||
return &BatchProcessor{
|
||||
batchSize: batchSize,
|
||||
flushTimeout: flushTimeoutNs,
|
||||
buffer: make([]interface{}, 0, batchSize),
|
||||
processor: processor,
|
||||
}
|
||||
}
|
||||
|
||||
// Add adds an item to the batch processor
|
||||
func (bp *BatchProcessor) Add(item interface{}) error {
|
||||
bp.mu.Lock()
|
||||
defer bp.mu.Unlock()
|
||||
|
||||
bp.buffer = append(bp.buffer, item)
|
||||
|
||||
if len(bp.buffer) >= bp.batchSize {
|
||||
return bp.flushLocked()
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Flush processes all items in the buffer immediately
|
||||
func (bp *BatchProcessor) Flush() error {
|
||||
bp.mu.Lock()
|
||||
defer bp.mu.Unlock()
|
||||
|
||||
return bp.flushLocked()
|
||||
}
|
||||
|
||||
// flushLocked processes items while holding the lock
|
||||
func (bp *BatchProcessor) flushLocked() error {
|
||||
if len(bp.buffer) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
batch := make([]interface{}, len(bp.buffer))
|
||||
copy(batch, bp.buffer)
|
||||
bp.buffer = bp.buffer[:0] // Reset buffer
|
||||
|
||||
return bp.processor(batch)
|
||||
}
|
||||
|
||||
// MemoryOptimizer provides utilities for memory optimization
|
||||
type MemoryOptimizer struct {
|
||||
pools *ObjectPool
|
||||
}
|
||||
|
||||
// NewMemoryOptimizer creates a new memory optimizer
|
||||
func NewMemoryOptimizer() *MemoryOptimizer {
|
||||
return &MemoryOptimizer{
|
||||
pools: NewObjectPool(),
|
||||
}
|
||||
}
|
||||
|
||||
// ProcessWithPools processes data using object pools to minimize allocations
|
||||
func (mo *MemoryOptimizer) ProcessWithPools(data []byte, processor func(*big.Int, *uint256.Int, []byte) error) error {
|
||||
bigInt := mo.pools.GetBigInt()
|
||||
uint256Int := mo.pools.GetUint256()
|
||||
workBuffer := mo.pools.GetByteSlice()
|
||||
|
||||
defer func() {
|
||||
mo.pools.PutBigInt(bigInt)
|
||||
mo.pools.PutUint256(uint256Int)
|
||||
mo.pools.PutByteSlice(workBuffer)
|
||||
}()
|
||||
|
||||
return processor(bigInt, uint256Int, workBuffer)
|
||||
}
|
||||
Reference in New Issue
Block a user