Düşük Gecikmeli İşlem Sistemleri için C++

Gecikmeye hassas yığında, C++ hâlâ eşleştirme yolunu elinde tutuyor: Globex tarzı venue'lar, birçok hisse senedi akışı ve kripto motorları (Hyperliquid sınıfı altyapı dahil), ortasında gizli bir GC (çöp toplayıcı) duraklaması olmadan öngörülebilir makine koduna derlenir.

C++'ı düşük gecikmeli işlem için benzersiz şekilde uygun kılan ne?

• Çöp toplayıcı yok — Öngörülemez duraklamalar yok. Belleğin tam olarak ne zaman ayrıldığını ve serbest bırakıldığını kontrol edersin.
• Donanıma yakınlık — CPU önbellek satırlarına, SIMD talimatlarına, bellek eşlemeli G/Ç'ye ve çekirdek atlama ağına doğrudan erişim.
• Derleme zamanı hesaplama — Şablon meta programlama işi çalışma zamanından derleme zamanına taşır, el yazması assembly kadar hızlı kod üretir.
• Öngörülebilir gecikme — Dikkatli kodlamayla, minimal titreşimle mikrosaniyenin altında tick-to-trade gecikmesi elde edebilirsin.

Düşük gecikmeli C++'ta, belleği nasıl ayırdığın, ne hesapladığından daha önemlidir. Yığın (stack) ile öbek (heap) tahsisi arasındaki fark gecikmede 100 kat olabilir.

// Stack allocation — near-instant, deterministic
struct OrderUpdate {
    uint64_t order_id;
    double price;
    uint32_t quantity;
    char side;  // 'B' or 'S'
};

void process_tick(const MarketData& tick) {
    OrderUpdate update{};  // Stack — zero allocation cost
    update.price = tick.mid_price();
    // ... process on the hot path
}

// Heap allocation — slow, non-deterministic (avoid on hot path)
auto* order = new OrderUpdate{};  // Calls malloc — BAD on hot path

Üretim sistemleri özel ayırıcılara yaslanır, böylece sıcak yol genel öbeği asla çağırmaz:

• Havuz ayırıcıları — Büyük bir bloğu önceden ayırır ve sabit boyutlu parçalar oyar. Parçalanma yok, O(1) tahsis.
• Arena ayırıcıları — Her tahsis için bir işaretçiyi ileri iter, her şeyi bir kerede serbest bırakır. Mesaj başına işleme için mükemmel.
• Büyük sayfalar (huge pages) — 2MB veya 1GB sayfalar TLB kaçırmalarını azaltır, emir defteri verilerin megabaytlara yayıldığında kritiktir.

Modern C++, RAII (Kaynak Edinimi Başlatmadır) ve akıllı işaretçilerle güvenli bellek yönetimini ergonomik hâle getirir:

// RAII — resource lifetime tied to scope
{
    auto connection = std::make_unique<TcpConnection>(endpoint);
    connection->send(order_message);
}  // Connection automatically closed here

// Shared ownership for reference-counted resources
auto config = std::make_shared<TradingConfig>(load_config());
engine.set_config(config);  // Multiple owners, automatic cleanup

Mutex'ler düşük gecikmeli kodun düşmanıdır. Tek bir std::mutex::lock() çağrısı çekişme olmasa bile 20-100 nanosaniye sürebilir—ve çekişme altında, bir iş parçacığını mikrosaniyeler boyunca durdurabilir. İşlem sistemleri bunun yerine kilitsiz veri yapıları kullanır.

İşlemdeki en kritik kilitsiz yapı, Tek-Üretici Tek-Tüketici (SPSC) kuyruğudur:

template<typename T, size_t Capacity>
class SPSCQueue {
    alignas(64) std::array<T, Capacity> buffer_;
    alignas(64) std::atomic<size_t> head_{0};
    alignas(64) std::atomic<size_t> tail_{0};

public:
    bool try_push(const T& item) {
        const auto tail = tail_.load(std::memory_order_relaxed);
        const auto next = (tail + 1) % Capacity;
        if (next == head_.load(std::memory_order_acquire))
            return false;  // Full
        buffer_[tail] = item;
        tail_.store(next, std::memory_order_release);
        return true;
    }

    bool try_pop(T& item) {
        const auto head = head_.load(std::memory_order_relaxed);
        if (head == tail_.load(std::memory_order_acquire))
            return false;  // Empty
        item = buffer_[head];
        head_.store((head + 1) % Capacity, std::memory_order_release);
        return true;
    }
};

Anahtar tasarım prensipleri:

• alignas(64) — Her atomik değişken kendi önbellek satırını alır, CPU çekirdekleri arasında yanlış paylaşımı (false sharing) engeller.
• Bellek sıralaması — acquire/release semantiği seq_cst'den daha ucuzdur ve üretici-tüketici örüntüleri için yeterlidir.
• İkinin kuvveti boyutlandırma — Üretimde, modülonun bit düzeyinde bir VE işlemine dönüşmesi için 1024 veya 4096 gibi boyutlar kullan.

Tipik bağlantı: NIC iş parçacığı kuyruğa ekler, strateji iş parçacığı kuyruktan çıkarır—topolojiyi doğru alırsan tel yolunda mutex olmaz.

C++ şablonları işi çalışma zamanından derleme zamanına kaydırmana izin verir. İşlemde bu, ikili dosyanın işlem yaptığın kesin protokoller, enstrümanlar ve stratejiler için özelleştirilmiş olması anlamına gelir—sıcak yolda çalışma zamanı dallanması yoktur.

