# FPGA Tick-to-Trade Cut-Through MAC & PCS Latency Budgets

> Decompose sub-200ns FPGA tick-to-trade pipelines across AMD Virtex UltraScale+ GTY SerDes, 64b/66b PCS, cut-through Ethernet MAC, and pre-staged TCP SBE.

Canonical: https://terminalledgerdesk.com/reports/fpga-tick-to-trade-cut-through-mac-pcs-transceiver-pipeline-budgets
Last updated: 2026-11-14T19:50:29.280Z

**Publication:** Terminal Ledger Desk
**Category:** Matching Engine Clob Colocation Ptp
**Published:** 2026-11-14T06:15:25.915Z
**Author:** Marcus Thorne, CQF (Certificate in Quantitative Finance (CQF), Low-Latency FIX & Matching Engine Architect)
**Reviewer:** Not recorded

## Answer-first summary

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.

## Key takeaways

- Custom cut-through Verilog/SystemVerilog pipelines on 25GbE UltraScale+ / Agilex FPGAs achieve ~138 ns wire-to-wire with ±3.1 ns p99.99 jitter.
- Speculative TX with deliberate outbound CRC-32 poisoning lets an FPGA begin transmitting an order mid-packet while guaranteeing corrupt RX packets never execute.
- Keep complex pricing and TCP recovery in C++ on the host CPU while pre-staging ready-to-fire binary TCP frames and risk bounds inside FPGA BRAM.
- Ensure outbound frame length exceeds remaining inbound post-price bytes (or pad IP options) so the inbound FCS verdict always arrives before outbound FCS commits.

## Related financial entities

- **CME Aurora Financial Data Center Standard** (CME-AURORA) — product: Dedicated CME Group hosting facility in Aurora, Illinois, housing the Globex matching engine and offering direct low-latency colocation to clearing members.
- **Electronic Trading Pre-Trade Risk Standard (FIA / CFTC)** (PRE-RISK) — product: Industry benchmark and regulatory requirement mandating automated pre-trade risk checks to prevent erroneous orders and systemic flash crashes.
- **Equinix Financial Exchange Infrastructure (LD4/NY4/TY3)** (EQUINIX-FIN) — product: World-leading interconnected financial data centers housing hundreds of liquidity providers, exchanges, and trading engines within unified physical campuses.

## Analysis

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](/engines/cme-aurora-colocation-standard) 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](/api/figure?type=flow&title=Sub-200ns%20Cut-Through%20FPGA%20Tick-to-Trade%20Datapath&subtitle=322.26%20MHz%2064-bit%20streaming%20SBE%2FITCH%20parser%20%2B%20pre-staged%20BRAM%20TCP%20templates%20%2B%20FCS%20stomp%20safety&steps=1.%20GTY%20%2B%20Lean%20PCS%3A%3A25G%20No-FEC%20SerDes%20%2B%2064b%2F66b%20%2826%20ns%29%7C2.%20Stream%20Decode%3A%3AMatch%20SecurityID%20%26%20Price%20at%20byte%2064%7C3.%20BRAM%20Trigger%3A%3ACheck%20Risk%20LUT%20%2B%20load%20pre-built%20TCP%7C4.%20Speculative%20TX%3A%3AStream%20TX%3B%20stomp%20TX-FCS%20if%20RX-CRC%20bad&metrics=WIRE-TO-WIRE%20P50%3A%3A138%20ns%3A%3AInbound%20trigger%20byte%20-%3E%20TX%20bit0%7CJITTER%20%28P99.99%29%3A%3A%C2%B13.1%20ns%3A%3A1%20clock%20cycle%20CDC%20variance!%7CCLOCK%20DOMAIN%3A%3A322.26%20MHz%3A%3A64-bit%20bus%20%40%203.103%20ns%2Fword%7CBAD-CRC%20ESCAPES%3A%3A0%20Packets%3A%3ASpeculative%20FCS%20poison%20gate)

## 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](/engines/pretrade-risk-control-standard)!

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!)

