Merge pull request #172 from ChainSafe/tuyen/time-cache

Implement SimpleTimeCache

Author: dapplion

package.json

@@ -19,6 +19,7 @@
     "build:types": "aegir build --no-types",
     "prepare": "npm run build",
     "pretest": "npm run build",
+    "benchmark": "node ./node_modules/.bin/benchmark 'test/benchmark/time-cache.test.js' --local",
     "test": "aegir test",
     "test:node": "aegir test --target node",
     "test:browser": "aegir test --target browser"
@@ -47,7 +48,6 @@
     "libp2p-interfaces": "^2.0.1",
     "peer-id": "^0.16.0",
     "protobufjs": "^6.11.2",
-    "time-cache": "^0.3.0",
     "uint8arrays": "^3.0.0"
   },
   "devDependencies": {
@@ -83,6 +83,8 @@
     "p-wait-for": "^3.1.0",
     "promisify-es6": "^1.0.3",
     "sinon": "^11.1.1",
+    "time-cache": "^0.3.0",
+    "@dapplion/benchmark": "^0.1.6",
     "typescript": "4.0.x",
     "util": "^0.12.3"
   },

test/benchmark/time-cache.test.js

@@ -0,0 +1,26 @@
+const {itBench, setBenchOpts} = require("@dapplion/benchmark");
+const TimeCache = require('time-cache')
+const {SimpleTimeCache} = require("../../src/utils/time-cache");
+
+describe("npm TimeCache vs SimpleTimeCache", () => {
+  setBenchOpts({
+    maxMs: 100 * 1000,
+    minMs: 60 * 1000,
+    runs: 512,
+  });
+
+  const iterations = [1_000_000, 4_000_000, 8_000_000, 16_000_000];
+  const timeCache = new TimeCache({ validity: 1 });
+  const simpleTimeCache = new SimpleTimeCache({ validityMs: 1000 });
+
+  for (const iteration of iterations) {
+    itBench(`npm TimeCache.put x${iteration}`, () => {
+      for (let j = 0; j < iteration; j++) timeCache.put(String(j));
+    });
+
+    itBench(`SimpleTimeCache.put x${iteration}`, () => {
+      for (let j = 0; j < iteration; j++) simpleTimeCache.put(String(j));
+    });
+  }
+
+});

test/time-cache.spec.js

@@ -0,0 +1,41 @@
+const {expect} = require("chai")
+const {SimpleTimeCache} = require("../src/utils/time-cache")
+const sinon = require("sinon")
+
+describe("SimpleTimeCache", () => {
+  const validityMs = 1000
+  const timeCache = new SimpleTimeCache({validityMs})
+  const sandbox = sinon.createSandbox()
+
+  beforeEach(() => {
+    sandbox.useFakeTimers()
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+
+  it("should delete items after 1sec", () => {
+    timeCache.put("aFirst")
+    timeCache.put("bFirst")
+    timeCache.put("cFirst")
+
+    expect(timeCache.has("aFirst")).to.be.true
+    expect(timeCache.has("bFirst")).to.be.true
+    expect(timeCache.has("cFirst")).to.be.true
+
+    sandbox.clock.tick(validityMs)
+
+    timeCache.put("aSecond")
+    timeCache.put("bSecond")
+    timeCache.put("cSecond")
+
+    expect(timeCache.has("aSecond")).to.be.true
+    expect(timeCache.has("bSecond")).to.be.true
+    expect(timeCache.has("cSecond")).to.be.true
+    expect(timeCache.has("aFirst")).to.be.false
+    expect(timeCache.has("bFirst")).to.be.false
+    expect(timeCache.has("cFirst")).to.be.false
+  })
+})

ts/index.ts

@@ -8,13 +8,11 @@ import { createGossipRpc, shuffle, hasGossipProtocol, messageIdToString } from '
 import { PeerScore, PeerScoreParams, PeerScoreThresholds, createPeerScoreParams, createPeerScoreThresholds } from './score'
 import { IWantTracer } from './tracer'
 import { AddrInfo, MessageIdFunction } from './interfaces'
+import { SimpleTimeCache } from './utils/time-cache'
 import { Debugger } from 'debug'
 import Libp2p from 'libp2p'
 
 import PeerStreams from 'libp2p-interfaces/src/pubsub/peer-streams'
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import TimeCache = require('time-cache')
 import PeerId = require('peer-id')
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
@@ -89,7 +87,7 @@ interface GossipOptions extends GossipInputOptions {
 class Gossipsub extends Pubsub {
   peers: Map<string, PeerStreams>
   direct: Set<string>
-  seenCache: TimeCache
+  seenCache: SimpleTimeCache
   topics: Map<string, Set<string>>
   mesh: Map<string, Set<string>>
   fanout: Map<string, Set<string>>
@@ -192,9 +190,9 @@ class Gossipsub extends Pubsub {
     /**
      * Cache of seen messages
      *
-     * @type {TimeCache}
+     * @type {SimpleTimeCache}
      */
-    this.seenCache = new TimeCache({ validity: opts.seenTTL / 1000 })
+    this.seenCache = new SimpleTimeCache({ validityMs: opts.seenTTL })
 
     /**
      * Map of topic meshes

ts/utils/time-cache.ts

@@ -0,0 +1,49 @@
+type SimpleTimeCacheOpts = {
+  validityMs: number
+}
+
+/**
+ * This is similar to https://github.com/daviddias/time-cache/blob/master/src/index.js
+ * for our own need, we don't use lodash throttle to improve performance.
+ * This gives 4x - 5x performance gain compared to npm TimeCache
+ */
+export class SimpleTimeCache {
+  private entries: Map<string, number>;
+  private validityMs: number;
+  private lastPruneTime = 0;
+
+  constructor (options: SimpleTimeCacheOpts) {
+    this.entries = new Map()
+    this.validityMs = options.validityMs
+
+    if (this.validityMs <= 0) {
+      throw Error(`Invalid validityMs ${this.validityMs}`)
+    }
+  }
+
+  put (key: string): void {
+    this.entries.set(key, Date.now())
+    this.prune()
+  }
+
+  prune (): void {
+    const now = Date.now()
+    if (now - this.lastPruneTime < 200) {
+      return
+    }
+    this.lastPruneTime = now
+
+    for (const [k, v] of this.entries.entries()) {
+      if (v + this.validityMs < now) {
+        this.entries.delete(k)
+      } else {
+        // sort by insertion order
+        break
+      }
+    }
+  }
+
+  has (key: string): boolean {
+    return this.entries.has(key)
+  }
+}