StratCraftStratCraftDeutsch
← NexusFIX/Benchmarks
NexusFIX
Abschnitte
Reproduzieren
Ressourcen
Benchmarks · v1.8 · Mai 2026

Performance-Benchmarks.

Gemessene Ergebnisse, keine Marketing-Behauptungen. Alle Benchmarks auf Linux mit GCC 13.3, 100.000 Iterationen, CPU-gebunden.

ExecutionReport-Parsing
246 ns
QuickFIX 730 ns3,0x schneller
Durchsatz
4,17M Msg/Sek.
QuickFIX 1,19M Msg/Sek.3,5x höher
P99-Latenz
258 ns
QuickFIX 784 ns3,0x niedriger
Heap-Allokationen / Nachricht
0
QuickFIX ~12 (std::string, std::map-Knoten)Arena-Wiederverwendung

NexusFIX vs. QuickFIX.

Direktvergleich der wichtigsten FIX-Operationen.

Metrik
QuickFIX
NexusFIX
Verbesserung
ExecutionReport-Parsing
730 ns
246 ns
3,0x schneller
NewOrderSingle-Parsing
661 ns
229 ns
2,9x schneller
Feldzugriff (4 Felder)
31 ns
11 ns
2,9x schneller
Durchsatz
1,19M Msg/Sek.
4,17M Msg/Sek.
3,5x höher
P99-Latenz
784 ns
258 ns
3,0x niedriger

Optimierungsreise.

Von 730ns auf 246ns in vier aufeinander aufbauenden Phasen.

200 ns400 ns600 ns730 nsBaselineBASELINE520 ns−210PHASE 1380 ns−140PHASE 2290 ns−90PHASE 3246 ns−44PHASE 4GESAMT · -484NS · 3.0× SCHNELLER
1 Phase 1: Zero-Copy-Parsing
730ns → 520ns

std::string-Kopien durch std::span<const char>-Ansichten in den Originalpuffer ersetzt. Ein std::span ist 16 Bytes auf dem Stack. Kein Heap, keine Kopie, kein Destruktor.

2 Phase 2: O(1)-Feldzugriff
520ns → 380ns

std::map<int, std::string> durch ein vorindiziertes Array ersetzt. Feldzugriff wird zu einem einzigen mov-Befehl, indiziert durch die FIX-Tag-Nummer.

3 Phase 3: SIMD-Trennzeichen-Scanning
380ns → 290ns

AVX2-vektorisiertes SOH-Trennzeichen-Scanning verarbeitet 32 Bytes pro Zyklus. ~13x schneller als Byte-für-Byte-Scanning.

4 Phase 4: Compile-Time-Offsets
290ns → 246ns

consteval-Feld-Offset-Tabellen und 22 Compile-Time-Lookup-Tabellen eliminieren ~300 Laufzeit-Branches für Enum-/Typ-Konvertierung.

Null-Allokations-Nachweis.

Verarbeitung einer NewOrderSingle-Nachricht auf dem Hot Path.

QuickFIX /order-flow Hot-Path
~12 Heap-Allokationen
Heap-Allokationen
~12 (std::string, std::map-Knoten)
Feldspeicherung
std::map<int, std::string>-Kopien
Parsing-Logik
Laufzeit-Map-Einfügung
Speicher-Footprint
Dynamisch, unvorhersehbar
Destruktor-Overhead
~12 std::string-Destruktoren
HEAP · pro Nachricht12 Allokationen
0x7f3a..0000verstreut
NexusFIX /order-flow Hot-Path
0 Allokationen · Arena-Wiederverwendung
Heap-Allokationen
0
Feldspeicherung
std::span-Ansichten in den Originalpuffer
Parsing-Logik
Compile-Time-Offset-Tabelle
Speicher-Footprint
Statisch, vorab allozierter PMR-Pool
Destruktor-Overhead
0 (kein eigener Speicher)
ARENA · pro Nachricht0 Allokationen
0x0001..a000zusammenhängend · wiederverwendet

Technikvergleich.

