Fast Matching Engine

A high-performance electronic trading matching engine built in Modern C++ with a FastAPI backend. The project simulates the core functionality of a real-world exchange by maintaining independent order books for multiple symbols and matching orders using Price-Time Priority (FIFO).

The matching engine is written entirely in C++ for performance, while Python bindings expose the engine through REST APIs.

---

Features

• High-performance C++ matching engine
• Price-Time Priority (FIFO) matching
• Limit Order support
• Market Order support
• Multi-symbol order books
• Fast order cancellation
• Best Bid / Best Ask retrieval
• Thread-safe order processing
• FastAPI REST APIs
• Python bindings using pybind11
• Snowflake-style Order ID generation
• Modular backend architecture

---

Tech Stack

Core Engine

• C++17
• STL
• Mutex
• Shared Mutex
• CMake

Backend

• FastAPI
• Python
• Pydantic
• Uvicorn

Bindings

• pybind11

---

Architecture

                REST API
                  │
             FastAPI Backend
                  │
          Python Service Layer
                  │
          pybind11 Bindings
                  │
      C++ Matching Engine Core
                  │
        Independent Order Books

---

Matching Logic

The engine follows the same matching strategy used by modern exchanges.

Buy Orders

Priority:

1. Highest Price
2. Earliest Timestamp

Sell Orders

Priority:

1. Lowest Price
2. Earliest Timestamp

This guarantees Price-Time Priority (FIFO).

---

Project Structure

backend/
│
├── app/
│   ├── routes/
│   ├── services/
│   ├── models/
│   ├── utils/
│   ├── engine/
│   └── main.py
│
└── Cpp_files/
    ├── core/
    │   ├── MatchingEngine.cpp
    │   ├── OrderBook.cpp
    │   ├── Order.cpp
    │   └── ...
    │
    └── bindings/
        ├── bindings.cpp
        └── CMakeLists.txt

---

Order Book Design

Each trading symbol maintains its own independent order book.

The order book stores:

• Buy Orders
• Sell Orders
• Order Index for O(1) cancellation

Buy side:

Highest Price
     ↓
FIFO Queue

Sell side:

Lowest Price
     ↓
FIFO Queue

---

Thread Safety

The engine is designed for concurrent environments.

Features include:

• Per-order-book mutex for sequential order processing
• Shared mutex for safe access to multiple order books
• Independent locking for different trading symbols

This allows multiple symbols to be processed concurrently while preserving correctness.

---

Order Processing Flow

Client

   │

POST /order

   │

FastAPI

   │

Validation

   │

Generate Order ID

   │

Python Bindings

   │

C++ Matching Engine

   │

Trades Generated

   │

REST Response

---

REST APIs

Submit Order

POST /order

Submits either a Market or Limit order.

---

Cancel Order

DELETE /order/{symbol}/{order_id}

Cancels an active order.

---

Best Buy Price

GET /book/{symbol}/best_buy_price

Returns the highest bid currently available.

---

Best Sell Price

GET /book/{symbol}/best_sell_price

Returns the lowest ask currently available.

---

Available Order Books

GET /orderbook/symbols

Returns all symbols currently maintained by the engine.

---

Design Highlights

• Modular architecture separating matching logic from APIs
• Efficient price-level organization using ordered STL containers
• Constant-time order cancellation using indexed order locations
• Clean separation between engine, service layer, and REST interface
• Extensible design suitable for adding persistence, authentication, and additional order types

---

Performance Benchmark

The matching engine was benchmarked under both single-threaded and multi-threaded workloads to evaluate throughput and scalability.

Benchmark Results

Single Thread

Orders Processed : 10,000,000
Execution Time   : 8.52 s
Throughput       : 1.17 Million Orders/sec


Multi Thread

Threads          : 4
Symbols          : 4
Orders Processed : 4,000,000
Execution Time   : 0.875 s
Throughput       : 4.57 Million Orders/sec

Observations

• The multi-threaded implementation achieved approximately 2–4× higher throughput than the single-threaded version.
• When different threads process different trading symbols (low contention), the engine demonstrates near-linear scalability because each OrderBook can be processed independently.
• When multiple threads operate on the same symbol, throughput decreases due to lock contention on the corresponding OrderBook.

Performance Characteristics

Feature	Complexity
Order Matching	O(log P + T)
Order Insertion	O(log P)
Order Cancellation	O(1)
Best Bid / Ask	O(1)
Multi-Symbol Processing	Parallel
Matching Policy	Price-Time Priority (FIFO)

Where:

• P = Number of price levels
• T = Number of trades generated by the incoming order

Future Improvements

Planned enhancements include:

• User authentication (JWT)
• MySQL integration
• Persistent order history
• Portfolio management
• Trade history
• Market depth visualization
• Benchmarking and stress testing

---

Learning Outcomes

This project demonstrates practical knowledge of:

• Order matching algorithms
• Price-Time Priority
• Exchange architecture
• Modern C++
• Multithreading and synchronization
• Data structures for low-latency systems
• FastAPI backend development
• Python-C++ interoperability using pybind11
• REST API design

---

Author

Siddharth Arora

B.Tech Computer Science Indian Institute of Information Technology, Guwahati

If you found this project interesting, consider giving it a ⭐.