// Compile-time FIX protocol field parsing
template<int Tag>
struct FIXField;

template<> struct FIXField<35> {  // MsgType
    static constexpr const char* name = "MsgType";
    using type = char;
};

template<> struct FIXField<44> {  // Price
    static constexpr const char* name = "Price";
    using type = double;
};

// Zero-overhead dispatch based on message type
template<char MsgType>
void handle_message(const char* raw, size_t len) {
    if constexpr (MsgType == 'D') {
        // New Order Single — inline at compile time
        parse_new_order(raw, len);
    } else if constexpr (MsgType == '8') {
        // Execution Report
        parse_execution(raw, len);
    }
}

if constexpr dalları tamamen derleme zamanında çözülür—üretilen makine kodu, sıfır dallanma yükü olan sadece ilgili yolu içerir. Bu teknik, bağlantı zamanı optimizasyonu (LTO) ile birleştiğinde, protokol ayrıştırmasının esasen bellek okumaları düz çizgi bir diziye dönüştürüldüğü ikili dosyalar üretir.

Modern C++20/23 özellikleri, consteval, kavramlar ve derleme zamanı konteynerler bunu daha da ileri götürür, tüm emir doğrulama işlem hatlarının derleme zamanında hesaplanmasını sağlar.

Mikrosaniyenin altındaki gecikmelerde, CPU önbellek hiyerarşisi en önemli optimizasyon hedefin hâline gelir. Ana belleğe önbellek kaçırma ~100 nanosaniyeye mal olur—toplam gecikme bütçen 500ns olduğunda bu bir sonsuzluktur.

// BAD: Array of Pointers (AoP) — cache-hostile
std::vector<std::unique_ptr<Order>> orders;  // Each access = pointer chase + cache miss

// GOOD: Struct of Arrays (SoA) — cache-friendly
struct OrderBook {
    std::vector<double> prices;      // Contiguous in memory
    std::vector<uint32_t> quantities; // Contiguous in memory
    std::vector<uint64_t> order_ids;  // Contiguous in memory
};
// Iterating prices = sequential cache line reads = fast

Ağ için, Linux çekirdeğinin TCP/IP yığını paket başına 5-15 mikrosaniye gecikme ekler. İşlem firmaları bunu tamamen atlar:

• DPDK (Data Plane Development Kit) — Çekirdeği atlayarak NIC'i doğrudan kullanıcı alanından sorgular. Mikrosaniyenin altında paket işleme sağlar.
• Solarflare OpenOnload — Bilindik bir soket API'siyle çekirdek atlama. Hisse senedi ve vadeli işlem ticaretinde yoğun kullanılır.
• FPGA NIC'leri — Xilinx Alveo ve benzeri kartlar piyasa verisini donanımda ayrıştırıp emir üretebilir, nanosaniye düzeyinde gecikmeler elde eder.

Merkeziyetsiz borsalar bile bu prensiplerden faydalanır. GaiaEx gibi platformları güçlendiren Hyperliquid'in L1 zinciri—yüksek verimli, düşük gecikmeli uzlaşı düşünülerek tasarlandı, ve ona bağlanan piyasa yapıcılar bir fiyat güncellemesi almak ile bir emir göndermek arasındaki zamanı en aza indirmek için optimize edilmiş C++ istemcileri kullanır.

Her borsanın kalbinde eşleştirme motoru oturur—alış ve satış emirlerini eşleştiren bileşen. Finansın tamamındaki en gecikmeye hassas yazılım parçasıdır ve neredeyse her zaman C++'ta yazılır.

Basitleştirilmiş bir eşleştirme motoru mimarisi:

class MatchingEngine {
    // One order book per instrument
    std::unordered_map<Symbol, OrderBook> books_;

    void on_new_order(const Order& order) {
        auto& book = books_[order.symbol];
        auto matches = book.match(order);

        for (const auto& fill : matches) {
            publish_execution(fill);      // To trading firms
            update_market_data(fill);     // To data feed
        }

        if (order.remaining_qty > 0) {
            book.insert(order);           // Rest on the book
        }
    }
};

Üretim eşleştirme motorları bu iskeletin çok ötesinde optimize eder:

• Fiyat-zaman önceliği — Aynı fiyattaki emirler geliş sırasına göre doldurulur, nanosaniye zaman damgalarıyla izlenir.
• Önceden tahsis edilmiş emir havuzları — Eşleştirme sırasında öbek tahsisi yok. Emirler sabit havuzlardan geri dönüştürülür.
• Kilitsiz tasarım — Her enstrümanın defteri özel bir çekirdekte çalışır. Defterler arası kilitleme gerekmez.
• Deterministik tekrar yürütme — Her emir ve eşleşme, düzenleyici uyumluluk ve felaket kurtarma için kalıcı depolamaya kaydedilir.

Bu düzeyde sistemler inşa etmek, C++'ın gerçekten parladığı yerdir. Hiçbir başka ana akım dil, bellek düzeni, iş parçacığı zamanlaması, önbellek davranışı ve ağ G/Ç'si üzerinde—ultra-düşük-gecikmeli mühendisliğin dört sütunu—eş zamanlı kontrol vermez. Bir sonraki borsayı mı inşa ediyorsun, bir piyasa yapıcı olarak birine mi bağlanıyorsun, veya bir prop firmada yürütmeyi mi optimize ediyorsun, C++ sorgusuz kral olarak kalıyor.