Nanosecond C++: Mastering Low-Latency Patterns for High-Frequency Trading - Couverture souple

C. Miller, Luis

Couverture souple

ISBN 13 : 9798273430525

Editeur : Independently published, 2025

Synopsis

You write fast C++ code. You're an expert in performance, and your applications are optimized.

But in the world of High-Frequency Trading (HFT), the "fast" C++ you know is not fast enough. The millisecond is an eternity. The microsecond is a liability. In this world, the race is won and lost in nanoseconds.

This is not a book about "best practices." It's a book about necessary practices. This is your playbook for the brutal, nanosecond-level arms race where "fast enough" gets you run over. In this world, the C++ abstractions you love—std::map, virtual functions, and even std::shared_ptr—are high-latency liabilities.

"Nanosecond C++" is a deep dive into the raw, mechanical-sympathy mindset required to build systems that operate at the absolute limits of physics and hardware. It's for the expert C++ developer who is ready to unlearn "convenient" abstractions and master the art of writing code that speaks directly to the silicon.

You will learn to stop programming the CPU and start choreographing it.
Inside this book, you will master:

• The Nanosecond Mindset: Adopt "mechanical sympathy" and learn to see your code not as lines of C++, but as a series of instructions that must perfectly fit the CPU's pipeline and 64-byte cache lines.
• Zero-Cost Metaprogramming: Tame the compiler. Use if constexpr, C++20 Concepts, and constexpr lookup tables to force your logic to execute at compile-time, not runtime.
• Data-Oriented Design (DOD): Leave Object-Oriented patterns behind. Learn why Struct-of-Arrays (SoA) is the key to annihilating cache misses and unlocking the "free" 4x-8x speedup from auto-vectorization.
• The Lock-Free Battlefield: Replace "stop-the-world" mutexes with deterministic, hardware-level atomics. Master the LMAX Disruptor pattern as the blueprint for all core-to-core communication.
• Total Kernel Bypass: Unmask the 10,000-nanosecond lie of recvfrom(). Learn to bypass the OS entirely, memory-map your NIC, and busy-poll for packets in 50 nanoseconds.
• Nanosecond Parsing: Wield SIMD (AVX) intrinsics to parse complex ASCII (FIX) and binary messages in a handful of clock cycles, not thousands.
• Profiling Ground Truth: Stop guessing. Use perf, Hardware Performance Counters, and Google Benchmark to find the exact cache-missing instruction, and read the generated assembly to prove your fix worked.
• Hardware Co-Design: Go beyond C++ and learn how the final nanosecond is gained by bridging your code to FPGAs with High-Level Synthesis (HLS).

This book is for the professional C++ developer who is not satisfied with "fast" and is ready to pursue deterministic. If you are ready to write the most performant C++ of your career, this is your guide.

The race is measured in nanoseconds. Don't show up with millisecond-level code.

Détails de l'édition

• Éditeur: Independently published
• Date d'édition: 2025
• Langue: anglais
• ISBN 13: 9798273430525
• Reliure: Broché
• Nombre de pages: 212
• Coordonnées du fabricant: non disponible
• Personne responsable: non disponible