| Pipeline Stage | Stock 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 Sum** | `137 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](/engines/cme-aurora-colocation-standard)) |

## 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
T_fpga_cut_through = T_qsfp_phy + T_rx_pcs + (Byte_Price_End * 8 / R_gbps) + (N_rtl_cycles * T_clk) + T_tx_pcs
Condition_FCS_Safe : (Byte_In_Total - Byte_Price_End) / R_in_gbps <= (Byte_Out_Total - 4) / R_out_gbps

Where (25GbE No-FEC @ 322.26 MHz, T_clk = 3.103 ns):
 T_qsfp_phy = 8 ns; T_rx_pcs = 13 ns; T_tx_pcs = 11 ns
 Byte_Price_End = 64 bytes (20.48 ns from start of frame); N_rtl_cycles = 27 cycles (83.78 ns)

Worked Cut-Through Wire-to-Wire Latency:
 T_fpga_cut_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](/standards/sec) / [CFTC](/standards/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](/reports/solarflare-onload-ef-vi-vs-dpdk-kernel-bypass-nic-rx-tx-ring-tuning) and our [Deterministic Matching Engines & Colocation Guide](/reports/deterministic-matching-engine-clob-colocation-ptp-clock-sync-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](/api/figure?type=bars&title=Hardware%20vs%20Software%20Tick-to-Trade%20Latency%20Breakdown&subtitle=Measured%20wire-to-wire%20on%20passive%20optical%20Arista%207130%20tap%20%28nanoseconds%29&steps=Custom%20RTL%20Cut-Through%20%2B%20Stomp%3A%3A138%20ns%20p50%20%20%20141%20ns%20p99.99%7CCustom%20RTL%20Store-and-Forward%3A%3A265%20ns%20p50%20%20%20269%20ns%20p99.99%7CVitis%20HLS%20%2B%20Vendor%2010G%2F25G%20IP%3A%3A490%20ns%20p50%20%20%20505%20ns%20p99.99%7CTuned%20C%2B%2B20%20%2B%20Solarflare%20ef_vi%3A%3A840%20ns%20p50%20%20%201%2C850%20ns%20p99.99&metrics=P99.99%20ADVANTAGE%3A%3A13.1x%3A%3A141%20ns%20FPGA%20vs%201%2C850%20ns%20C%2B%2B%7CHOST%20ROLE%3A%3APre-Stager%3A%3AUpdates%20BRAM%20quotes%20over%20PCIe%7CINLINE%20COLLARS%3A%3A0%20Extra%20ns%3A%3AEvaluated%20in%20parallel%20LUTs%7CTCP%20CHECKSUM%3A%3A1-Cycle%20Add%3A%3ADelta%20fold%20on%20pre-summed%20hdr)

## 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](/calculators/algorithmic-kelly-allocation-calculator), integrate host management via [FIX API](/software/fix-api), and explore hardware timing in the [Matching Engine, Colocation & PTP Topic Hub](/topics/matching-engine-clob-colocation-ptp).

- [IEEE 1588v2 PTP Clock Synchronization: GNSS Grandmasters, Boundary Clocks & NIC PHC](/reports/ieee-1588v2-ptp-grandmaster-boundary-clock-nic-hardware-timestamps)

## 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.


## Source URLs

- https://docs.amd.com/v/u/en-US/ug578-ultrascale-gty-transceivers
- https://www.cmegroup.com/confluence/display/EPICSANDBOX/CME+Globex+Connectivity
- https://standards.ieee.org/ieee/802.3/10422/

## Citation

- APA: Marcus Thorne, CQF. (2026). 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
- Canonical article: [FPGA Tick-to-Trade Pipelines: Cut-Through PCS/MAC & Sub-200ns Order Triggering](https://terminalledgerdesk.com/reports/fpga-tick-to-trade-cut-through-mac-pcs-transceiver-pipeline-budgets)
- Site research index: [Terminal Ledger Desk](https://terminalledgerdesk.com/llms-full.txt)
