new benchmarker/benchmarks; keeps old benchmarks

benchmarks/append.benchmark.js

@@ -0,0 +1,37 @@
+'use strict'
+const Ipfs = require('ipfs')
+const { createLog, height } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log } = await createLog(ipfs, 'A')
+
+  let i = 0
+  let appends = 0
+  benchmarker.trackMemory()
+  benchmarker.addMetric({
+    name: 'appends',
+    get: () => i
+  })
+  benchmarker.addMetric({
+    name: 'appends per second',
+    get: () => {
+      const perSecond = i - appends
+      appends = i
+      return perSecond
+    }
+  })
+
+  benchmarker.log('appending the log...')
+  benchmarker.startRecording()
+  for (; i < height; i++) {
+    await log.append(Date.now(), 32)
+  }
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/find-heads.benchmark.js

@@ -0,0 +1,21 @@
+'use strict'
+const Ipfs = require('ipfs')
+const Log = require('../src/log')
+const { createLog, height, appendEntries } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log } = await createLog(ipfs, 'A')
+
+  const { entries } = await appendEntries(log, height, { withEntries: true })
+
+  benchmarker.startRecording()
+  Log.findHeads(entries)
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/from-entry-hash.benchmark.js

@@ -0,0 +1,22 @@
+'use strict'
+const Ipfs = require('ipfs')
+const Log = require('../src/log')
+const { createLog, height, appendEntries } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log, identity, access } = await createLog(ipfs, 'A')
+
+  await appendEntries(log, height, { refCount: 64 })
+
+  benchmarker.trackMemory()
+  benchmarker.startRecording()
+  await Log.fromEntryHash(ipfs, identity, log.heads.map(e => e.hash), { access, logId: log._id })
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/get.benchmark.js

@@ -0,0 +1,23 @@
+'use strict'
+const Ipfs = require('ipfs')
+const { createLog, height, appendEntries } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log } = await createLog(ipfs, 'A')
+
+  await appendEntries(log, height)
+  const values = log.values
+
+  benchmarker.startRecording()
+  for (const { hash } of values) {
+    log.get(hash)
+  }
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/has.benchmark.js

@@ -0,0 +1,23 @@
+'use strict'
+const Ipfs = require('ipfs')
+const { createLog, height, appendEntries } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log } = await createLog(ipfs, 'A')
+
+  await appendEntries(log, height)
+  const values = log.values
+
+  benchmarker.startRecording()
+  for (const { hash } of values) {
+    log.has(hash)
+  }
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/heads.benchmark.js

@@ -0,0 +1,23 @@
+'use strict'
+const Ipfs = require('ipfs')
+const { createLog, height, appendEntries } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log } = await createLog(ipfs, 'A')
+
+  await appendEntries(log, height)
+
+  const cycle = () => log.heads
+  benchmarker.startRecording()
+  for (let i = 0; i < height; i++) {
+    cycle()
+  }
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/join.benchmark.js

@@ -0,0 +1,24 @@
+'use strict'
+const Ipfs = require('ipfs')
+const { createLog, height } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log: logA } = await createLog(ipfs, 'A')
+  const { log: logB } = await createLog(ipfs, 'B')
+
+  benchmarker.trackMemory()
+  benchmarker.startRecording()
+  for (let i = 0; i < height; i++) {
+    const now = Date.now()
+    await Promise.all([logA.append(now), logB.append(now)])
+    await Promise.all([logA.join(logB), logB.join(logA)])
+  }
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/tail-hashes.benchmark.js

@@ -0,0 +1,23 @@
+'use strict'
+const Ipfs = require('ipfs')
+const { createLog, height, appendEntries } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log } = await createLog(ipfs, 'A')
+
+  await appendEntries(height)
+
+  const cycle = () => log.tailHashes
+  benchmarker.startRecording()
+  for (let i = 0; i < height; i++) {
+    cycle()
+  }
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/tails.benchmark.js

@@ -0,0 +1,23 @@
+'use strict'
+const Ipfs = require('ipfs')
+const { createLog, height, appendEntries } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log } = await createLog(ipfs, 'A')
+
+  await appendEntries(height)
+
+  const cycle = () => log.tails
+  benchmarker.startRecording()
+  for (let i = 0; i < height; i++) {
+    cycle()
+  }
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/traverse.benchmark.js

@@ -0,0 +1,23 @@
+'use strict'
+const Ipfs = require('ipfs')
+const { createLog, height, appendEntries } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log } = await createLog(ipfs, 'A')
+
+  await appendEntries(height)
+
+  const cycle = () => log.traverse(log.heads)
+  benchmarker.startRecording()
+  for (let i = 0; i < height; i++) {
+    cycle()
+  }
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}

benchmarks/utils/create-log.js

@@ -1,7 +1,7 @@
 const Keystore = require('orbit-db-keystore')
 const IdentityProvider = require('orbit-db-identity-provider')
-const leveldown = require('leveldown')
-const storage = require('orbit-db-storage-adapter')(leveldown)
+const level = require('level')
+const storage = require('orbit-db-storage-adapter')(level)
 
 const Log = require('../../src/log')
 const AccessController = Log.AccessController

benchmarks/utils/index.js

@@ -0,0 +1,15 @@
+'use strict'
+const appendEntries = async (log, height, { refCount, withEntries } = {}) => {
+  const entries = []
+  for (let i = 0; i < height; i++) {
+    const entry = await log.append(Date.now(), refCount)
+    if (withEntries) entries.push(entry)
+  }
+  return { entries }
+}
+
+module.exports = {
+  createLog: require('./create-log'),
+  height: 5000,
+  appendEntries
+}

benchmarks/values.benchmark.js

@@ -0,0 +1,23 @@
+'use strict'
+const Ipfs = require('ipfs')
+const { createLog, height, appendEntries } = require('./utils')
+
+async function benchmark (benchmarker) {
+  const ipfs = await Ipfs.create({ repo: benchmarker.dir + '/ipfs' })
+  const { log } = await createLog(ipfs, 'A')
+
+  await appendEntries(height)
+
+  const cycle = () => log.values
+  benchmarker.startRecording()
+  for (let i = 0; i < height; i++) {
+    cycle()
+  }
+  benchmarker.stopRecording()
+
+  await ipfs.stop()
+}
+
+module.exports = {
+  benchmark
+}