Network Protocols & Market Data

Last week you built the pipeline inside your process and treated “a tick arrived” as given. Something put those bytes on your socket first, and that something made three decisions you now have to understand: which transport carries the feed, what encoding the fields are in, and how you find out that you missed a message. Get the third one wrong and your book is silently, profitably wrong — for someone else.

• Choose between TCP, UDP unicast and UDP multicast for a feed and for order entry, and defend both choices with the loss and fan-out numbers.
• Read an ITCH-style binary message, a FIX tag=value message and a JSON message of the same order, and state the bytes and the nanoseconds for each.
• Detect a sequence gap and run the snapshot-plus-replay recovery without ever trading a stale book.
• Write a single-pass, zero-allocation FIX parser, and say what be64toh is for.

1What is it? Three delivery models, three failure modes

A market-data feed and an order session want opposite things. The feed wants the newest bytes at the lowest latency to the largest number of subscribers, and it can survive losing one. The order session must never lose a message and only ever talks to one counterparty. That is the whole reason real venues ship market data over UDP multicast and order entry over TCP. Pick a model and turn up the loss.

2How does it work? Bytes, fields, checksums, gaps

One order — buy 100 AAPL at 185.50 — in three encodings. Same information, wildly different cost to put on a wire and take off it. Race them.

—

Click a bar to inspect that encoding. The decode numbers are for extracting all five fields into a struct on one ~3 GHz core: a pointer cast plus two byte-swaps for binary, a single forward scan with hand-rolled digit maths for FIX, and a general DOM build for JSON. Nothing here is a library benchmark — it is the shape of the work each encoding forces on you.

a · Step through a FIX message

FIX is tag=value pairs, each terminated by the SOH byte 0x01. It is self-describing and human-readable, and both of those properties cost you nanoseconds: you must scan for =, scan for SOH, and convert ASCII digits to numbers on every single field. Edit the message and step it.

—

// include/fix_parser.hpp — one forward pass, no allocation
while (p < end) {
  int tag = 0;                        // digits up to '='
  while (p < end && *p != '=') {
    if (*p < '0' || *p > '9') return false;
    tag = tag * 10 + (*p++ - '0');
  }
  if (p >= end) return false;      // no '='
  ++p;                               // consume '='
  const char* v = p;                 // value slice
  while (p < end && *p != SOH) ++p;
  const int vlen = static_cast<int>(p - v);
  if (p < end) ++p;                  // consume SOH
  // switch (tag) { case 11: … case 44: … }
}

b · Endianness and fixed-width integers

Binary protocols put the fields at known byte offsets, which only works if everyone agrees on which bytes. Network byte order is big-endian; every x86-64 and every ARM64 you will run on is little-endian. So a binary feed decode is a cast plus a byte swap per multi-byte field — one bswap instruction, about a cycle, and completely non-optional.

#pragma pack(push, 1)
struct AddOrder {          // ITCH-style, 18 bytes
  std::uint8_t  msg_type;   // 'A'          off 0
  std::uint64_t order_id;   // big-endian   off 1
  std::uint8_t  side;       // 'B' / 'S'    off 9
  std::uint32_t qty;        //              off 10
  std::uint32_t price;      // scaled ×1e4  off 14
};
#pragma pack(pop)
static_assert(sizeof(AddOrder) == 18);

c · Sequence numbers, gap detection and recovery

Multicast has no retransmit, so the sequence number is the only thing that tells you a message existed. The feed handler keeps one integer — the next expected sequence — and every arriving message either matches it, is a duplicate, or proves a gap. Step the stream.

—

The discipline that matters: a gap makes the book untradeable until recovery completes. Not degraded, not probably-fine — untradeable. A feed handler that keeps applying increments across a hole produces a book that diverges silently from the venue's and looks perfectly healthy in every log you have.

3Why it matters: the arena's wire, and whose clock you trust

The arena speaks JSON over WebSocket — a discriminated union keyed on a type field, defined in shared/messages.py. It is convenient, it is what the Python bots speak, and it is the opposite of everything a real venue does. Knowing exactly what it costs you is the point of this section, because next session you will cut that cost.

—

Timestamps and whose clock you trust

Every message you receive carries a venue timestamp, and you will stamp your own on arrival. The difference is what you call latency — which means your latency measurement is only as good as the agreement between two clocks. Drag the skew and watch the measurement lie.

4Five ways this goes wrong

Four of these five are silent. Open them.

5Check yourself

Three questions, instant feedback, nothing recorded.

6Do the work