Order Book Freezing for Latency-Independent Fair Processing

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

In distributed computing systems, latency between computer nodes can lead to uneven processing of data transaction requests, where requests from closer nodes are processed faster than those from more distant nodes, even if transmitted earlier, resulting in unfair processing and potential losses for participants with slower connections.

Innovation Solution

A computer system is configured to lock or freeze one side of a data structure, such as an order book, when an incoming aggressive order is received, allowing orders on the other side to be processed while the locked side's requests are queued. A timer is started for the locked side, and upon expiration, the locked side is unfrozen, and all queued requests are processed in the order they were received.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Speed

If immediate processing of incoming data transaction requests is implemented, then processing speed is improved, but fairness and reliability deteriorate due to latency-based uneven processing

Engineering Contradiction:
Improveprocessing speedVSAvoidprocessing fairness
Core Design Contradiction:
SpeedVSReliability

Solution Approach 1:

The system performs preliminary actions by locking the order book side and queuing incoming requests before processing them. When an aggressive order is received, the system proactively locks the affected side and queues subsequent requests, ensuring they are processed in a controlled manner after the lock is released, thereby preventing latency-based unfairness while maintaining efficient processing

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

A queue data structure is introduced as an intermediary between request reception and processing. Requests are placed in the queue during the lock period and processed systematically after the lock is released, mediating between the need for immediate processing and the requirement for fair, latency-independent handling

Inventive Principle:
Principle #24Intermediary (Mediator)

2Reliability

If processing of data transaction requests is delayed to ensure fairness, then processing fairness is improved, but processing speed and productivity deteriorate

Engineering Contradiction:
Improveprocessing fairnessVSAvoidprocessing throughput
Core Design Contradiction:
ReliabilityVSProductivity

Solution Approach 1:

The processing system is segmented into distinct phases: immediate locking upon receiving an aggressive order, queuing of incoming requests during the lock period, and systematic processing after lock release. This segmentation allows the system to maintain high throughput by processing non-conflicting requests immediately while ensuring fairness for conflicting requests through the queued processing mechanism

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The system dynamically adjusts its processing behavior based on the state of the order book. When no aggressive order is present, requests are processed immediately with full throughput. When an aggressive order triggers a lock, the system dynamically switches to queued processing for the affected side, maintaining fairness while minimizing impact on overall productivity

Inventive Principle:
Principle #15Dynamics

Data Source

PatentUS11609782B2Delayed processing for electronic data messages in a distributed computer system
Publication Date: 2023.03.21 NASDAQ TECHNOLOGY AB
  • US11609782B2 patent drawing
  • US11609782B2 patent drawing
  • US11609782B2 patent drawing

AI summary

A computer system is provided that includes a matching engine and a freezing process. The matching engine freezes one side of a two-sided data structure when an order is determined to matchable. The freezing process starts a timer based on the matching determination. Orders that are handled by the matching engine while the side is frozen are added to a queue. When the timer ends, the orders in the queue are processed against those orders that are now resting within the data structure.