hypercore-storage 3.1.2 → 3.2.0

package/README.md

@@ -14,10 +14,20 @@ The following API is what Hypercore 11 binds to to do I/O.
 const Storage = require('hypercore-storage')
 ```
 
-#### `store = new Storage(dbOrPath)`
+#### `store = new Storage(dbOrPath, opts = {})`
 
 Make a new storage engine.
 
+`opts` includes:
+
+```
+{
+  treeCache: {    // Same options as `xache`
+    maxSize: 8192 // Max number of tree nodes to cache
+  }
+}
+```
+
 #### `core = await store.createCore({ key, discoveyKey, manifest?, keyPair?, encryptionKey?, userData? })`
 
 Create a new core, returns a storage instance for that core.

package/index.js

@@ -4,6 +4,7 @@ const ScopeLock = require('scope-lock')
 const DeviceFile = require('device-file')
 const path = require('path')
 const fs = require('fs')
+const Xache = require('xache')
 
 const View = require('./lib/view.js')
 
@@ -84,7 +85,7 @@ class Atom {
 }
 
 class HypercoreStorage {
-  constructor(store, db, core, view, atom) {
+  constructor(store, db, treeCache, core, view, atom) {
     this.store = store
     this.db = db
     this.core = core
@@ -92,6 +93,7 @@ class HypercoreStorage {
     this.atom = atom
 
     this.view.readStart()
+    this.treeCache = treeCache
   }
 
   get readOnly() {
@@ -201,6 +203,7 @@ class HypercoreStorage {
     return new HypercoreStorage(
       this.store,
       this.db.snapshot(),
+      this.treeCache,
       this.core,
       this.view.snapshot(),
       this.atom
@@ -218,7 +221,15 @@ class HypercoreStorage {
     if (this.atom && this.atom !== atom) {
       throw new Error('Cannot atomize and atomized session with a new atom')
     }
-    return new HypercoreStorage(this.store, this.db.session(), this.core, atom.view, atom)
+
+    return new HypercoreStorage(
+      this.store,
+      this.db.session(),
+      this.treeCache,
+      this.core,
+      atom.view,
+      atom
+    )
   }
 
   createAtom() {
@@ -267,7 +278,7 @@ class HypercoreStorage {
       dependencies: []
     }
 
-    const coreRx = new CoreRX(core, this.db, this.view)
+    const coreRx = new CoreRX(core, this.db, this.view, this.treeCache, this.store.stats, -1)
 
     const dependencyPromise = coreRx.getDependency()
     coreRx.tryFlush()
@@ -278,6 +289,7 @@ class HypercoreStorage {
     return new HypercoreStorage(
       this.store,
       this.db.session(),
+      this.treeCache,
       core,
       this.atom ? this.view : new View(),
       this.atom
@@ -341,6 +353,7 @@ class HypercoreStorage {
     return new HypercoreStorage(
       this.store,
       this.db.session(),
+      this.treeCache,
       core,
       this.atom ? this.view : new View(),
       this.atom
@@ -412,8 +425,11 @@ class HypercoreStorage {
     await tx.flush()
   }
 
-  read() {
-    return new CoreRX(this.core, this.db, this.view)
+  read(fork = -1) {
+    let treeCache = null
+    if (!this.atom) treeCache = this.treeCache
+
+    return new CoreRX(this.core, this.db, this.view, treeCache, this.store.stats, fork)
   }
 
   write() {
@@ -430,7 +446,7 @@ class HypercoreStorage {
   }
 
   static async export(ptr, db, { batches = false } = {}) {
-    const rx = new CoreRX(ptr, db, EMPTY)
+    const rx = new CoreRX(ptr, db, EMPTY, null, null, -1)
 
     const core = {
       head: null,
@@ -507,8 +523,19 @@ class CorestoreStorage {
 
     const dbPath = path.join(this.path, 'db')
 
+    this.stats = {
+      treeCache: {
+        hits: 0,
+        misses: 0,
+        parallel: 0,
+        skips: 0
+      }
+    }
     this.rocks = storage === null ? db : new RocksDB(dbPath, { ...opts, lock: this.deviceFile })
     this.db = createColumnFamily(this.rocks, opts)
+
+    const { treeCache = { maxSize: 8192 } } = opts
+    this.treeCache = new Xache(treeCache)
   }
 
   get opened() {
@@ -530,7 +557,7 @@ class CorestoreStorage {
 
   async audit() {
     for await (const { core } of this.createCoreStream()) {
-      const coreRx = new CoreRX(core, this.db, EMPTY)
+      const coreRx = new CoreRX(core, this.db, EMPTY, this.treeCache, this.stats, -1)
       const authPromise = coreRx.getAuth()
 
       coreRx.tryFlush()
@@ -548,7 +575,7 @@ class CorestoreStorage {
   }
 
   async deleteCore(ptr) {
-    const rx = new CoreRX(ptr, this.db, EMPTY)
+    const rx = new CoreRX(ptr, this.db, EMPTY, this.treeCache, this.stats, -1)
 
     const authPromise = rx.getAuth()
     const sessionsPromise = rx.getSessions()
@@ -782,6 +809,7 @@ class CorestoreStorage {
     await this._flush()
     await this.db.close()
     await this.rocks.close()
+    this.treeCache.destroy()
     if (this.deviceFile) await this.deviceFile.close()
   }
 
@@ -1053,7 +1081,14 @@ class CorestoreStorage {
     const ptr = { corePointer, dataPointer, dependencies: [] }
 
     while (true) {
-      const rx = new CoreRX({ dataPointer, corePointer: 0, dependencies: [] }, this.db, EMPTY)
+      const rx = new CoreRX(
+        { dataPointer, corePointer: 0, dependencies: [] },
+        this.db,
+        EMPTY,
+        this.treeCache,
+        this.stats,
+        -1
+      )
       const dependencyPromise = rx.getDependency()
       rx.tryFlush()
       const dependency = await dependencyPromise
@@ -1074,7 +1109,14 @@ class CorestoreStorage {
     const core = { corePointer, dataPointer, dependencies: [] }
 
     while (true) {
-      const rx = new CoreRX({ dataPointer, corePointer: 0, dependencies: [] }, this.db, view)
+      const rx = new CoreRX(
+        { dataPointer, corePointer: 0, dependencies: [] },
+        this.db,
+        view,
+        this.treeCache,
+        this.stats,
+        -1
+      )
       const dependencyPromise = rx.getDependency()
       rx.tryFlush()
       const dependency = await dependencyPromise
@@ -1083,7 +1125,7 @@ class CorestoreStorage {
       dataPointer = dependency.dataPointer
     }
 
-    const result = new HypercoreStorage(this, this.db.session(), core, EMPTY, null)
+    const result = new HypercoreStorage(this, this.db.session(), this.treeCache, core, EMPTY, null)
 
     if (version < VERSION) await this._migrateCore(result, discoveryKey, version, create)
     return result
@@ -1136,7 +1178,7 @@ class CorestoreStorage {
 
     tx.apply()
 
-    return new HypercoreStorage(this, this.db.session(), ptr, EMPTY, null)
+    return new HypercoreStorage(this, this.db.session(), this.treeCache, ptr, EMPTY, null)
   }
 
   async createCore(data) {

package/lib/tx.js

@@ -176,39 +176,42 @@ class CoreTX {
 }
 
 class CoreRX {
-  constructor(core, db, view) {
+  constructor(core, db, view, treeCache, stats, fork) {
     this.core = core
     this.read = db.read({ autoDestroy: true })
     this.view = view
+    this.treeCache = treeCache
+    this.fork = fork
+    this.stats = stats
 
     view.readStart()
   }
 
   static async getAuth(db, c) {
-    return await decode(CORE_AUTH, await db.get(core.auth(c.corePointer)))
+    return decode(CORE_AUTH, await db.get(core.auth(c.corePointer)))
   }
 
   async getAuth() {
-    return await decode(CORE_AUTH, await this.view.get(this.read, core.auth(this.core.corePointer)))
+    return decode(CORE_AUTH, await this.view.get(this.read, core.auth(this.core.corePointer)))
   }
 
   async getSessions() {
-    return await decode(
+    return decode(
       CORE_SESSIONS,
       await this.view.get(this.read, core.sessions(this.core.corePointer))
     )
   }
 
   static async getHead(db, c) {
-    return await decode(CORE_HEAD, await db.get(core.head(c.dataPointer)))
+    return decode(CORE_HEAD, await db.get(core.head(c.dataPointer)))
   }
 
   async getHead() {
-    return await decode(CORE_HEAD, await this.view.get(this.read, core.head(this.core.dataPointer)))
+    return decode(CORE_HEAD, await this.view.get(this.read, core.head(this.core.dataPointer)))
   }
 
   async getDependency() {
-    return await decode(
+    return decode(
       CORE_DEPENDENCY,
       await this.view.get(this.read, core.dependency(this.core.dataPointer))
     )
@@ -222,14 +225,11 @@ class CoreRX {
   }
 
   static async getHints(db, c) {
-    return await decode(CORE_HINTS, await db.get(core.hints(c.dataPointer)))
+    return decode(CORE_HINTS, await db.get(core.hints(c.dataPointer)))
   }
 
   async getHints() {
-    return await decode(
-      CORE_HINTS,
-      await this.view.get(this.read, core.hints(this.core.dataPointer))
-    )
+    return decode(CORE_HINTS, await this.view.get(this.read, core.hints(this.core.dataPointer)))
   }
 
   getBlock(index) {
@@ -242,10 +242,64 @@ class CoreRX {
     return this.view.get(this.read, core.bitfield(this.core.dataPointer, index, 0))
   }
 
+  async _resolveTreeCache(key, promise, entry) {
+    try {
+      const value = decode(CORE_TREE_NODE, await promise)
+      const cached = this.treeCache.get(key)
+
+      // preflight is gone; no-op
+      if (cached !== entry) return value
+
+      if (value !== null) {
+        // replace cached entry with value
+        this.treeCache.set(key, { pending: null, value })
+      } else {
+        // discard non-existing values
+        this.treeCache.delete(key)
+      }
+
+      return value
+    } catch (err) {
+      // cleanup
+      const cached = this.treeCache.get(key)
+      if (cached === entry) {
+        this.treeCache.delete(key)
+      }
+
+      throw err
+    }
+  }
+
   async getTreeNode(index) {
     const dep = findTreeDependency(this.core.dependencies, index)
     const data = dep === null ? this.core.dataPointer : dep.dataPointer
-    return decode(CORE_TREE_NODE, await this.view.get(this.read, core.tree(data, index)))
+
+    if (!this.treeCache || this.fork < 0) {
+      if (this.stats !== null) this.stats.treeCache.skips++
+      // no-cache
+      return decode(CORE_TREE_NODE, await this.view.get(this.read, core.tree(data, index)))
+    }
+
+    const key = `${data}:${index}:${this.fork}`
+    let entry = this.treeCache.get(key)
+    if (entry) {
+      if (entry.pending) {
+        if (this.stats !== null) this.stats.treeCache.parallel++
+        return entry.pending
+      }
+
+      if (this.stats !== null) this.stats.treeCache.hits++
+      return entry.value
+    }
+
+    if (this.stats !== null) this.stats.treeCache.misses++
+
+    const promise = this.view.get(this.read, core.tree(data, index))
+    entry = { pending: null, value: null }
+    entry.pending = this._resolveTreeCache(key, promise, entry)
+    this.treeCache.set(key, entry)
+
+    return entry.pending
   }
 
   async hasTreeNode(index) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypercore-storage",
-  "version": "3.1.2",
+  "version": "3.2.0",
   "main": "index.js",
   "files": [
     "index.js",
@@ -58,7 +58,8 @@
     "resolve-reject-promise": "^1.0.0",
     "rocksdb-native": "^3.11.0",
     "scope-lock": "^1.2.4",
-    "streamx": "^2.21.1"
+    "streamx": "^2.21.1",
+    "xache": "^1.2.1"
   },
   "devDependencies": {
     "bare-os": "^3.9.1",