Garbage Free OrderBook

Overview

This library provides lightweight Order Book component.

Requirements:

Input data: Level 1, Level 2 market data in Universal Market Data format
You need to decide if you need aggregated / consolidated / single-exchange order book before you start using it
No need to keep "before/after" state of each market message update (only "after")
No memory allocatons in main processing cycle
Single threaded use only

Getting started

Step 1: Setting up the dependency.

The first step is to include orderbook into your project, for example, as a Gradle compile dependency:

dependencies {
    implementation  com.epam.deltix:orderbook-core:x.x.x
}

(Please replace x with the latest version numbers: Maven Central )

Step 2: Create order book

final OrderBook<OrderBookQuote> orderBook = OrderBookFactory.create();

Step 3: Feed order book with market data

void onMarketData(final MarketMessage message) {
    orderBook.update(message);
}

Step 4: Access order book state

Use for-each loop (procedural style)

for (OrderBookQuote quote : orderBook.getMarketSide(QuoteSide.ASK)) {
    System.out.println(quote);
}

You can use the streaming API if you don't care about memory allocation! 💪

orderBook.getMarketSide(QuoteSide.ASK).stream()    #1) Stream for quotes in order book
    .filter(quote -> Decimal64Utils.isGreater(quote.getPrice(), Decimal64Utils.fromInt(15)))
    .forEach(System.out::println);

orderBook.getExchangeList().stream()               #2) Stream for quotes by exchanges
    .flatMap(exchange -> exchange.getMarketSide(QuoteSide.ASK).stream())
    .filter(quote -> Decimal64Utils.isGreater(quote.getPrice(), Decimal64Utils.fromInt(15)))
    .forEach(System.out::println);

🔧 Configuration Parameters

🚀 Initialization

You can use the OrderBookOptionsBuilder class like so:

final OrderBookOptions commonOpt = new OrderBookOptionsBuilder()
        .quoteLevels(DataModelType.LEVEL_TWO)
        .initialMaxDepth(marketDepth)
        .initialExchangesPoolSize(exchangeIds.length)
        .updateMode(UpdateMode.WAITING_FOR_SNAPSHOT)
        .build();

final OrderBookOptions opt = new OrderBookOptionsBuilder()
        .parent(commonOpt)
        .symbol("BTC/USD")
        .orderBookType(OrderBookType.AGGREGATED)
        .build();

final OrderBook<OrderBookQuote> orderBook = OrderBookFactory.create(opt);

or directly instantiate a OrderBook with default parameters like so:

final OrderBook<OrderBookQuote> orderBook = OrderBookFactory.create();

Parameter Details

parent - Override the defaults from the given option
You may use this only once.
Since: 1.0.11
Type: OrderBookOptions
symbol - Stock symbol
This stock symbol is used to check all input packets before processing.
If you are sure that your market data contains data for only one stock symbol, you may not set this option.
Since: 1.0.11
Type: String
orderBookType - Order book type to use
Since: 1.0.11
Type: OrderBookType
Default Value is: SINGLE_EXCHANGE
The following types are supported:
- SINGLE_EXCHANGE - order book from single exchange
- CONSOLIDATED - consolidated view on the market from multiple exchanges, you can see individual exchange sizes
- AGGREGATED - aggregated view of multiple exchanges, you can see combined size of each price level
updateMode - What do we do with incremental update if we have empty order book?
Since: 1.0.11
Type: UpdateMode
Default Value is: WAITING_FOR_SNAPSHOT
The following types are supported:
- WAITING_FOR_SNAPSHOT - waiting snapshot before processing incremental update
- NON_WAITING_FOR_SNAPSHOT - process incremental update without waiting for the snapshot
gapMode - What do we do if we have a gap between the last existing level and the current inserted level (empty levels in between)?
Since: 1.0.11
Type: GapMode
Default Value is: SKIP
The following types are supported:
- SKIP - let's skip quote
- SKIP_AND_DROP - let's skip quote and drop all quote for stock exchange
- FILL_GAP - let's fill these empty levels with values from the current event.
  The insertion level cannot be greater than the value of the parameter maxDepth
  otherwise insertion wiil be skip.
quoteLevels - Quote levels to use
Since: 1.0.11
Type: DataModelType
Default Value is: LEVEL_ONE
The following types are supported:
- LEVEL_ONE - level one (best bid and best offer)
- LEVEL_TWO - level two. Market by level. More details than LEVEL_ONE
🔢 initialDepth - How large initial depth of market should be?
Since: 1.0.11
Type: int
Default Value is: 1
🔢 maxDepth - How large maximum (limit) depth of market should be?
Using this parameter if you want processing not all depth of market.
But is can make orderbook not valid (with gaps). See parameter gapMode
Since: 1.0.11
Type: int
Default Value is: 32767
🔢 unreachableDepthMode - What do we do if we have quote level more than maxDepth?

Since: 1.0.17
Type: UnreachableDepthMode
Default Value is: SKIP
The following types are supported:
- SKIP - let's skip quote
- SKIP_AND_DROP - let's skip quote and drop all quote for stock exchange
🔢 initialExchangesPoolSize - How large initial pool size for stock exchanges should be?
Supported for AGGREGATED and CONSOLIDATED order book type.
Since: 1.0.11
Type: int
Default Value is: 1

Samples

Iteration Cookies (Callback)

In many cases it is helpful to pass some kind of cookie or state object when iterating order book:

orderBook.getMarketSide(QuoteSide.ASK).forEach(this::quoteViewAccumulatorAction, new QuoteCookie());

Small example that shows some useful accumulator:

private static final class PriceAccumulator { 
    @Decimal
    private long price;

    public void apply(@Decimal long add) {
        price = Decimal64Utils.add(price, add);
    }

    public long getPrice() {
        return price;
    }
}

...
orderBook.getMarketSide(QuoteSide.ASK).forEach(this::quoteViewAccumulatorAction, priceAccumulator);
orderBook.getMarketSide(QuoteSide.BID).forEach(this::quoteViewAccumulatorAction, priceAccumulator);
...

boolean quoteViewAccumulatorAction(final OrderBookQuoteView orderBookQuote,
                                   final PriceAccumulator accumulator){
    accumulator.apply(orderBookQuote.getPrice());
    return priceLevel< 10; // do not go deeper than 10 levels
}

Samples can be found in the samples folder.

Performance Testing

Preparation

Measured on moderately sized developer's laptop. For run test see OrderBookIT

Hardware:

CPU: Intel(R) Core(TM) i7-10610U CPU @ 1.80GHz   2.30 GHz
Memory: 32.0 GB
Disk: SSD 512

Market data:

Quote levels: L1/L2
Types of packages: VENDOR_SNAPSHOT/PERIODICAL_SNAPSHOT/INCREMENTAL_UPDATE
Number of exchanges: 1
Price levels: 500
Number of messages: 4 27 042

Test Result

Table - L1 Quote Level

Order Book Implementation	Messages Processed (msg/s)	Allocation Memory byte(s)
Black hole	1 977 046	-
SingleExchangeOrderBook	1 567 812	496
ConsolidatedOrderBook	TODO	TODO
AggregatedOrderBook	TODO	TODO

Table - L2 Quote Level

Order Book Implementation	Messages Processed (msg/s)	Allocation Memory byte(s)
Black hole	1 977 046	-
SingleExchangeOrderBook	1 110 222	62 272
ConsolidatedOrderBook	890 701	67 024
AggregatedOrderBook	890 062	125 024

License

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

epam / TimebaseOrderBook