book

Building Low Latency Applications with C++

Name: Building Low Latency Applications with C++
Author: Sourav Ghosh
ISBN: 9781837639359

by Sourav Ghosh

July 2023

Intermediate to advanced

506 pages

13h 52m

English

Packt Publishing

Read now

Unlock full access

Building Low Latency Applications with C++
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Part 1:Introducing C++ Concepts and Exploring Important Low-Latency Applications
Chapter 1: Introducing Low Latency Application Development in C++
Understanding requirements for latency-sensitive applicationsUnderstanding latency-sensitive versus latency-critical applicationsMeasuring latencyDifferentiating between latency metricsRequirements of latency-sensitive applicationsUnderstanding why C++ is the preferred programming languageCompiled languageCloser to hardware – low-level languageDeterministic usage of resourcesSpeed and high performanceLanguage constructs and featuresMature and large community supportLanguage under active developmentIntroducing some important low latency applicationsLower-level low latency applicationsHigher-level low latency applicationsInternet of Things and machine-to-machine applicationsSummary
Chapter 2: Designing Some Common Low Latency Applications in C++
Understanding low latency performance in live video streaming applicationsDefining important concepts in low latency streamingUnderstanding sources of latency in video streaming applicationsMeasuring latencies in low latency video streamingUnderstanding the impact of high latenciesExploring technologies for low latency video streamingExploring solutions and platforms for low latency streamingUnderstanding what low latency constraints matter in gaming applicationsConcepts in low latency gaming applicationsImproving gaming application performanceDiscussing the design of IoT and retail analytics systemsEnsuring low latency in IoT devicesExploring low latency electronic tradingUnderstanding the need for low latency in modern electronic tradingAchieving the lowest latencies in electronic tradingSummary
Chapter 3: Exploring C++ Concepts from A Low-Latency Application’s Perspective
Technical requirementsApproaching low-latency application development in C++Coding for correctness first, optimizing secondDesigning optimal data structures and algorithmsBeing mindful of the processorUnderstanding the cache and memory access costsUnderstanding how C++ features work under the hoodLeveraging the C++ compilerMeasuring and improving performanceAvoiding pitfalls and leveraging C++ features to minimize application latencyChoosing storageChoosing data typesUsing casting and conversion operationsOptimizing numerical operationsOptimizing boolean and bitwise operationsInitializing, destroying, copying, and moving objectsUsing references and pointersOptimizing jumping and branchingCalling functions efficientlyUsing bitfieldsUsing runtime polymorphismUsing compile-time polymorphismUsing additional compile-time processingHandling exceptionsAccessing cache and memoryDynamically allocating memoryMulti-threadingMaximizing C++ compiler optimization parametersUnderstanding how compilers optimizeUnderstanding when compilers fail to optimizeLearning about compiler optimization flagsSummary
Chapter 4: Building the C++ Building Blocks for Low Latency Applications
Technical requirementsC++ threading for multi-threaded low latency applicationsDefining some useful macros and functionsCreating and launching a new threadSetting thread affinityBuilding an exampleDesigning C++ memory pools to avoid dynamic memory allocationsUnderstanding the definition of a memory poolUnderstanding the use cases of a memory poolDesigning the memory pool storageInitializing the memory poolServing new allocation requestsHandling deallocationsUsing the memory pool with an exampleTransferring data using lock-free queuesCommunicating between threads and processesDesigning lock-free queue storageInitializing the lock-free queueAdding elements to the queueConsuming elements from the queueUsing the lock-free queueBuilding a low latency logging frameworkDesigning utility methods for timeDesigning the low latency loggerDefining some logger structuresInitializing the logger data structuresCreating the logger and launching the logger threadPushing data to the logger queueAdding a useful and generic log functionLearning how to use the logger with an exampleC++ network programming using socketsBuilding a basic socket APIImplementing a sender/receiver TCP socketBuilding a TCP server componentBuilding an example of the TCP server and clientsSummary
Part 2:Building a Live Trading Exchange in C++
Chapter 5: Designing Our Trading Ecosystem
Understanding the layout of the electronic trading ecosystemDefining the topology of the electronic trading ecosystemIntroducing the components of the electronic trading ecosystemDesigning the C++ matching engine in a trading exchangeUnderstanding the purpose of the matching engineUnderstanding the exchange order bookMatching participant ordersDesigning our matching engineUnderstanding how an exchange publishes information to participantsCommunicating market events through markets dataDesigning the market data publisherNotifying market participants through the order gateway interfacesDesigning the order gateway serverBuilding a market participant’s interface to the exchangeUnderstanding the market data consumer infrastructureDesigning the market data consumerUnderstanding the order gateway client infrastructureDesigning the order gateway client infrastructureDesigning a framework for low-latency C++ trading algorithmsBuilding the order bookBuilding a feature engineDeveloping the execution logicUnderstanding the risk management systemsDesigning our trading strategy frameworkSummary
Chapter 6: Building the C++ Matching Engine
Technical requirementsDefining the operations and interactions in our matching engineDefining some types and constantsDesigning the matching engineDesigning the exchange order bookBuilding the matching engine and exchanging external dataBuilding the matching engineConsuming from and publishing to the order gateway queuePublishing to the market data publisher queueBuilding the exchange application binaryRunning the exchange application binaryBuilding the order book and matching ordersBuilding the internal data structuresHandling new passive ordersHandling order cancellation requestsMatching aggressive orders and updating the order bookSummary

