┌─────────────────────────────────────────────────────────────────────────┐
│                     PERFORMANCE-CRITICAL PATH                            │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│   Network Layer (0.5-2 us)                                              │
│   ┌───────────────────────────────────────────────────────────────┐    │
│   │  Kernel Bypass (io_uring) │ TCP_NODELAY │ SO_BUSY_POLL        │    │
│   │  Zero-Copy Receive │ Multicast Groups │ DPDK (optional)       │    │
│   └───────────────────────────────────────────────────────────────┘    │
│                              ↓                                          │
│   Protocol Layer (100-500 ns)                                          │
│   ┌───────────────────────────────────────────────────────────────┐    │
│   │  FlatBuffers (zero-copy) │ Protobuf (pooled) │ Binary codec   │    │
│   │  Pre-allocated buffers │ Arena allocation │ No reflection     │    │
│   └───────────────────────────────────────────────────────────────┘    │
│                              ↓                                          │
│   Matching Engine (2 ns - 487 ns)                                      │
│   ┌───────────────────────────────────────────────────────────────┐    │
│   │  Lock-free orderbook │ SIMD price comparison │ CPU pinning    │    │
│   │  NUMA-aware allocation │ Cache-line alignment │ Branch-free   │    │
│   └───────────────────────────────────────────────────────────────┘    │
│                              ↓                                          │
│   Persistence Layer (async, non-blocking)                              │
│   ┌───────────────────────────────────────────────────────────────┐    │
│   │  Write-ahead log │ Async commit │ Memory-mapped │ Batching    │    │
│   └───────────────────────────────────────────────────────────────┘    │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

// BAD: Allocates on every order
func (ob *OrderBook) Match(order *Order) *Trade {
    trade := &Trade{} // Heap allocation
    return trade
}

// GOOD: Pool-allocated, zero heap allocations
func (ob *OrderBook) Match(order *Order) *Trade {
    trade := ob.tradePool.Get() // Pre-allocated pool
    trade.Reset()
    return trade
}

// Lock-free price level using atomic operations
type PriceLevel struct {
    price    atomic.Int64
    quantity atomic.Int64
    orders   atomic.Pointer[OrderList]
}

func (pl *PriceLevel) AddQuantity(qty int64) int64 {
    return pl.quantity.Add(qty)
}

// Aligned to 64-byte cache line to prevent false sharing
type Order struct {
    _        [64]byte // Padding for cache line alignment
    ID       uint64
    Price    int64
    Quantity int64
    Side     uint8
    _        [39]byte // Padding to fill cache line
}

// Bind goroutine to CPU and allocate on local NUMA node
func (e *Engine) StartWorker(cpuID int) {
    runtime.LockOSThread()
    unix.SchedSetaffinity(0, &unix.CPUSet{cpuID: true})

    // All allocations now on local NUMA node
    e.localOrderBook = NewOrderBook()
}

# Full benchmark suite
make bench

# CPU profiling
go test -cpuprofile=cpu.prof -bench=BenchmarkOrderBook ./pkg/lx/
go tool pprof -http=:8080 cpu.prof

# Memory profiling
go test -memprofile=mem.prof -bench=BenchmarkOrderBook ./pkg/lx/
go tool pprof -http=:8081 mem.prof

# Trace analysis
go test -trace=trace.out -bench=BenchmarkOrderBook ./pkg/lx/
go tool trace trace.out

# Linux perf (kernel-level)
perf stat -e cycles,instructions,cache-misses ./lxd --benchmark

# Increase network buffers
sysctl -w net.core.rmem_max=134217728
sysctl -w net.core.wmem_max=134217728
sysctl -w net.ipv4.tcp_rmem="4096 87380 134217728"
sysctl -w net.ipv4.tcp_wmem="4096 87380 134217728"

# Disable Nagle's algorithm
sysctl -w net.ipv4.tcp_nodelay=1

# Enable busy polling
sysctl -w net.core.busy_read=50
sysctl -w net.core.busy_poll=50

# Huge pages (2MB pages reduce TLB misses)
echo 1024 > /proc/sys/vm/nr_hugepages

# Optimal GC settings for low latency
export GOGC=400              # Less frequent GC
export GOMEMLIMIT=8GiB       # Hard memory limit
export GOMAXPROCS=8          # Match physical cores

# Enable memory ballast (reduces GC frequency)
# In code: var ballast = make([]byte, 10<<30) // 10GB ballast

// Critical performance metrics
type Metrics struct {
    OrderLatencyP50  time.Duration `metric:"order_latency_p50"`
    OrderLatencyP99  time.Duration `metric:"order_latency_p99"`
    OrderLatencyP999 time.Duration `metric:"order_latency_p999"`

    MatchThroughput  float64 `metric:"match_throughput_per_sec"`
    OrdersInFlight   int64   `metric:"orders_in_flight"`

    GCPauseP99       time.Duration `metric:"gc_pause_p99"`
    HeapInUse        uint64  `metric:"heap_in_use_bytes"`

    NetworkRTT       time.Duration `metric:"network_rtt_us"`
    TCPRetransmits   int64   `metric:"tcp_retransmits"`
}