release

Author: harshitsinghcode

.github/workflows/publish.yml

@@ -0,0 +1,61 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        # Build on Windows (YOU), Linux (Servers), and Mac (Devs)
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      # Used to build the C++ Extension automatically
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.16.5
+        # env:
+        #   CIBW_SOME_OPTION: value
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build sdist
+        run: pipx run build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-sdist
+          path: dist/*.tar.gz
+
+  publish_to_pypi:
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # IMPORTANT: Mandatory for trusted publishing
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v4
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - name: Publish distribution 📦 to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

README.md

@@ -0,0 +1,82 @@
+# SHAURYA: Scalable High-frequency Architecture for Ultra-low Response Yield Access
+
+![Language](https://img.shields.io/badge/language-C%2B%2B17-blue.svg)
+![Latency](https://img.shields.io/badge/min%20latency-300%20ns-brightgreen.svg)
+![Architecture](https://img.shields.io/badge/architecture-Lock--Free-orange.svg)
+![Parsing](https://img.shields.io/badge/parsing-Zero--Copy-red.svg)
+
+**Shaurya** is a high-frequency trading (HFT) market data feed handler engineered for sub-microsecond latency. By leveraging **Zero-Copy parsing**, **Lock-Free concurrency**, and **Stack-based memory management**, it bypasses the performance bottlenecks of standard software architectures to process financial data with deterministic speed.
+
+---
+
+## ⚡ Performance Impact & Comparison
+
+Shaurya was benchmarked using high-resolution hardware timers (`QueryPerformanceCounter`).
+
+| Implementation Approach | Average Latency | Min Latency | Why it's Slow/Fast? |
+| :--- | :--- | :--- | :--- |
+| **Python Script** | ~45.0 µs | ~30.0 µs | Interpreter overhead & Garbage Collection pauses. |
+| **Standard C++ (`std::string`)** | ~5.0 µs | ~3.5 µs | Frequent Heap Allocations (`malloc`) & deep memory copying. |
+| **SHAURYA (Zero-Copy)** | **1.88 µs*** | **0.3 µs** | **Zero-Copy** pointer arithmetic & **Lock-Free** queues. |
+
+> **The Result:** Shaurya achieves a minimum internal reaction time of **300 nanoseconds**, approximately **50x faster** than standard Python implementations.
+>
+> **Measured in Pure Mock Environment*
+
+![WhatsApp Image 2025-12-12 at 23 55 35_9e0c137d](https://github.com/user-attachments/assets/c095eb1a-0a6b-40d3-8a43-8a725090134b)
+
+
+### 🌍 Real-World Validation: The "Fragmented Liquidity" Test
+Shaurya was subjected to a **30-minute stress test** aggregating live ticks from **Binance, Coinbase, and Bitstamp** simultaneously.
+
+* **Test Duration:** 30 Minutes
+* **Total Messages:** 21,862 (Live Volatility Bursts)
+* **Outcome:** The engine successfully normalized fragmented liquidity streams in real-time. While average latency increased under OS scheduler load (due to non-isolated cores), the **minimum latency remained at 0.3 µs**, proving the core engine's efficiency remains stable even during crypto market volatility.
+
+---
+
+## 🏗 Key Technical Innovations
+
+### 1. Zero-Copy Architecture
+Instead of copying network packets into new `std::string` objects (which forces the OS to allocate memory), Shaurya uses a custom `StringViewLite` class. This creates a lightweight "view" over the raw socket buffer, allowing the engine to parse prices without moving a single byte of memory.
+
+### 2. Lock-Free Concurrency (SPSC)
+Traditional systems use Mutex locks (`std::mutex`) to share data between threads, which forces the CPU to stop and switch contexts (expensive). Shaurya implements a **Single-Producer Single-Consumer Ring Buffer** using `std::atomic` instructions. This allows the Network Thread to push data and the Strategy Thread to read data simultaneously without ever blocking.
+
+### 3. CPU Cache Optimization
+Critical data structures are aligned to 64-byte cache lines (`alignas(64)`). This prevents **False Sharing**, a phenomenon where two threads fight over the same CPU cache line, drastically reducing performance on multi-core systems.
+
+---
+
+## 🚀 Quick Start
+
+### Prerequisites
+* **OS:** Windows (Required for `winsock2` and `QueryPerformanceCounter`)
+* **Compiler:** G++ (MinGW) supporting C++11 or higher.
+
+### Execution Guide
+1.  **Build the System:**
+    ```cmd
+    build.bat
+    ```
+2.  **Start Data Source:** 
+    ```python bridge.py```
+3.  **Start Shaurya Engine:**
+    ```cmd
+    bin\Shaurya.exe
+    ```
+
+*Upon completion, the engine generates a `Shaurya_Metrics.txt` report detailing the nanosecond-level performance of the run.*
+
+---
+
+## Resources
+
+If you are new to High-Frequency Trading systems, these concepts explain the "Why" behind Shaurya's architecture:
+
+* **Latency vs. Jitter:** [Understand why "Average Speed" is useless in HFT](https://www.youtube.com/watch?v=NH1Tta7purM).
+* **Zero-Copy Networking:** [How avoiding memory copies saves microseconds](https://en.wikipedia.org/wiki/Zero-copy).
+* **Lock-Free Programming:** [An introduction to Atomics and Ring Buffers](https://www.1024cores.net/home/lock-free-algorithms/queues).
+* **False Sharing:** [The hidden killer of multi-threaded performance](https://mechanical-sympathy.blogspot.com/2011/07/false-sharing.html).
+
+`Developed by your's truly 🛩️!`

bridge.py

@@ -2,26 +2,32 @@
 import websockets
 import json
 import socket
-import time
 
-TCP_HOST = "127.0.0.1"
-TCP_PORT = 5000
-RUN_DURATION = 1800  # 30 Minutes
+# --- CONFIGURATION ---
+MULTICAST_GROUP = "239.0.0.1"
+MULTICAST_PORT = 30001
+RUN_DURATION = 120  # 30 Minutes
 
+# --- DATA SOURCES ---
 SOURCES = [
     {"name": "BINANCE",  "url": "wss://stream.binance.com:9443/ws/btcusdt@trade"},
     {"name": "COINBASE", "url": "wss://ws-feed.exchange.coinbase.com"},
     {"name": "BITSTAMP", "url": "wss://ws.bitstamp.net"}
 ]
 
-async def forward_to_engine(writer, fix_msg):
+# Setup UDP Multicast Socket
+sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
+
+def send_multicast(fix_msg):
     try:
-        writer.write(fix_msg.encode())
-        await writer.drain()
+        sock.sendto(fix_msg.encode(), (MULTICAST_GROUP, MULTICAST_PORT))
+        # Optional: Print a dot for every message to verify liveness without spam
+        # print(".", end="", flush=True) 
     except Exception as e:
-        print(f"[TCP ERROR] {e}")
+        print(f"[ERROR] UDP Send Failed: {e}")
 
-async def stream_binance(writer):
+async def stream_binance():
     url = SOURCES[0]["url"]
     async for websocket in websockets.connect(url):
         try:
@@ -30,12 +36,14 @@ async def stream_binance(writer):
                 msg = await websocket.recv()
                 data = json.loads(msg)
                 price = data['p']
+                # Tag 49 identifies the Source Exchange
                 fix = f"8=FIX.4.2\x0135=X\x0149=BINANCE\x0155=BTCUSDT\x01269=0\x01270={price}\x01"
-                await forward_to_engine(writer, fix)
+                send_multicast(fix)
         except Exception:
+            await asyncio.sleep(1) # Reconnect delay
             continue
 
-async def stream_coinbase(writer):
+async def stream_coinbase():
     url = SOURCES[1]["url"]
     async for websocket in websockets.connect(url):
         try:
@@ -51,11 +59,12 @@ async def stream_coinbase(writer):
                 if 'price' in data:
                     price = data['price']
                     fix = f"8=FIX.4.2\x0135=X\x0149=COINBASE\x0155=BTCUSD\x01269=0\x01270={price}\x01"
-                    await forward_to_engine(writer, fix)
+                    send_multicast(fix)
         except Exception:
+            await asyncio.sleep(1)
             continue
 
-async def stream_bitstamp(writer):
+async def stream_bitstamp():
     url = SOURCES[2]["url"]
     async for websocket in websockets.connect(url):
         try:
@@ -71,39 +80,31 @@ async def stream_bitstamp(writer):
                 if 'data' in data and 'price' in data['data']:
                     price = data['data']['price']
                     fix = f"8=FIX.4.2\x0135=X\x0149=BITSTAMP\x0155=BTCUSD\x01269=0\x01270={price}\x01"
-                    await forward_to_engine(writer, fix)
+                    send_multicast(fix)
         except Exception:
+            await asyncio.sleep(1)
             continue
 
 async def main():
-    server = await asyncio.start_server(handle_client, TCP_HOST, TCP_PORT)
-    addr = server.sockets[0].getsockname()
-    print(f"[GATEWAY] Multi-Source Bridge listening on {addr}")
-    print(f"[GATEWAY] Test Duration: {RUN_DURATION / 60} Minutes")
-
-    async with server:
-        await server.serve_forever()
+    print(f"[GATEWAY] Starting Multi-Exchange UDP Broadcast to {MULTICAST_GROUP}:{MULTICAST_PORT}")
+    print(f"[GATEWAY] Aggregating Liquidity from Binance, Coinbase, Bitstamp...")
 
-async def handle_client(reader, writer):
-    print("[GATEWAY] Shaurya Engine Connected! Starting Streams...")
-    
+    # Run all streams concurrently
     tasks = [
-        asyncio.create_task(stream_binance(writer)),
-        asyncio.create_task(stream_coinbase(writer)),
-        asyncio.create_task(stream_bitstamp(writer))
+        asyncio.create_task(stream_binance()),
+        asyncio.create_task(stream_coinbase()),
+        asyncio.create_task(stream_bitstamp())
     ]
 
+    # Run for the specified duration
     await asyncio.sleep(RUN_DURATION)
 
-    print("\n[GATEWAY] 30 Minutes Complete. Stopping Test...")
-    writer.close()
-    await writer.wait_closed()
-    
+    print("\n[GATEWAY] Test Duration Complete. Stopping...")
     for task in tasks:
         task.cancel()
 
 if __name__ == "__main__":
     try:
         asyncio.run(main())
     except KeyboardInterrupt:
-        pass
+        print("Gateway Stopped.")

cmakelists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.15)
+project(shaurya_hft)
+
+# 1. Find Python and Pybind11
+find_package(Python COMPONENTS Interpreter Development REQUIRED)
+find_package(pybind11 CONFIG REQUIRED)
+
+# 2. Create the Module
+pybind11_add_module(shaurya_hft src/bindings.cpp src/FixParser.cpp src/NetworkClient.cpp)
+
+# 3. Optimizations
+if(MSVC)
+    target_compile_options(shaurya_hft PRIVATE /O2)
+else()
+    target_compile_options(shaurya_hft PRIVATE -O3 -march=native)
+endif()
+
+# 4. Includes & Links
+target_include_directories(shaurya_hft PRIVATE include)
+if(WIN32)
+    target_link_libraries(shaurya_hft PRIVATE ws2_32)
+endif()
+
+# 5. CRITICAL FIX: Tell CMake to install the file into the package!
+install(TARGETS shaurya_hft DESTINATION .)