Rust में जटिल आर्बिट्रेज एग्जीक्यूशन: नैनोसेकंड से एटॉमिक मल्टी-लेग तक

"फ्यूचर्स और स्पॉट के बीच जटिल आर्बिट्रेज चेन" सीरीज़ का भाग 6

एक साथ पाँच एक्सचेंजों के ऑर्केस्ट्रा का संचालन करते एक कंडक्टर की कल्पना कीजिए। हर वाद्य यंत्र अपना हिस्सा बजाता है, और पहले सुर से आखिरी सुर तक कुछ मिलीसेकंड से ज़्यादा का अंतर नहीं होना चाहिए। एक गलत सुर—और एक आर्बिट्रेज अवसर घाटे में बदल जाता है: एक एक्सचेंज पर एक लेग फिल हुआ और दूसरे पर कीमत गायब हो गई।

यह "फ्यूचर्स और स्पॉट के बीच जटिल आर्बिट्रेज चेन" सीरीज़ का छठा भाग है, और यह सबसे व्यावहारिक है। हम बाइट्स, कैश लाइनों और एटॉमिक ऑपरेशंस के स्तर तक उतरते हैं।

मल्टी-लेग आर्बिट्रेज के लिए अल्ट्रा-लो-लेटेंसी एग्जीक्यूशन सिस्टम की आर्किटेक्चर: मार्केट डेटा प्राप्त करने से लेकर 1-4 ms में ऑर्डर सबमिशन तक।

1. लेटेंसी ऑप्टिमाइज़ेशन: कर्नल से परे

सब-मिलीसेकंड सटीकता हासिल करने के लिए, हमें पारंपरिक बॉटलनेक को बायपास करना होगा।

1.1 io_uring और नेटवर्क बायपासिंग

io_uring यूज़र-स्पेस और कर्नल के बीच शेयर्ड-मेमोरी रिंग्स के ज़रिए असिंक्रोनस I/O प्रदान करता है। डिफ़ॉल्ट मोड में ऑपरेशंस के पूरे बैच (जैसे कई WebSockets से पढ़ना) के लिए केवल एक io_uring_enter सिस्टम कॉल लगता है; स्थिर अवस्था में ज़ीरो सिस्टम कॉल केवल IORING_SETUP_SQPOLL मोड में मिलते हैं, जहाँ एक कर्नल थ्रेड सबमिशन क्यू को पोल करता है (sq_thread_idle के बाद वह सो जाता है और उसे सिस्टम कॉल से जगाना पड़ता है)। ध्यान दें: io_uring नेटवर्क कर्नल बायपास नहीं है, पैकेट अब भी कर्नल के TCP/IP स्टैक से गुज़रते हैं। असली बायपास के लिए DPDK, AF_XDP या Solarflare ef_vi चाहिए।

use io_uring::IoUring;

struct UringReader {
    ring: IoUring,
    buffers: Vec<Vec<u8>>, // Pre-allocated buffers: one per exchange
}

1.2 simd-json और ज़ीरो-कॉपी डिसीरियलाइज़ेशन

अधिकांश एक्सचेंज JSON का उपयोग करते हैं। simd-json पैरेलल पार्सिंग के लिए SIMD इंस्ट्रक्शंस का उपयोग करता है, जो स्टैंडर्ड पार्सर्स की तुलना में 2-4x तेज़ी प्रदान करता है।

2. लॉक-फ्री ऑर्डर बुक: कोई म्यूटेक्स नहीं

एक HFT वातावरण में, ऑर्डर बुक पर Mutex एक बड़ा बॉटलनेक है। हम बिना लॉक के $O(\log n)$ सर्च के लिए crossbeam-skiplist का उपयोग करते हैं:

use std::sync::atomic::{AtomicU64, Ordering};
use crossbeam_skiplist::SkipMap;

struct PriceLevel {
    price: AtomicU64,
    total_qty: AtomicU64,
}

struct LockFreeOrderBook {
    bids: SkipMap<Reverse<u64>, PriceLevel>,
    asks: SkipMap<u64, PriceLevel>,
}

3. LMAX Disruptor: एक लॉक-फ्री रिंग बफर

64 बाइट्स की कैश-लाइन एलाइनमेंट के साथ पहले से एलोकेटेड एक रिंग बफर एग्जीक्यूशन पाइपलाइन का दिल है। यह मार्केट डेटा को OrderBook Updater, Strategy Engine, और Risk Monitor से होकर बिना किसी कॉपी के समानांतर रूप से प्रवाहित होने देता है।

4. स्लिपेज मॉडलिंग: निश्चितता की परतें

हम स्लिपेज को तीन परतों का उपयोग करके मॉडल करते हैं:

1. इंस्टेंट LOB विश्लेषण: लिमिट ऑर्डर बुक का रीयल-टाइम विश्लेषण (माइक्रोसेकंड)।
2. काइल का लैम्ब्डा: ऑर्डर फ्लो की प्रति यूनिट प्राइस इम्पैक्ट (मिलीसेकंड)।
3. अमीहुद ILLIQ: दीर्घकालिक लिक्विडिटी मॉनिटरिंग (दिन)।

5. स्यूडो-एटॉमिक मल्टी-लेग एग्जीक्यूशन: टाइप-स्टेट पैटर्न

मल्टी-लेग आर्बिट्रेज स्ट्रैटेजी कभी भी सच में एटॉमिक नहीं होती: एक लेग फिल हो सकता है जबकि बाकी विफल हो जाएं। हम केवल "सब या अनवाइंड" वाला स्यूडो-एटॉमिक एग्जीक्यूशन हासिल कर सकते हैं: या तो सभी लेग फिल होते हैं, या फिल हो चुके लेग वापस अनवाइंड किए जाते हैं। हम Rust के Type-State Pattern का उपयोग करते हैं ताकि अमान्य स्टेट ट्रांज़िशन कंपाइल-टाइम पर ही एरर बन जाएं।

// States as types. Invalid transitions won't compile.
struct Idle;
struct Validating;
struct ExecutingLeg;
struct FullyFilled;
struct RollingBack;

struct Execution<State> {
    trade_id: u64,
    legs: Vec<TradeLeg>,
    _state: PhantomData<State>,
}

6. रिस्क मैनेजमेंट: किल स्विच और सर्किट ब्रेकर

एक तीन-स्तरीय सर्किट ब्रेकर सिस्टम को विनाशकारी बाज़ार गतिविधियों से बचाता है:

1. Paused: स्थानीय वोलैटिलिटी स्पाइक्स के लिए 5-मिनट का पॉज़।
2. Halted: 1-घंटे की बड़ी गिरावट के लिए 15-मिनट का हॉल्ट।
3. Shutdown: अगर BTC 24 घंटे में 20% गिरता है तो सिस्टम का पूर्ण शटडाउन।

7. परफॉर्मेंस बजट

ऑप्टिमाइज़्ड Rust कोड के साथ, हमारा लेटेंसी बजट इस तरह दिखता है:

• Network In (AWS ap-northeast-1): 0.5 - 2 ms
• Parsing/OrderBook: 2 - 10 μs
• Strategy/Risk: 5 - 15 μs
• Network Out: 0.5 - 2 ms कुल: 1 - 4 ms

निष्कर्ष

जटिल आर्बिट्रेज एग्जीक्यूशन के लिए Rust एक बेहतरीन भाषा है। यह C++ जैसा लो-लेवल कंट्रोल देती है, साथ ही वित्तीय सिस्टम्स के लिए ज़रूरी सुरक्षा गारंटी भी।

इसके साथ हमारी "जटिल आर्बिट्रेज चेन" सीरीज़ समाप्त होती है। ग्राफ एल्गोरिदम और कोप्युलस से लेकर मशीन लर्निंग और नैनोसेकंड एग्जीक्यूशन तक, अब आपके पास एक प्रोफेशनल-ग्रेड क्रिप्टोकरेंसी आर्बिट्रेज सिस्टम बनाने का पूरा ब्लूप्रिंट है।

---

बड़े पैमाने पर एग्जीक्यूट करने के लिए तैयार हैं? हमारे GitHub पर HFT Execution Engine को क्लोन करें।