Designentscheidungen, die sich zu 3x Performance summieren.

TechnikQuickFIXNexusFIX
SpeicherHeap-Allokation pro NachrichtZero-Copy-std::span-Ansichten
FeldzugriffO(log n) std::mapO(1) direktes Array-Indexing
ParsingByte-für-Byte-ScanningAVX2 SIMD vektorisiert
Feld-OffsetsLaufzeitberechnungconsteval Compile-Time
Enum-KonvertierungLaufzeit-Switch (~300 Branches)22 Compile-Time-Lookup-Tabellen
FehlerbehandlungAusnahmenstd::expected (kein Throw)

Architektur-Einflüsse.

11 führende Bibliotheken untersucht. Was wir gelernt, gebaut und gemessen haben.

hffix
Was wir gelernt haben

O(n)-Iterator-Lookup ist für dichte FIX-Pakete suboptimal

Was wir gebaut haben

consteval-Feld-Offsets + O(1)-Direktindizierung

14ns Feldzugriff
Ergebnis
Abseil
Was wir gelernt haben

Swiss Tables mit SIMD-Probing und H2-Fingerprints

Was wir gebaut haben

absl::flat_hash_map für Session-Store

31% schnellere Lookups
Ergebnis
Quill
Was wir gelernt haben

Lock-free SPSC-Queue mit verzögerter Formatierung

Was wir gebaut haben

Quill als Logging-Backend

8ns mediane Log-Latenz
Ergebnis
NanoLog
Was wir gelernt haben

Binäre Kodierung + Hintergrund-Thread für 7ns Logging

Was wir gebaut haben

DeferredProcessor<T> mit statischer Binär-Serialisierung

84% Reduktion (75→12ns)
Ergebnis
liburing
Was wir gelernt haben

DEFER_TASKRUN eliminiert Kernel-Task-Aufweckungen

Was wir gebaut haben

io_uring + registrierte Puffer + Multishot

7-27% schnelleres I/O
Ergebnis
Highway
Was wir gelernt haben

Portable SIMD-Abstraktion über Befehlssätze hinweg

Was wir gebaut haben

Handoptimierte Intrinsics für FIX-Muster beibehalten

13x Durchsatz
Ergebnis
Seastar
Was wir gelernt haben

Share-nothing-Reaktor für hochgradig paralleles I/O

Was wir gebaut haben

Core-Pinning + Lock-free-Pipelining

8% P99-Verbesserung
Ergebnis
Folly
Was wir gelernt haben

Fortgeschrittenes Memory-Fencing und Lock-free-Primitive

Was wir gebaut haben

Natives SPSC-Queue + Bit-Masking-Validierung

Null Abhängigkeit
Ergebnis
Rigtorp
Was wir gelernt haben

Cache-Line-Padding eliminiert False Sharing

Was wir gebaut haben

Natives SPSCQueue mit identischen Techniken

88M ops/sec, 11ns
Ergebnis
xsimd
Was wir gelernt haben

Generische SIMD-Wrapper für mathematische Operationen

Was wir gebaut haben

Direkte Intel-Intrinsics für SOH-Scanning

2x schneller als Wrapper
Ergebnis
Boost.PMR
Was wir gelernt haben

Monotonischer Puffer ermöglicht Arena-Allokation pro Nachricht

Was wir gebaut haben

std::pmr::monotonic_buffer_resource

Null Heap-Allokation
Ergebnis

Bereit, NexusFIX auszuprobieren?

Drei Befehle zum Bauen und Ausführen der Benchmarks.

Auf GitHub markieren ← Übersicht
~/dev. Bench
$ git clone https://github.com/StratCraftsAI/NexusFix.git
$ cd NexusFix
$ ./start.sh build # 2m18s · release
$ ./start.sh bench
  running 100,000 iterations · cpu pinned · warm cache
  ExecutionReport parse   246 ns   p99 258 ns
  NewOrderSingle parse    229 ns   p99 241 ns
  field_access            11 ns
  throughput              4.17 M msg/s
  ✓ csv written to ./out/bench-2026-05-17.csv