Chapter 7: Communicating with Market Participants
Technical requirementsDefining the market data protocol and order data protocolDesigning the market data protocolDesigning the order data protocolBuilding the order gateway serverDefining the data members in the order gateway serverInitializing the order gateway serverHandling incoming client requestsProcessing requests fairly using the FIFO sequencerSending client responsesBuilding the market data publisherDefining the data members in the market data publisherInitializing the market data publisherPublishing order book updatesSynthesizing and publishing snapshotsBuilding the main exchange applicationSummary
Part 3:Building Real-Time C++ Algorithmic Trading Systems
Chapter 8: Processing Market Data and Sending Orders to the Exchange in C++
Technical requirementsSubscribing to market data and decoding the market data protocolDefining the data members in the market data consumerInitializing the market data consumerRunning the market data consumer main loopProcessing market data updates and handling packet dropsSynchronizing with the snapshot streamBuilding order books from market dataDefining the structures for the market order bookDefining the data members in the order bookInitializing the order bookProcessing market updates and updating the order bookRevisiting the generic utility methods for order book managementConnecting to the exchange and sending and receiving order flowDefining the data members in the order gateway clientInitializing the order gateway clientSending order requests to the exchangeProcessing order responses from the exchangeSummary
Chapter 9: Building the C++ Trading Algorithm’s Building Blocks
Technical requirementsReacting to executions and managing positions, PnLs, and riskBuilding the feature and computing complex featuresDefining the data members in the feature engineInitializing the feature engineComputing the feature on order book changesComputing the feature on trade eventsUsing executions to update positions and PnLsDeclaring the data members in PositionInfoHandling order executions in PositionInfoHandling order book changes in PositionInfoDesigning PositionKeeperInitializing PositionKeeperHandling order executions and market updates in PositionKeeperSending and managing ordersDefining the OMOrder struct and its related typesDesigning the OrderManager classDefining the data members in OrderManagerInitializing OrderManagerSending new orders from OrderManagerCancelling orders from OrderManagerAdding methods to simplify order managementHandling order updates and updating ordersComputing and managing riskDefining the RiskCfg structureDefining the TradeEngineCfg structureDeclaring the RiskCheckResult enumerationDefining the RiskInfo structurePerforming risk checks in RiskInfoDesigning the data members in RiskManagerInitializing our RiskManager classPerforming risk checks in RiskManagerSummary
Chapter 10: Building the C++ Market Making and Liquidity Taking Algorithms
Technical requirementsUnderstanding the behavior of our trading algorithmsUnderstanding the market making trading algorithmInspecting market making mechanics with an exampleUnderstanding the liquidity taking trading algorithmAdding an enumeration to define the type of algorithmManaging the passive liquidity provided in the order bookDefining the data members in the MarketMaker algorithmInitializing the MarketMaker algorithmHandling order book updates and trade eventsHandling order updates in the MarketMaker algorithmOpening and closing positions aggressivelyDefining the data members in the LiquidityTaker algorithmInitializing the LiquidityTaker trading algorithmHandling trade events and order book updatesHandling order updates in the LiquidityTaker algorithmBuilding the trade engine frameworkDefining the data members in the trade engineInitializing the trade engineSending client requestsProcessing market data updates and client responsesHandling order book, trade, and order response updatesAdding some miscellaneous methodsBuilding and running the main trading applicationBuilding the main trading applicationRunning the final trading ecosystemInspecting the output of a runSummary
Part 4:Analyzing and Improving Performance
Chapter 11: Adding Instrumentation and Measuring Performance
Technical requirementsAdding an instrumentation system to measure system performanceAdding utilities for performance measurement using RDTSCUpdating our previous time utilitiesUnderstanding some issues with measurement systems in practiceMeasuring latencies at the exchangeMeasuring the latencies inside the market data publisherMeasuring the latencies inside the order serverMeasuring the latencies inside the matching engine and order bookMeasuring latencies in the trading engineMeasuring the latencies inside the market data consumerMeasuring the latencies inside the order gatewayMeasuring the latencies inside the trading engineRunning the entire ecosystem with the new instrumentation systemSummary
Chapter 12: Analyzing and Optimizing the Performance of Our C++ System
Technical requirementsAnalyzing the performance of our trading ecosystemRevisiting the latencies we measureAnalyzing the performanceUnderstanding the output of our analysisDiscussing tips and techniques for optimizing our C++ trading systemOptimizing the release buildSetting thread affinity correctlyOptimizing Logger for stringsEliminating the use of std::function instancesInspecting the impact of these optimizationsThinking about the future of our trading ecosystemGrowing containers dynamicallyGrowing and enhancing the hash mapsOptimizing snapshot messagesAdding authentication and rejection messages to the Order protocolSupporting modify messages in the Order protocolEnhancing trade engine componentsSummary
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Overview

