Skip to content
Terminal Ledger Desk
Directory

Matching Engine Clob Colocation Ptp

FPGA Tick-to-Trade Pipelines: Cut-Through PCS/MAC & Sub-200ns Order Triggering

By decoding ITCH/MDP bytes directly off a 322.26 MHz 64-bit AXI-Stream bus as bits arrive from the optical transceiver, cut-through FPGA pipelines fire pre-staged exchange orders in 118 to 195 nanoseconds wire-to-wire.

By Marcus Thorne, CQFReview not recorded
FPGA Tick-to-Trade Pipelines: Cut-Through PCS/MAC & Sub-200ns Order Triggering — Terminal Ledger Desk 2026 quantitative & supervisory data card
Terminal Ledger Desk (Deterministic Matching Engines, NY4/LD4/TY3 Colocation & PTPv2 Clock Sync): Cut-through 64b/66b PCS, 322MHz streaming SBE decode, BRAM order templates, and FCS safety.Source: Terminal Ledger Desk Institutional Research DeskLicense: CC-BY-4.0

Even the fastest ef_vi C++ server must wait for the entire Ethernet frame to finish arriving (store-and-forward), cross a PCIe Gen4/Gen5 root complex (~120 ns each way), and traverse CPU caches—setting a hard software floor around ~650–850 nanoseconds wire-to-wire. Top-decile futures and equities liquidity providers inside CME Aurora and Nasdaq Carteret shatter that PCIe barrier with field-programmable gate arrays (AMD/Xilinx Virtex UltraScale+ VU9P / VU23P and Intel Agilex 7) that evaluate book triggers mid-packet and begin streaming outbound TCP/SBE bytes before the inbound market-data FCS checksum even hits the fiber!

Cycle-by-Cycle Cut-Through Datapath: GTY SerDes -> PCS -> MAC -> Parser#

At 10GbE (10.3125 Gbps 64b/66b line rate), an FPGA internal datapath typically clocks 64 bits (8 bytes) every 6.4 nanoseconds (156.25 MHz)—or 64 bits every 3.103 nanoseconds (322.26 MHz) on 25GbE (No-FEC)! Look at how a custom low-latency Verilog/SystemVerilog pipeline shaves off vendor IP bloat:

  1. Optical SFP28/QSFP28 + GTY SerDes PMA (~24–34 ns RX+TX): Bypasses elastic phase-compensation FIFOs via comma-aligned RXCDR phase locking.
  2. Ultra-Lean 64b/66b PCS + Gearbox (~19–26 ns): Replaces general-purpose Xilinx 10G/25G Ethernet Subsystem (~110 ns RTT) with a custom deterministic descrambler (x^58 + x^39 + 1).
  3. Zero-Buffer Cut-Through MAC (1–2 clock cycles = 3.1–6.4 ns): Streams Eth + IPv4 + UDP + MoldUDP64/MDP headers straight into a streaming state-machine FSM as each 8-byte word arrives!
AMD Virtex UltraScale+ cut-through FPGA tick-to-trade pipeline from QSFP28 GTY SerDes to 64b/66b PCS, streaming SBE decoder, BRAM trigger, and FCS guard
AMD Virtex UltraScale+ cut-through FPGA tick-to-trade pipeline from QSFP28 GTY SerDes to 64b/66b PCS, streaming SBE decoder, BRAM trigger, and FCS guardVerified Exhibit

Speculative Pre-FCS Triggering & Corrupt-Frame FCS Kill-Bit Safety#

Wait—if an outbound OUCH 5.0 or CME iLink 3 order begins transmitting at byte 68 of a 240-byte inbound CME MDP 3.0 packet (saving 172 bytes = 137.6 ns of 10GbE serialization wait!), what happens if byte 239 fails its 32-bit Ethernet Frame Check Sequence (CRC-32) due to a cosmic ray or dirty optical ferrule?! Firing an order on corrupted price bits would violate pre-trade risk control standards!

