perf: improve OrderSide performance by saving asks in ascending order and bids in descending order

Author: fasenderos

src/orderbook.ts

@@ -28,8 +28,8 @@ export class OrderBook {
   private bids: OrderSide
   private asks: OrderSide
   constructor() {
-    this.bids = new OrderSide()
-    this.asks = new OrderSide()
+    this.bids = new OrderSide(Side.BUY)
+    this.asks = new OrderSide(Side.SELL)
   }
 
   /**
@@ -317,20 +317,12 @@ export class OrderBook {
   public depth = (): [[number, number][], [number, number][]] => {
     const asks: [number, number][] = []
     const bids: [number, number][] = []
-
-    let level = this.asks.maxPriceQueue()
-    while (level) {
-      const levelPrice = level.price()
+    this.asks.priceTree().forEach((levelPrice, level) => {
       asks.push([levelPrice, level.volume()])
-      level = this.asks.lowerThan(levelPrice)
-    }
-
-    level = this.bids.maxPriceQueue()
-    while (level) {
-      const levelPrice = level.price()
+    })
+    this.bids.priceTree().forEach((levelPrice, level) => {
       bids.push([levelPrice, level.volume()])
-      level = this.bids.lowerThan(levelPrice)
-    }
+    })
     return [asks, bids]
   }
 
@@ -469,20 +461,13 @@ export class OrderBook {
     }
 
     let cumulativeSize = 0
-    let iterator = orderSide.priceTree().end
-    let continueLoop = true
-    while (continueLoop) {
-      if (iterator?.node) {
-        if (price <= iterator.node.key) {
-          cumulativeSize += iterator.node.value.volume()
-          if (cumulativeSize < size && iterator.hasPrev) {
-            iterator = orderSide.priceTree().at(iterator.index - 1)
-          } else {
-            continueLoop = false
-          }
-        } else continueLoop = false
-      } else continueLoop = false
-    }
+    orderSide.priceTree().forEach((_key, priceLevel) => {
+      if (price <= priceLevel.price() && cumulativeSize < size) {
+        cumulativeSize += priceLevel.volume()
+      } else {
+        return true // break the loop
+      }
+    })
     return cumulativeSize >= size
   }
 }

src/orderside.ts

@@ -2,18 +2,24 @@ import createRBTree from 'functional-red-black-tree'
 import { CustomError, ERROR } from './errors'
 import { Order, OrderUpdate } from './order'
 import { OrderQueue } from './orderqueue'
+import { Side } from './side'
 
 export class OrderSide {
   private _priceTree: createRBTree.Tree<number, OrderQueue>
   private _prices: { [key: string]: OrderQueue } = {}
-
   private _volume = 0
   private _total = 0
   private _numOrders = 0
   private _depthSide = 0
-
-  constructor() {
-    this._priceTree = createRBTree<number, OrderQueue>()
+  private _side: Side = Side.SELL
+
+  constructor(side: Side) {
+    const compare =
+      side === Side.SELL
+        ? (a: number, b: number) => a - b
+        : (a: number, b: number) => b - a
+    this._priceTree = createRBTree<number, OrderQueue>(compare)
+    this._side = side
   }
 
   // returns amount of orders
@@ -106,31 +112,39 @@ export class OrderSide {
     }
   }
 
-  // returns maximal level of price
+  // returns max level of price
   maxPriceQueue = (): OrderQueue | undefined => {
     if (this._depthSide > 0) {
-      const max = this._priceTree.end
+      const max =
+        this._side === Side.SELL ? this._priceTree.end : this._priceTree.begin
       return max.value
     }
   }
 
-  // returns maximal level of price
+  // returns min level of price
   minPriceQueue = (): OrderQueue | undefined => {
     if (this._depthSide > 0) {
-      const min = this._priceTree.begin
+      const min =
+        this._side === Side.SELL ? this._priceTree.begin : this._priceTree.end
       return min.value
     }
   }
 
   // returns nearest OrderQueue with price less than given
   lowerThan = (price: number): OrderQueue | undefined => {
-    const node = this._priceTree.lt(price)
+    const node =
+      this._side === Side.SELL
+        ? this._priceTree.lt(price)
+        : this._priceTree.gt(price)
     return node.value
   }
 
   // returns nearest OrderQueue with price greater than given
   greaterThan = (price: number): OrderQueue | undefined => {
-    const node = this._priceTree.gt(price)
+    const node =
+      this._side === Side.SELL
+        ? this._priceTree.gt(price)
+        : this._priceTree.lt(price)
     return node.value
   }
 

test/orderbook.test.ts

@@ -7,15 +7,21 @@ const addDepth = (ob: OrderBook, prefix: string, quantity: number) => {
   for (let index = 50; index < 100; index += 10) {
     ob.limit(Side.BUY, `${prefix}buy-${index}`, quantity, index)
   }
-
   for (let index = 100; index < 150; index += 10) {
     ob.limit(Side.SELL, `${prefix}sell-${index}`, quantity, index)
   }
-
   return
 }
 
 describe('OrderBook', () => {
+  // First test the addDepth function used by all the other test
+  test('test addDepth testing function', () => {
+    const ob = new OrderBook()
+    addDepth(ob, '', 10)
+    expect(ob.toString()).toBe(
+      `\n140 -> 10\n130 -> 10\n120 -> 10\n110 -> 10\n100 -> 10\r\n------------------------------------\n90 -> 10\n80 -> 10\n70 -> 10\n60 -> 10\n50 -> 10`
+    )
+  })
   test('test limit place', () => {
     const ob = new OrderBook()
     const size = 2
@@ -45,7 +51,7 @@ describe('OrderBook', () => {
     depth.forEach((side, index) => {
       side.forEach((level, subIndex) => {
         expect(level[1]).toBe(2)
-        let price = index === 0 ? 140 - 10 * subIndex : 90 - 10 * subIndex
+        let price = index === 0 ? 100 + 10 * subIndex : 90 - 10 * subIndex
         expect(level[0]).toBe(price)
       })
     })
@@ -197,7 +203,7 @@ describe('OrderBook', () => {
 
     const processFOKSell = ob.limit(
       Side.SELL,
-      'order-fok-s80',
+      'order-fok-sell-4-70',
       4,
       70,
       TimeInForce.FOK
@@ -342,11 +348,4 @@ describe('OrderBook', () => {
     expect(calc4.err?.message).toBe(ERROR.ErrInsufficientQuantity)
     expect(calc4.price).toBe(10500)
   })
-  test('test priceCalculation', () => {
-    const ob = new OrderBook()
-    addDepth(ob, '', 10)
-    expect(ob.toString()).toBe(
-      `\n140 -> 10\n130 -> 10\n120 -> 10\n110 -> 10\n100 -> 10\r\n------------------------------------\n90 -> 10\n80 -> 10\n70 -> 10\n60 -> 10\n50 -> 10`
-    )
-  })
 })

test/orderside.test.ts

@@ -5,7 +5,7 @@ import { ERROR } from '../src/errors'
 
 describe('OrderSide', () => {
   test('it should append/update/remove orders from queue', () => {
-    const os = new OrderSide()
+    const os = new OrderSide(Side.SELL)
     const order1 = new Order('order1', Side.SELL, 5, 10)
     const order2 = new Order('order2', Side.SELL, 5, 20)