// BAD: Array of Structures (AoS) — poor cache locality
struct Order {
    double price;       // 8 bytes
    int quantity;        // 4 bytes
    char side;           // 1 byte
    // 3 bytes padding
    std::string symbol;  // 32 bytes — heap allocated!
};
std::vector<Order> orders;  // each order spread across memory

// GOOD: Structure of Arrays (SoA) — cache-friendly
struct Orders {
    std::vector<double> prices;
    std::vector<int> quantities;
    std::vector<char> sides;
    std::vector<uint32_t> symbolIds;  // use IDs instead of strings
};
// When iterating prices, they're contiguous in memory → cache hits

class Arena {
    char* memory;
    size_t offset;
    size_t capacity;
    
public:
    Arena(size_t size) : memory(new char[size]), offset(0), capacity(size) {}
    ~Arena() { delete[] memory; }
    
    void* allocate(size_t bytes, size_t alignment = 8) {
        size_t aligned = (offset + alignment - 1) & ~(alignment - 1);
        if (aligned + bytes > capacity) return nullptr;
        void* ptr = memory + aligned;
        offset = aligned + bytes;
        return ptr;
    }
    
    void reset() { offset = 0; }  // O(1) "free all"
    
    Arena(const Arena&) = delete;
    Arena& operator=(const Arena&) = delete;
};

// Usage:
Arena arena(1024 * 1024);  // 1MB pool
auto* order = new(arena.allocate(sizeof(Order))) Order{};
// No syscall, no locking, O(1) allocation

template<typename T, size_t N>
class ObjectPool {
    union Slot {
        T object;
        Slot* next;
        Slot() {}
        ~Slot() {}
    };
    
    Slot slots[N];
    Slot* free_list;
    
public:
    ObjectPool() {
        free_list = &slots[0];
        for (size_t i = 0; i < N - 1; ++i)
            slots[i].next = &slots[i + 1];
        slots[N - 1].next = nullptr;
    }
    
    template<typename... Args>
    T* allocate(Args&&... args) {
        if (!free_list) return nullptr;
        Slot* slot = free_list;
        free_list = slot->next;
        return new(&slot->object) T(std::forward<Args>(args)...);
    }
    
    void deallocate(T* obj) {
        obj->~T();
        auto* slot = reinterpret_cast<Slot*>(obj);
        slot->next = free_list;
        free_list = slot;
    }
};

// SLOW: branch-heavy
int abs_val(int x) {
    if (x < 0) return -x;
    return x;
}

// FAST: branchless
int abs_val(int x) {
    int mask = x >> 31;           // 0 if positive, -1 if negative
    return (x + mask) ^ mask;     // branchless absolute value
}

// SLOW: conditional increment
if (condition) count++;

// FAST: branchless
count += (condition);  // condition is 0 or 1

// GCC/Clang
if (__builtin_expect(error_occurred, 0)) {  // unlikely
    handle_error();
}

// C++20:
if (value > threshold) [[likely]] {
    fast_path();
} else [[unlikely]] {
    slow_path();
}

template<typename T, size_t Capacity>
class SPSCQueue {
    static_assert((Capacity & (Capacity - 1)) == 0, "Capacity must be power of 2");
    
    std::array<T, Capacity> buffer;
    alignas(64) std::atomic<size_t> head{0};  // written by consumer
    alignas(64) std::atomic<size_t> tail{0};  // written by producer
    // alignas(64) prevents false sharing
    
public:
    bool push(const T& item) {
        size_t t = tail.load(std::memory_order_relaxed);
        size_t next = (t + 1) & (Capacity - 1);
        
        if (next == head.load(std::memory_order_acquire))
            return false;  // full
        
        buffer[t] = item;
        tail.store(next, std::memory_order_release);
        return true;
    }
    
    bool pop(T& item) {
        size_t h = head.load(std::memory_order_relaxed);
        
        if (h == tail.load(std::memory_order_acquire))
            return false;  // empty
        
        item = buffer[h];
        head.store((h + 1) & (Capacity - 1), std::memory_order_release);
        return true;
    }
};

template<typename T>
class LockFreeStack {
    struct Node {
        T data;
        Node* next;
    };
    
    std::atomic<Node*> head{nullptr};
    
public:
    void push(T value) {
        Node* new_node = new Node{std::move(value), nullptr};
        new_node->next = head.load(std::memory_order_relaxed);
        
        while (!head.compare_exchange_weak(
            new_node->next, new_node,
            std::memory_order_release,
            std::memory_order_relaxed)) {
            // CAS failed — another thread modified head
            // new_node->next is automatically updated to current head
            // retry
        }
    }
};

// SLOW: frequent I/O — one syscall per message
for (auto& msg : messages) {
    write(fd, msg.data(), msg.size());  // syscall each iteration
}

// FAST: batch I/O — single syscall
std::string batch;
batch.reserve(total_size);
for (auto& msg : messages) {
    batch += msg;
}
write(fd, batch.data(), batch.size());  // single syscall

// FAST: writev for scatter-gather I/O
struct iovec iov[N];
// ... fill iov with pointers and lengths ...
writev(fd, iov, N);  // single syscall, multiple buffers

// HOT PATH: busy-wait (spins, uses CPU, but zero latency)
while (!data_ready.load(std::memory_order_acquire)) {
    // spin — CPU core dedicated to this
}

// COLD PATH: sleep (yields CPU, higher latency)
while (!data_ready.load(std::memory_order_acquire)) {
    std::this_thread::yield();
}

#include <pthread.h>

void pin_thread_to_core(int core_id) {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(core_id, &cpuset);
    pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
}

pin_thread_to_core(2);  // pin trading thread to core 2

#include <numa.h>
void* ptr = numa_alloc_onnode(size, numa_node_of_cpu(sched_getcpu()));

[[gnu::hot]] void process_order(Order& order) {
    // Compiler optimizes this more aggressively
}

[[gnu::cold]] void handle_error(int code) {
    // Compiler moves this to cold section (less cache pressure on hot code)
}

void do_not_optimize(auto& value) {
    asm volatile("" : : "r,m"(value) : "memory");
}

#include <immintrin.h>

// Add 8 floats at once (AVX)
void add_arrays(float* a, float* b, float* result, int n) {
    for (int i = 0; i < n; i += 8) {
        __m256 va = _mm256_loadu_ps(a + i);
        __m256 vb = _mm256_loadu_ps(b + i);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_storeu_ps(result + i, vc);
    }
}
// 8x throughput for floating-point operations!

#include <chrono>

auto start = std::chrono::high_resolution_clock::now();
// ... code to benchmark ...
auto end = std::chrono::high_resolution_clock::now();

auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
std::cout << duration.count() << " ns\n";

inline uint64_t rdtsc() {
    unsigned int lo, hi;
    __asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi));
    return ((uint64_t)hi << 32) | lo;
}

uint64_t start = rdtsc();
// ... hot path code ...
uint64_t cycles = rdtsc() - start;
// At 3GHz: 1 cycle ≈ 0.33ns