Hardware engineers use Speculative TX with Deliberate FCS Poisoning: while streaming the outbound 98-byte TCP order (~78.4 ns wire duration), if the inbound packet fails its trailing CRC-32 check before the outbound packet finishes sending its own last 4 bytes, the FPGA inverts the outbound Ethernet CRC-32 (~fcs)! Every exchange Layer-2 switch immediately drops the stomped frame silently at the MAC port—zero bad order ever reaches the matching engine! (Note: if the inbound packet is much longer than the outbound packet, the FPGA inserts dummy IP options/padding or delays TX tail closure until inbound CRC_OK latches!)

Quantitative Distribution · Stock Vendor FPGA IP (Store & Fwd)
Stock Vendor FPGA IP (Store & Fwd)Custom Low-Latency RTL (Cut-Through)
01Optical SFP28 + GTY SerDes …48 ns (Elastic …0264b/66b PCS + MAC Layer (RX…145 ns (Xilinx …03Frame Arrival Wait (200B Pa…160 ns (10G) / …04Parser + Book + Risk + TCP …137 ns (44 HLS …05Total Wire-to-Wire (p99.99)~505 ns
Pipeline StageStock Vendor FPGA IP (Store & Fwd)Custom Low-Latency RTL (Cut-Through)Software ef_vi C++ Equivalent
Optical SFP28 + GTY SerDes (RX+TX)48 ns (Elastic buffer enabled)28 ns (Buffer-bypass CDR)~65 ns (NIC PHY + SerDes)
64b/66b PCS + MAC Layer (RX+TX)145 ns (Xilinx MAC + AXI FIFO)24 ns (Direct 64b gear + 0-FIFO)~490 ns (PCIe Gen4 DMA + CTPIO)
Frame Arrival Wait (200B Packet)160 ns (10G) / 64 ns (25G)0 ns post-price-field!160 ns / 64 ns (Full DMA wait)
Parser + Book + Risk + TCP Sum137 ns (44 HLS cycles)86 ns (28 RTL cycles @ 322MHz)240 – 1,250 ns (CPU L1/L3 jitter)
Total Wire-to-Wire (p99.99)~505 ns~141 ns~1,850 ns (Aurora)

10GbE / 25GbE FPGA Tick-to-Trade Nanosecond Component Budget#

Comparing standard vendor FPGA IP cores against custom low-latency PCS/MAC and speculative pre-staged BRAM order templates.

Formula or model from the articleNot independently verified
T_fpga_cut_through = T_qsfp_phy + T_rx_pcs + (Byte_Price_End * 8 / R_gbps) + (N_rtl_cycles * T_clk) + T_tx_pcs
  • ConditionFCSSafe : (ByteInTotal - BytePriceEnd) / Ringbps <= (ByteOutTotal - 4) / Routgbps
  • Where (25GbE No-FEC @ 322.26 MHz, T_clk = 3.103 ns):
  • Tqsfpphy = 8 ns; Trxpcs = 13 ns; Ttxpcs = 11 ns
  • BytePriceEnd = 64 bytes (20.48 ns from start of frame); Nrtlcycles = 27 cycles (83.78 ns)
  • Worked Cut-Through Wire-to-Wire Latency:
  • Tfpgacut_through = 8 + 13 + 20.48 + 83.78 + 11 = 136.26 nanoseconds!
  • FCS Safety Check : Inbound remaining (140 - 64 = 76B) <= Outbound pre-CRC (108 - 4 = 104B) -> 100% Safe to Stomp!

Host-CPU + FPGA Hybrid Division of Labor: Pre-Staged BRAM Order Templates#

Trying to implement complex options volatility surface fitting, TCP congestion recovery, and FIX session GapFill inside Verilog LUTs creates multi-month synthesis nightmares. Instead, institutional architectures split intelligence cleanly across PCIe:

  • C++ Host CPU (Slow Control Plane — every 50–500 us): Computes theoretical fair values, Greek skews, and SEC / CFTC position limits; writes pre-built binary iLink 3 / OUCH TCP packets (complete with pre-summed partial IPv4/TCP pseudo-header checksums!) into FPGA Block RAM (BRAM) trigger slots (Slot[symbolId] = { triggerBidPx, triggerAskPx, maxOrderQty, rawTcpFrame[96] }).
  • FPGA Fabric (Fast Reflex Plane — 138 ns): Parses SecurityID, updates on-chip BRAM top-of-book, checks inline hardware kill-switch credit registers, patches TCP SeqNum + Timestamp in 1 cycle, and fires—complementing Solarflare ef_vi C++ gateways and our Deterministic Matching Engines & Colocation Guide.
Internal wire-to-wire tick-to-trade latency across C++ ef_vi, HLS FPGA with Xilinx MAC, Custom Verilog Store-and-Forward, and Custom Verilog Cut-Through
Internal wire-to-wire tick-to-trade latency across C++ ef_vi, HLS FPGA with Xilinx MAC, Custom Verilog Store-and-Forward, and Custom Verilog Cut-ThroughVerified Exhibit

Deterministic Zero-Jitter Tail (p99.99 - p50 < 4 Nanoseconds)#

Perhaps the biggest advantage of synchronous RTL over even tuned C++ is zero tail variance: because an FPGA pipeline has no instruction cache, no TLB, no branch predictor, and no SMI interrupts, processing packet #1 and packet #10,000,000 takes the exact same integer number of 3.103-ns clock ticks (p99.99 - p50 = ±3.1 ns clock-domain crossing phase)!

Evaluate capital-efficiency trade-offs of sub-200ns queue capture inside the Algorithmic Kelly Allocation Calculator, integrate host management via FIX API, and explore hardware timing in the Matching Engine, Colocation & PTP Topic Hub.

Frequently asked questions

What happens at the exchange switch when an FPGA poisons the FCS (CRC-32) of a speculative order?

Every IEEE 802.3 Ethernet switch verifies the trailing 32-bit FCS before forwarding a store-and-forward frame to the matching engine. Inverting the FCS causes the exchange ingress MAC to discard the aborted speculative packet silently as a physical layer CRC error—Note: excessive stomps will trigger exchange port monitoring alerts, so only stomp genuine rare corruptions, never normal strategy cancels!

Why must firms never use FCS poisoning as a routine strategy cancellation trick?

Exchanges like CME, Nasdaq, and Eurex strictly forbid intentional FCS corruption to abort valid strategy decisions! Exchange network operations monitor per-port CRC error counters and fine or disconnect ports abusing Layer-2 stomping; FCS poisoning is strictly an electrical/optical bit-error safety guard.

How does an FPGA maintain a live TCP connection to CME iLink 3 or Nasdaq OUCH without a full TCP stack?

In hybrid TCP offload, the Linux/Onload host establishes the TCP handshake, handles heartbeats, and performs rare packet retransmissions, while the FPGA sits inline snooping Sequence/ACK numbers and injecting single pre-templated fast-path orders seamlessly into the TCP byte stream.

Why disable 25GbE Reed-Solomon FEC (Clause 108 RS-FEC) on FPGA colocation links when permitted?

25GbE RS(528,514) FEC accumulates 5,280-bit codewords before correcting burst bit errors, adding ~80–110 ns of mandatory serialization latency. On short, cleanintra-hall OS2 fiber patches (< 150m) where raw BER is < 10^-13, running 25GBASE-R No-FEC eliminates that penalty.

Publication record

Published
14 November 2026
Updated
14 November 2026
Author
Marcus Thorne, CQF
Review
Review not recorded
Automated fact check
Passed in the stored pipeline record
Source URLs
3 recorded

AI assistance recorded: anthropic/claude-opus-4.6. This field does not establish human review or source verification.

Academic & Institutional Attribution

Cite This Research & Embed Live Data Card

Open Attribution License (CC BY 4.0)

Standard academic & institutional research paper citation format.

Marcus Thorne, CQF. (2026, November 14). FPGA Tick-to-Trade Pipelines: Cut-Through PCS/MAC & Sub-200ns Order Triggering. Terminal Ledger Desk. https://terminalledgerdesk.com/reports/fpga-tick-to-trade-cut-through-mac-pcs-transceiver-pipeline-budgets

Regulatory Directory Cross-Reference

Referenced Institutions & Regulatory Registries

Referenced Supervisory Authorities

Explore Matching Engine Clob Colocation Ptp Hub (20) →

Terminal Ledger Desk Data, Benchmarks & Contributor Records

FPGA Tick-to-Trade Cut-Through MAC & PCS Latency Budgets | Terminal Ledger Desk