How d-nithinteja/swiftspsc works
Purpose and Entry Points
SwiftSPSC is a C++ lock-free single-producer/single-consumer queue library with two execution modes: reusable in-process thread communication and Linux shared-memory IPC. The public include surface is include/swiftspsc/swiftspsc.h; the primary queue type is include/swiftspsc/spsc_queue.h. CMake builds examples, benchmarks, and installation artifacts from CMakeLists.txt.
In-Process Queue Core
include/swiftspsc/spsc_queue.h implements swiftspsc::SPSCQueue<T> as a fixed-capacity, power-of-two ring buffer. One producer owns enqueue-side progress and one consumer owns dequeue-side progress; this ownership model avoids locks. The API supports nonblocking try_* operations and spinning push/pop operations.
Lock-Free Coordination and Memory Boundary
Queue correctness relies on atomic head/tail indices, acquire/release publication, and mask-based ring indexing. Producer-side cached consumer progress and consumer-side cached producer progress reduce cross-core atomic reads. Shared queue conventions and lower-level IPC primitives are centralized in include/swiftspsc/queue_common.h.
IPC Shared-Memory Pipeline
The IPC path uses named shared memory and a producer/consumer lifecycle. examples/ipc/producer.cpp creates or initializes the shared queue, publishes items, and signals completion. examples/ipc/consumer.cpp waits for readiness, drains published work, observes the done state, and reports throughput. This mode preserves batch publication behavior rather than treating each enqueue as an independent cross-process publication.
HFT Integration Shape
The hft directory demonstrates a likely market-data-to-strategy handoff built on SPSC-style communication. hft/md_gateway.cpp represents ingestion/gateway-side production; hft/strategy_engine.cpp represents downstream consumption and strategy execution; hft/hft_types.h defines their exchanged domain types. This isolates market-data acquisition from latency-sensitive strategy processing through a bounded queue boundary.
Performance Evaluation
Thread-mode benchmarks measure throughput and latency under producer/consumer execution: benchmarks/thread_throughput.cpp and benchmarks/thread_latency.cpp. examples/thread/basic.cpp is the minimal in-process integration entry point. Benchmark quality depends on release compilation, CPU affinity/isolation, and repeated percentile-based measurements.
Runtime and Delivery
The project is native C++ built with CMake (CMakeLists.txt) and has no web or managed runtime. IPC execution is Linux-oriented due to named shared-memory usage. The library is primarily header-based under include/swiftspsc/, with CMake installation exposing those headers to downstream C++ consumers.
Main entry points: spsc_queue.h SPSCQueue<T> · CMakeLists.txt CMake Build & Install · queue_common.h Named Shared Queue · hft_types.h Market Data Types
Components 15
Header Library
Header-based SPSC queue implementation.
- Public Include Surface
include/swiftspsc/swiftspsc.h - SPSCQueue<T> · Fixed-capacity power-of-two queue with try and spinning APIs.
include/swiftspsc/spsc_queue.h - Atomic Ring Coordination · Head/tail publication, cached progress, and mask indexing.
include/swiftspsc/spsc_queue.h - Shared Queue Conventions · Centralizes shared queue conventions and lower-level IPC support.
include/swiftspsc/queue_common.h
Shared-Memory IPC
Linux producer/consumer example pipeline.
- IPC Producer · Initializes named shared queue, publishes items, then signals completion.
examples/ipc/producer.cpp - Named Shared Queue · Batch-published queue state shared between Linux processes.
include/swiftspsc/queue_common.h - IPC Consumer · Waits for readiness, drains work, observes done state, and reports throughput.
examples/ipc/consumer.cpp
HFT Handoff
Market-data to strategy queue boundary.
- Market Data Types · Types exchanged across the gateway-to-strategy boundary.
hft/hft_types.h - Market Data Gateway · Ingests market data and produces bounded-queue messages.
hft/md_gateway.cpp - Strategy Engine · Consumes market data for latency-sensitive strategy execution.
hft/strategy_engine.cpp - Bounded Queue Boundary · Isolates acquisition from strategy processing.
include/swiftspsc/spsc_queue.h
Examples & Benchmarks
- Thread Basic Example
examples/thread/basic.cpp - Thread Throughput
benchmarks/thread_throughput.cpp - Thread Latency · Uses repeated percentile-based latency measurements.
benchmarks/thread_latency.cpp
Other components
- CMake Build & Install · Builds examples and benchmarks and installs public headers.
CMakeLists.txt
Connections 20
- CMake Build & Install → Public Include Surface: installs
- CMake Build & Install → Thread Basic Example: builds
- CMake Build & Install → Thread Throughput: builds
- CMake Build & Install → Thread Latency: builds
- CMake Build & Install → IPC Producer: builds
- CMake Build & Install → IPC Consumer: builds
- Public Include Surface → SPSCQueue<T>: exposes
- SPSCQueue<T> → Atomic Ring Coordination: implements with
- SPSCQueue<T> → Shared Queue Conventions: uses conventions
- Thread Basic Example → SPSCQueue<T>: uses
- Thread Throughput → SPSCQueue<T>: measures
- Thread Latency → SPSCQueue<T>: measures
- IPC Producer → Named Shared Queue: creates and publishes
- Named Shared Queue → IPC Consumer: published batches and done state
- Named Shared Queue → Shared Queue Conventions: uses IPC primitives
- Market Data Gateway → Bounded Queue Boundary: produces
- Bounded Queue Boundary → Strategy Engine: consumes
- Bounded Queue Boundary → SPSCQueue<T>: is implemented by
- Market Data Types → Market Data Gateway: defines messages
- Market Data Types → Strategy Engine: defines messages