Packets, Transactions and Queues: Design Principles for HFT Systems from a Measurement Study of CME Market Data
Analizzando oltre un anno di dati del mercato CME, questo articolo mette in discussione la convenzionale progettazione HFT a thread singolo, dimostrando che mentre un singolo thread è sufficiente per l'elaborazione dei pacchetti in un sotto-periodo, un'architettura a due stadi con thread può ridurre significativamente le code nelle code (queuing tails) causate dai burst di transazioni, a condizione che la divisione accorci lo stadio più lento del sistema.
Articolo originale sotto licenza CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Questa è una spiegazione generata dall'IA dell'articolo qui sotto. Non è stata scritta dagli autori. Per precisione tecnica, consulta l'articolo originale. Leggi il disclaimer completo
Nel mondo del trading ad alta frequenza, dove i computer comprano e vendono azioni in frazioni di secondo, la velocità non è solo un vantaggio; è l'intero gioco. Questi sistemi operano su un presupposto semplice: se riesci a elaborare le informazioni di mercato più velocemente di chiunque altro, puoi trarre profitto da minuscole differenze di prezzo prima che scompaiano. Per fare ciò, gli ingegneri costruiscono software specializzati che ascoltano un flusso costante di dati dai mercati azionari, li decodificano e prendono decisioni in microsecondi. Per anni, il settore ha operato secondo una regola ferrea: mantenere la parte più critica di questo software su un singolo core di un processore. La logica era che spostare i dati tra diversi core, o "thread", fosse troppo lento e rischioso, aggiungendo ritardi che avrebbero rovinato la velocità del sistema. Questo approccio trattava il software come un lavoratore singolo e concentrato che non passa mai un compito a qualcun altro, credendo che qualsiasi interruzione costerebbe più del lavoro stesso.
Tuttavia, questa convinzione radicata per anni si basava su un'assunzione relativa a come arrivano i dati di mercato: che arrivino come un flusso costante e casuale, come gocce di pioggia che cadono a intervalli imprevedibili. Se ciò fosse vero, l'approccio del singolo lavoratore sarebbe effettivamente il più veloce. Ma cosa succederebbe se i dati non arrivassero in modo casuale? Cosa succederebbe se arrivassero in improvvisi e intensi scoppi, dove migliaia di aggiornamenti colpiscono il sistema in un battito di ciglia? Un nuovo studio di misurazione su dati di mercato reali del Chicago Mercantile Exchange suggerisce che la vecchia regola potrebbe essere errata nei momenti di massima attività. Tracciando miliardi di pacchetti di dati nell'arco di oltre un anno, i ricercatori hanno scoperto che i dati di mercato non arrivano in modo casuale. Al contrario, arrivano in cluster stretti, dove un evento ne scatena una rapida successione di altri, creando un modello "auto-eccitante". Questa scoperta cambia la matematica della velocità. Risulta che, quando i dati arrivano in questi scoppi specifici e raggruppati, dividere il lavoro tra più processori può effettivamente rendere il sistema più veloce e affidabile, a condizione che il sistema sia progettato per gestire correttamente il ritmo degli scoppi.
I ricercatori hanno iniziato esaminando il flusso di dati grezzi mentre viaggia dal motore di abbinamento (matching engine) dell'exchange, dove vengono elaborati gli ordini, verso i computer dei trader. Hanno seguito ogni singolo pacchetto di dati, annotando esattamente quando lasciava l'exchange e quando arrivava. Hanno scoperto che il sistema dell'exchange agisce come un guardiano con un limite di velocità fisso. Anche quando il motore di abbinamento elabora gli ordini incredibilmente velocemente — a volte entro una frazione di un microsecondo l'uno dall'altro — l'editore di dati dell'exchange non può inviarli tutti insieme. Li invia uno alla volta, con un intervallo minimo di circa 7,5 microsecondi tra ogni pacchetto. Ciò crea un treno di pacchetti di dati che arrivano al computer del trader con una spaziatura costante e ritmica, indipendentemente da quanto fosse caotica l'attività alla fonte.
Questo arrivo ritmico è la chiave delle nuove scoperte. I ricercatori hanno costruito una simulazione al computer per testare come diversi design di software gestirebbero questo specifico ritmo. Hanno confrontato l'approccio tradizionale a thread singolo, in cui un processore svolge tutto il lavoro, con una pipeline a più stadi, in cui il lavoro è suddiviso tra diversi processori che lavorano in sequenza. Nella loro simulazione, hanno alimentato il sistema con la tempistica esatta dei pacchetti di dati reali. I risultati sono stati chiari: per i compiti che richiedono più del gap di 7,5 microsecondi tra i pacchetti, l'approccio a thread singolo crea un enorme arretrato. Quando arriva un'ondata di dati, il singolo processore viene sopraffatto e il ritardo per gli ultimi pacchetti del burst cresce fino a essere decine di volte superiore al compito stesso. Questo ritardo è la "coda" che i trader temono, poiché significa che le loro decisioni vengono prese troppo tardi.
Al contrario, la pipeline a più stadi ha gestito questi scoppi con facilità. Dividendo il lavoro, il sistema poteva elaborare il treno di pacchetti in entrata in parallelo. Mentre il primo processore stava decodificando il primo pacchetto, il secondo stava già lavorando sul secondo, e così via. Ciò ha permesso al sistema di smaltire l'arretrato molto più velocemente, mantenendo basso e costante il ritardo per ogni pacchetto. La simulazione ha mostrato che per compiti che durano 16 microsecondi o più, la divisione del lavoro riduce i ritardi massimi di un fattore di dieci o più, con solo una minima penalità per i momenti tipici, non carichi di burst. I ricercatori hanno confermato che questo miglioramento non era dovuto al mero volume di dati, ma specificamente alla natura raggruppata e a scatti (bursty) dei tempi di arrivo. Quando hanno simulato la stessa quantità di dati che arrivavano casualmente, il sistema multi-stadio non offriva alcun vantaggio, e il sistema a thread singolo rimaneva efficiente.
Lo studio ha anche escluso altre potenziali cause dei ritardi. Hanno scoperto che la dimensione dei pacchetti di dati o il numero di messaggi al loro interno non erano i motori primari del rallentamento. Anche quando hanno riorganizzato i dati per rimuovere i burst mantenendo lo stesso numero di pacchetti, i ritardi massicci sono scomparsi. Ciò ha dimostrato che il problema riguardava puramente la tempistica degli arrivi. I ricercatori hanno anche esaminato l'exchange stesso per capire perché i dati arrivassero in questi cluster. Hanno scoperto che il motore di abbinamento dell'exchange spesso elabora più ordini quasi simultaneamente, probabilmente perché molti trader stanno reagendo allo stesso evento di mercato contemporaneamente. Tuttavia, l'editore dell'exchange poi li spaziata, creando il treno ritmico che i sistemi dei trader devono gestire.
Per i progettisti di questi sistemi di trading, il documento offre una guida chiara e basata sui dati. Se il tempo di elaborazione di un sistema è inferiore al gap di 7,5 microsecondi tra i pacchetti, la vecchia regola si applica ancora: mantenerlo su un singolo thread. Non c'è beneficio nel dividere il lavoro, e si aggiunge solo complessità non necessaria. Ma se il tempo di elaborazione è superiore a quel gap, l'approccio a thread singolo fallirà durante i burst, e il sistema dovrebbe essere diviso in più stadi. I ricercatori sottolineano che l'obiettivo non è usare quanti più processori possibile, ma garantire che la parte più lenta del processo sia abbastanza veloce da tenere il passo con il ritmo dell'exchange. Hanno anche scoperto che la specifica disposizione dei processori conta meno che garantire che lo stadio più lento sia gestito in modo efficiente.
Questo lavoro non pretende di aver risolto ogni problema nel trading ad alta velocità, né suggerisce che l'approccio a thread singolo sia obsoleto. Semplicemente fornisce una misurazione precisa di quando tale approccio smette di funzionare e quando diventa necessario un design diverso. Misurando il mondo reale piuttosto che affidarsi a modelli teorici, i ricercatori hanno fornito agli ingegneri una soglia concreta rispetto a cui misurarsi. Hanno dimostrato che la natura del flusso di dati — specificamente la sua tendenza ad arrivare in scoppi auto-eccitanti — detta il modo migliore per costruire il software che lo consuma. La lezione è che nel mondo della finanza ad alta velocità, comprendere il ritmo dei dati è importante quanto la velocità del computer.
Sommerso dagli articoli nel tuo campo?
Ricevi digest giornalieri degli articoli più recenti corrispondenti alle tue parole chiave di ricerca — con riassunti tecnici, nella tua lingua.