Building Low Latency Applications with C++ is your ultimate guide to mastering the development of high-performance, low-latency systems. You will gain a solid understanding of how to construct each component of a low-latency trading ecosystem from scratch using C++. By the end of the book, you'll be ready to implement best practices to optimize performance in real-world scenarios.

What this Book will help me do

Gain expertise in analyzing latency bottlenecks and applying C++ optimization techniques.
Develop components of a low-latency trading system such as matching engines and data handlers.
Understand and utilize advanced features of C++ for performance-critical applications.
Learn to measure system-level performance to identify and address latency issues.
Master the end-to-end design and implementation of a high-performance trading system.

Author(s)

Sourav Ghosh is a seasoned software engineer and expert in C++ programming for high-performance systems. With years of hands-on experience in developing low-latency applications, Sourav brings a wealth of knowledge and practical insight. He is passionate about clean code and effective application design, sharing his expertise through this comprehensive guide.

Who is it for?

This book is ideal for intermediate to advanced C++ developers aiming to specialize in low-latency system design, particularly in domains like high-frequency trading. It is also well-suited for quantitative analysts interested in implementing trading algorithms with optimal performance. Readers should be comfortable with C++ and have a foundational understanding of computer programming principles to fully benefit.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

C++ Concurrency in Action, Second Edition

Publisher Resources

ISBN: 9781837639359

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills