add benchmark files

Asmod4n · Asmod4n · commit 995f6529f771 · 2026-03-28T19:48:05.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -36,4 +36,8 @@ build/
 compile_commands.json
 build_config.rb.lock
 .cache
-mruby
+mruby
+benchmark/bench_c_lmdb
+node_modules/
+package.json
+package-lock.json
diff --git a/benchmark/bench_c_lmdb.c b/benchmark/bench_c_lmdb.c
@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <lmdb.h>
+
+#define N        10000
+#define VAL_SIZE 100
+#define MAP_SIZE (256UL * 1024 * 1024)
+
+static double now_ms(void) {
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return ts.tv_sec * 1000.0 + ts.tv_nsec / 1.0e6;
+}
+
+static void check(int rc, const char *msg) {
+    if (rc != 0) { fprintf(stderr, "%s: %s\n", msg, mdb_strerror(rc)); exit(1); }
+}
+
+int main(void) {
+    MDB_env *env; MDB_dbi dbi; MDB_txn *txn; MDB_cursor *cursor;
+    MDB_val key, data;
+    char keybuf[32], valbuf[VAL_SIZE];
+    double t0, t1;
+    int rc;
+
+    memset(valbuf, 'x', VAL_SIZE);
+
+    const char *path = "/tmp/bench_c_lmdb";
+    mkdir(path, 0755);
+    check(mdb_env_create(&env), "env_create");
+    check(mdb_env_set_mapsize(env, MAP_SIZE), "set_mapsize");
+    check(mdb_env_open(env, path, MDB_NOSYNC | MDB_NOMETASYNC, 0644), "env_open");
+    check(mdb_txn_begin(env, NULL, 0, &txn), "txn_begin");
+    check(mdb_dbi_open(txn, NULL, 0, &dbi), "dbi_open");
+    check(mdb_txn_commit(txn), "txn_commit");
+
+    printf("=== C LMDB Benchmark (%d records, %d-byte values) ===\n\n", N, VAL_SIZE);
+
+    /* 1. N writes, 1 txn each */
+    t0 = now_ms();
+    for (int i = 0; i < N; i++) {
+        int len = snprintf(keybuf, sizeof(keybuf), "key:%08d", i);
+        key.mv_data = keybuf; key.mv_size = len;
+        data.mv_data = valbuf; data.mv_size = VAL_SIZE;
+        check(mdb_txn_begin(env, NULL, 0, &txn), "txn_begin");
+        check(mdb_put(txn, dbi, &key, &data, 0), "put");
+        check(mdb_txn_commit(txn), "txn_commit");
+    }
+    t1 = now_ms();
+    printf("1. Write (1 txn each):   %8.1f ms  (%7.0f ops/s)\n",
+           t1-t0, N/((t1-t0)/1000.0));
+
+    /* 2. N writes, 1 txn total */
+    check(mdb_txn_begin(env, NULL, 0, &txn), "txn_begin");
+    check(mdb_drop(txn, dbi, 0), "drop");
+    check(mdb_txn_commit(txn), "txn_commit");
+
+    t0 = now_ms();
+    check(mdb_txn_begin(env, NULL, 0, &txn), "txn_begin");
+    for (int i = 0; i < N; i++) {
+        int len = snprintf(keybuf, sizeof(keybuf), "key:%08d", i);
+        key.mv_data = keybuf; key.mv_size = len;
+        data.mv_data = valbuf; data.mv_size = VAL_SIZE;
+        check(mdb_put(txn, dbi, &key, &data, 0), "put");
+    }
+    check(mdb_txn_commit(txn), "txn_commit");
+    t1 = now_ms();
+    printf("2. Write (1 txn total):  %8.1f ms  (%7.0f ops/s)\n",
+           t1-t0, N/((t1-t0)/1000.0));
+
+    /* 3. N reads, 1 txn each */
+    t0 = now_ms();
+    for (int i = 0; i < N; i++) {
+        int len = snprintf(keybuf, sizeof(keybuf), "key:%08d", i);
+        key.mv_data = keybuf; key.mv_size = len;
+        check(mdb_txn_begin(env, NULL, MDB_RDONLY, &txn), "txn_begin");
+        mdb_get(txn, dbi, &key, &data);
+        mdb_txn_abort(txn);
+    }
+    t1 = now_ms();
+    printf("3. Read  (1 txn each):   %8.1f ms  (%7.0f ops/s)\n",
+           t1-t0, N/((t1-t0)/1000.0));
+
+    /* 4. N reads, 1 txn total (cursor scan) */
+    int count = 0;
+    t0 = now_ms();
+    check(mdb_txn_begin(env, NULL, MDB_RDONLY, &txn), "txn_begin");
+    check(mdb_cursor_open(txn, dbi, &cursor), "cursor_open");
+    while (mdb_cursor_get(cursor, &key, &data, count == 0 ? MDB_FIRST : MDB_NEXT) == 0)
+        count++;
+    mdb_cursor_close(cursor);
+    mdb_txn_abort(txn);
+    t1 = now_ms();
+    printf("4. Read  (1 txn total):  %8.1f ms  (%7.0f ops/s)\n",
+           t1-t0, count/((t1-t0)/1000.0));
+
+    /* 5. Prefix scan */
+    check(mdb_txn_begin(env, NULL, 0, &txn), "txn_begin");
+    for (int i = 0; i < N; i++) {
+        int len = snprintf(keybuf, sizeof(keybuf), "user:%06d", i);
+        key.mv_data = keybuf; key.mv_size = len;
+        data.mv_data = valbuf; data.mv_size = VAL_SIZE;
+        mdb_put(txn, dbi, &key, &data, 0);
+    }
+    check(mdb_txn_commit(txn), "txn_commit");
+
+    const char *prefix = "user:";
+    size_t plen = strlen(prefix);
+    count = 0;
+    t0 = now_ms();
+    check(mdb_txn_begin(env, NULL, MDB_RDONLY, &txn), "txn_begin");
+    check(mdb_cursor_open(txn, dbi, &cursor), "cursor_open");
+    key.mv_data = (void*)prefix; key.mv_size = plen;
+    rc = mdb_cursor_get(cursor, &key, &data, MDB_SET_RANGE);
+    while (rc == 0) {
+        if (key.mv_size < plen || memcmp(key.mv_data, prefix, plen) != 0) break;
+        count++;
+        rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT);
+    }
+    mdb_cursor_close(cursor);
+    mdb_txn_abort(txn);
+    t1 = now_ms();
+    printf("5. Prefix scan (%d):    %8.1f ms  (%7.0f ops/s)\n",
+           count, t1-t0, count/((t1-t0)/1000.0));
+
+    mdb_env_close(env);
+    system("rm -rf /tmp/bench_c_lmdb");
+    return 0;
+}
diff --git a/benchmark/bench_mruby_lmdb.rb b/benchmark/bench_mruby_lmdb.rb
@@ -0,0 +1,66 @@
+N        = 10_000
+VAL_SIZE = 100
+MAPSIZE  = 256 * 1024 * 1024
+
+def now_ms
+  Time.now.to_f * 1000.0
+end
+
+def fmt(n, ms)
+  ops = (n / (ms / 1000.0)).to_i
+  "#{ms.to_i.to_s.rjust(8)} ms  (#{ops.to_s.rjust(7)} ops/s)"
+end
+
+path  = "/tmp/bench-mruby-lmdb-#{$$}"
+value = "x" * VAL_SIZE
+
+env = MDB::Env.new(mapsize: MAPSIZE)
+env.open(path, MDB::NOSUBDIR | MDB::NOSYNC | MDB::NOMETASYNC)
+db = env.database
+
+puts "=== mruby LMDB Benchmark (#{N} records, #{VAL_SIZE}-byte values) ==="
+puts
+
+# 1. N writes, 1 txn each
+t0 = now_ms
+N.times { |i| db["key:%08d" % i] = value }
+t1 = now_ms
+puts "1. Write (1 txn each):   #{fmt(N, t1 - t0)}"
+
+# 2. N writes, 1 txn total
+db.drop
+t0 = now_ms
+env.transaction do |txn|
+  dbi = db.dbi
+  N.times { |i| MDB.put(txn, dbi, "key:%08d" % i, value) }
+end
+t1 = now_ms
+puts "2. Write (1 txn total):  #{fmt(N, t1 - t0)}"
+
+# 3. N reads, 1 txn each
+t0 = now_ms
+N.times { |i| db["key:%08d" % i] }
+t1 = now_ms
+puts "3. Read  (1 txn each):   #{fmt(N, t1 - t0)}"
+
+# 4. N reads, 1 txn total (cursor scan)
+count = 0
+t0 = now_ms
+db.each { count += 1 }
+t1 = now_ms
+puts "4. Read  (1 txn total):  #{fmt(count, t1 - t0)}"
+
+# 5. Prefix scan
+env.transaction do |txn|
+  dbi = db.dbi
+  N.times { |i| MDB.put(txn, dbi, "user:%06d" % i, value) }
+end
+count = 0
+t0 = now_ms
+db.each_prefix("user:") { count += 1 }
+t1 = now_ms
+puts "5. Prefix scan (#{count}):   #{fmt(count, t1 - t0)}"
+
+env.close
+File.delete(path) rescue nil
+File.delete("#{path}-lock") rescue nil
diff --git a/benchmark/bench_node_lmdb.js b/benchmark/bench_node_lmdb.js
@@ -0,0 +1,75 @@
+const { open } = require('lmdb');
+const fs = require('fs');
+
+const N        = 10_000;
+const VAL_SIZE = 100;
+
+function nowMs() {
+    const [s, ns] = process.hrtime();
+    return s * 1000 + ns / 1e6;
+}
+
+function fmt(n, ms) {
+    return `${ms.toFixed(1).padStart(8)} ms  (${Math.round(n/(ms/1000)).toString().padStart(7)} ops/s)`;
+}
+
+async function main() {
+    const value = 'x'.repeat(VAL_SIZE);
+    const path  = '/tmp/bench_node_lmdb';
+
+    if (fs.existsSync(path)) fs.rmSync(path, { recursive: true });
+    fs.mkdirSync(path, { recursive: true });
+
+    const db = open({ path, mapSize: 256*1024*1024, noSync: true, noMetaSync: true, encoding: 'binary' });
+
+    console.log(`=== Node.js LMDB Benchmark (${N} records, ${VAL_SIZE}-byte values) ===\n`);
+
+    // 1. N writes, 1 txn each
+    let t0 = nowMs();
+    for (let i = 0; i < N; i++)
+        await db.transaction(() => { db.put(`key:${String(i).padStart(8,'0')}`, value); });
+    let t1 = nowMs();
+    console.log(`1. Write (1 txn each):   ${fmt(N, t1-t0)}`);
+
+    // 2. N writes, 1 txn total
+    await db.clearAsync();
+    t0 = nowMs();
+    await db.transaction(() => {
+        for (let i = 0; i < N; i++)
+            db.put(`key:${String(i).padStart(8,'0')}`, value);
+    });
+    t1 = nowMs();
+    console.log(`2. Write (1 txn total):  ${fmt(N, t1-t0)}`);
+
+    // 3. N reads, 1 txn each
+    t0 = nowMs();
+    for (let i = 0; i < N; i++)
+        db.get(`key:${String(i).padStart(8,'0')}`);
+    t1 = nowMs();
+    console.log(`3. Read  (1 txn each):   ${fmt(N, t1-t0)}`);
+
+    // 4. N reads, 1 txn total (cursor scan)
+    let count = 0;
+    t0 = nowMs();
+    for (const _ of db.getRange())
+        count++;
+    t1 = nowMs();
+    console.log(`4. Read  (1 txn total):  ${fmt(count, t1-t0)}`);
+
+    // 5. Prefix scan
+    await db.transaction(() => {
+        for (let i = 0; i < N; i++)
+            db.put(`user:${String(i).padStart(6,'0')}`, value);
+    });
+    count = 0;
+    t0 = nowMs();
+    for (const { key } of db.getRange({ start: 'user:', end: 'user;' }))
+        count++;
+    t1 = nowMs();
+    console.log(`5. Prefix scan (${count}):   ${fmt(count, t1-t0)}`);
+
+    await db.close();
+    fs.rmSync(path, { recursive: true, force: true });
+}
+
+main().catch(console.error);
diff --git a/benchmark/bench_python_lmdb.py b/benchmark/bench_python_lmdb.py
@@ -0,0 +1,75 @@
+import os, time, shutil, lmdb
+
+N        = 10_000
+VAL_SIZE = 100
+MAP_SIZE = 256 * 1024 * 1024
+
+def now_ms():
+    return time.monotonic() * 1000.0
+
+def fmt(n, ms):
+    return f"{ms:8.1f} ms  ({n/(ms/1000):7.0f} ops/s)"
+
+path  = "/tmp/bench_python_lmdb"
+value = b'x' * VAL_SIZE
+
+if os.path.exists(path): shutil.rmtree(path)
+os.makedirs(path)
+env = lmdb.open(path, map_size=MAP_SIZE, sync=False, metasync=False)
+
+print(f"=== Python LMDB Benchmark ({N} records, {VAL_SIZE}-byte values) ===\n")
+
+# 1. N writes, 1 txn each
+t0 = now_ms()
+for i in range(N):
+    with env.begin(write=True) as txn:
+        txn.put(f"key:{i:08d}".encode(), value)
+t1 = now_ms()
+print(f"1. Write (1 txn each):   {fmt(N, t1-t0)}")
+
+# 2. N writes, 1 txn total
+with env.begin(write=True) as txn:
+    txn.drop(env.open_db(), delete=False)
+t0 = now_ms()
+with env.begin(write=True) as txn:
+    for i in range(N):
+        txn.put(f"key:{i:08d}".encode(), value)
+t1 = now_ms()
+print(f"2. Write (1 txn total):  {fmt(N, t1-t0)}")
+
+# 3. N reads, 1 txn each
+t0 = now_ms()
+for i in range(N):
+    with env.begin() as txn:
+        txn.get(f"key:{i:08d}".encode())
+t1 = now_ms()
+print(f"3. Read  (1 txn each):   {fmt(N, t1-t0)}")
+
+# 4. N reads, 1 txn total (cursor scan)
+count = 0
+t0 = now_ms()
+with env.begin() as txn:
+    cursor = txn.cursor()
+    for _ in cursor.iternext():
+        count += 1
+t1 = now_ms()
+print(f"4. Read  (1 txn total):  {fmt(count, t1-t0)}")
+
+# 5. Prefix scan
+with env.begin(write=True) as txn:
+    for i in range(N):
+        txn.put(f"user:{i:06d}".encode(), value)
+prefix = b"user:"
+count = 0
+t0 = now_ms()
+with env.begin() as txn:
+    cursor = txn.cursor()
+    cursor.set_range(prefix)
+    for k, _ in cursor:
+        if not k.startswith(prefix): break
+        count += 1
+t1 = now_ms()
+print(f"5. Prefix scan ({count}):   {fmt(count, t1-t0)}")
+
+env.close()
+shutil.rmtree(path, ignore_errors=True)
diff --git a/benchmark/run_all.sh b/benchmark/run_all.sh
