diff --git a/.github/scripts/bench_logs_to_pages.py b/.github/scripts/bench_logs_to_pages.py
new file mode 100644
index 0000000000..4331afe26d
--- /dev/null
+++ b/.github/scripts/bench_logs_to_pages.py
@@ -0,0 +1,833 @@
+#!/usr/bin/env python3
+"""Parse db_bench / memtablerep_bench logs and maintain GitHub Pages site trees.
+
+Supports multi-engine comparison (topling / topling-dictzip10 / rocksdb-*).
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import re
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+DB_BENCH_RE = re.compile(
+    r"^(?P<name>\S+)\s*:\s*"
+    r"(?P<micros>[\d.]+)\s+micros/op\s+"
+    r"(?P<ops>\d+)\s+ops/sec\s+"
+    r"(?P<seconds>[\d.]+)\s+seconds\s+"
+    r"(?P<operations>\d+)\s+operations;"
+    r"(?P<extra>.*)$"
+)
+RUNNING_RE = re.compile(r"^Running\s+(?P<name>\S+)\s*$")
+METRIC_RE = re.compile(
+    r"^(?P<label>Total bytes written|Write throughput|write us/op|"
+    r"Total bytes read|Read throughput|read us/op|Elapsed time|"
+    r"Number of threads)\s*:\s*(?P<value>.+)$"
+)
+
+ENGINES = ("topling", "topling-dictzip10", "rocksdb-v8.10", "rocksdb-master")
+TOPLING_ENGINES = ("topling", "topling-dictzip10")
+ROCKSDB_ENGINES = ("rocksdb-v8.10", "rocksdb-master")
+# memtablerep is identical across Topling yaml variants; only default topling runs it.
+MEMTABLE_ENGINES = ("topling", "rocksdb-v8.10", "rocksdb-master")
+ENGINE_LABELS = {
+    "topling": "ToplingDB",
+    "topling-dictzip10": "ToplingDB minDictZip=10",
+    "rocksdb-v8.10": "RocksDB v8.10",
+    "rocksdb-master": "RocksDB master",
+}
+# Short labels for ratio column headers.
+RATIO_BASE_LABELS = {
+    "topling": "Topling",
+    "topling-dictzip10": "dictzip10",
+}
+RATIO_OTHER_LABELS = {
+    "rocksdb-v8.10": "v8.10",
+    "rocksdb-master": "master",
+}
+
+
+def parse_shm_usage(text: str) -> Optional[Dict[str, int]]:
+    apparent: Optional[int] = None
+    allocated: Optional[int] = None
+    for line in text.splitlines():
+        line = line.strip()
+        if line.startswith("apparent_bytes="):
+            apparent = int(line.split("=", 1)[1])
+        elif line.startswith("allocated_bytes="):
+            allocated = int(line.split("=", 1)[1])
+    if apparent is None or allocated is None:
+        return None
+    return {"apparent_bytes": apparent, "allocated_bytes": allocated}
+
+
+def format_iec(num_bytes: int) -> str:
+    """IEC human-readable (1024), one decimal place, e.g. 850.0MiB / 1.2GiB."""
+    n = float(num_bytes)
+    units = ("B", "KiB", "MiB", "GiB", "TiB")
+    idx = 0
+    while n >= 1024.0 and idx < len(units) - 1:
+        n /= 1024.0
+        idx += 1
+    if idx == 0:
+        return f"{int(num_bytes)}B"
+    return f"{n:.1f}{units[idx]}"
+
+
+SHM_WORKLOADS = ("fillrandom", "fillseq")
+
+
+def load_shm_usages(eng_dir: Path) -> Dict[str, Optional[Dict[str, int]]]:
+    """Load per-workload shm usage; legacy shm_usage.txt maps to fillseq."""
+    out: Dict[str, Optional[Dict[str, int]]] = {}
+    for wl in SHM_WORKLOADS:
+        path = eng_dir / f"shm_usage-{wl}.txt"
+        if path.is_file():
+            out[wl] = parse_shm_usage(
+                path.read_text(encoding="utf-8", errors="replace")
+            )
+        else:
+            out[wl] = None
+    legacy = eng_dir / "shm_usage.txt"
+    if out.get("fillseq") is None and legacy.is_file():
+        out["fillseq"] = parse_shm_usage(
+            legacy.read_text(encoding="utf-8", errors="replace")
+        )
+    return out
+
+
+def _size_ratio_cell(
+    base_bytes: Optional[int], other_bytes: Optional[int]
+) -> str:
+    """ratio = other / base; &lt;1 means other uses less space (better compression)."""
+    if base_bytes is None or other_bytes is None or base_bytes <= 0:
+        return "—"
+    ratio = other_bytes / base_bytes
+    cls = "faster" if ratio < 1.0 else "slower"
+    return f'<span class="{cls}">{ratio:.2f}x</span>'
+
+
+def build_shm_usage_table(
+    usages: Dict[str, Dict[str, Optional[Dict[str, int]]]],
+) -> str:
+    """Wide space compare: allocated bytes per engine + dictzip10/Topling size ratio."""
+
+    def _bytes(eng: str, wl: str, key: str) -> Optional[int]:
+        u = (usages.get(eng) or {}).get(wl)
+        if not u:
+            return None
+        return u.get(key)
+
+    headers = ["workload"]
+    for e in ENGINES:
+        headers.append(ENGINE_LABELS[e])
+    headers.append("dictzip10 / Topling (space)")
+
+    rows_html = []
+    for wl in SHM_WORKLOADS:
+        cells = [f"<td>{html.escape(wl)}</td>"]
+        for e in ENGINES:
+            b = _bytes(e, wl, "allocated_bytes")
+            cells.append(
+                f"<td>{html.escape(format_iec(b)) if b is not None else 'n/a'}</td>"
+            )
+        cells.append(
+            f"<td>{_size_ratio_cell(_bytes('topling', wl, 'allocated_bytes'), _bytes('topling-dictzip10', wl, 'allocated_bytes'))}</td>"
+        )
+        rows_html.append("<tr>" + "".join(cells) + "</tr>")
+    if not rows_html:
+        rows_html.append(
+            f'<tr><td colspan="{len(headers)}"><em>no rows</em></td></tr>'
+        )
+    th = "".join(f"<th>{html.escape(h)}</th>" for h in headers)
+    return (
+        "<table>\n<thead><tr>"
+        + th
+        + "</tr></thead>\n<tbody>\n"
+        + "\n".join(rows_html)
+        + "\n</tbody>\n</table>"
+    )
+
+
+def parse_db_bench(text: str) -> List[Dict[str, str]]:
+    rows: List[Dict[str, str]] = []
+    for line in text.splitlines():
+        m = DB_BENCH_RE.match(line.strip())
+        if not m:
+            continue
+        rows.append(
+            {
+                "benchmark": m.group("name"),
+                "micros/op": m.group("micros"),
+                "ops/sec": m.group("ops"),
+                "seconds": m.group("seconds"),
+                "operations": m.group("operations"),
+                "extra": m.group("extra").strip(),
+            }
+        )
+    return rows
+
+
+def parse_memtablerep(text: str) -> List[Dict[str, str]]:
+    rows: List[Dict[str, str]] = []
+    current: Optional[str] = None
+    for line in text.splitlines():
+        stripped = line.strip()
+        rm = RUNNING_RE.match(stripped)
+        if rm:
+            current = rm.group("name")
+            continue
+        mm = METRIC_RE.match(stripped)
+        if mm and current:
+            rows.append(
+                {
+                    "benchmark": current,
+                    "metric": mm.group("label"),
+                    "value": mm.group("value").strip(),
+                }
+            )
+    return rows
+
+
+def _table(headers: List[str], rows: List[Dict[str, str]], keys: List[str]) -> str:
+    th = "".join(f"<th>{html.escape(h)}</th>" for h in headers)
+    body_parts = []
+    for row in rows:
+        tds = "".join(f"<td>{html.escape(str(row.get(k, '')))}</td>" for k in keys)
+        body_parts.append(f"<tr>{tds}</tr>")
+    if not body_parts:
+        body_parts.append(
+            f'<tr><td colspan="{len(headers)}"><em>no rows parsed</em></td></tr>'
+        )
+    return (
+        "<table>\n<thead><tr>"
+        + th
+        + "</tr></thead>\n<tbody>\n"
+        + "\n".join(body_parts)
+        + "\n</tbody>\n</table>"
+    )
+
+
+def _page(title: str, body: str) -> str:
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>{html.escape(title)}</title>
+  <style>
+    body {{ font-family: system-ui, sans-serif; margin: 2rem; line-height: 1.45; }}
+    table {{ border-collapse: collapse; margin: 1rem 0 2rem; width: 100%; }}
+    th, td {{ border: 1px solid #ccc; padding: 0.4rem 0.6rem; text-align: left; }}
+    th {{ background: #f4f4f4; }}
+    h1, h2, h3 {{ margin-top: 1.5rem; }}
+    a {{ color: #0645ad; }}
+    .meta {{ color: #555; font-size: 0.9rem; }}
+    .faster {{ color: #0a7a28; font-weight: 600; }}
+    .slower {{ color: #a30d0d; }}
+  </style>
+</head>
+<body>
+{body}
+</body>
+</html>
+"""
+
+
+def _ops_by_benchmark(rows: List[Dict[str, str]]) -> Dict[str, int]:
+    out: Dict[str, int] = {}
+    for row in rows:
+        try:
+            out[row["benchmark"]] = int(row["ops/sec"])
+        except (KeyError, ValueError):
+            continue
+    return out
+
+
+def _seconds_by_benchmark(rows: List[Dict[str, str]]) -> Dict[str, float]:
+    out: Dict[str, float] = {}
+    for row in rows:
+        try:
+            out[row["benchmark"]] = float(row["seconds"])
+        except (KeyError, ValueError):
+            continue
+    return out
+
+
+def _metric_map(rows: List[Dict[str, str]]) -> Dict[str, str]:
+    """Key: benchmark|metric -> value."""
+    out: Dict[str, str] = {}
+    for row in rows:
+        out[f"{row['benchmark']}|{row['metric']}"] = row["value"]
+    return out
+
+
+def _time_ratio_cell(topling_s: Optional[float], other_s: Optional[float]) -> str:
+    """ratio = other_seconds / topling_seconds; >=1 means ToplingDB faster."""
+    if topling_s is None or other_s is None or topling_s <= 0:
+        return "—"
+    ratio = other_s / topling_s
+    cls = "faster" if ratio >= 1.0 else "slower"
+    return f'<span class="{cls}">{ratio:.2f}x</span>'
+
+
+def _subject_time_ratio_cell(
+    baseline_s: Optional[float], subject_s: Optional[float]
+) -> str:
+    """ratio = subject / baseline; color is about the subject (dictzip10).
+
+    >1 → subject slower (red); <1 → subject faster (green).
+    """
+    if baseline_s is None or subject_s is None or baseline_s <= 0:
+        return "—"
+    ratio = subject_s / baseline_s
+    if ratio > 1.0:
+        cls = "slower"
+    elif ratio < 1.0:
+        cls = "faster"
+    else:
+        return f"{ratio:.2f}x"
+    return f'<span class="{cls}">{ratio:.2f}x</span>'
+
+
+def _ratio_pairs() -> List[Tuple[str, str]]:
+    """(base_topling_eng, rocksdb_eng) for time-ratio columns."""
+    pairs: List[Tuple[str, str]] = []
+    for base in TOPLING_ENGINES:
+        for other in ROCKSDB_ENGINES:
+            pairs.append((base, other))
+    return pairs
+
+
+def build_db_bench_compare(
+    engines: Dict[str, List[Dict[str, str]]],
+) -> str:
+    """Wide comparison: ops/sec + dictzip10/Topling time + rocksdb/topling* time."""
+    ops_by = {e: _ops_by_benchmark(engines.get(e, [])) for e in ENGINES}
+    sec_by = {e: _seconds_by_benchmark(engines.get(e, [])) for e in ENGINES}
+    key_sets = [set(m.keys()) for m in ops_by.values() if m]
+    names = sorted(set().union(*key_sets)) if key_sets else []
+    ratio_pairs = _ratio_pairs()
+    headers = ["benchmark"] + [
+        f"{ENGINE_LABELS[e]} ops/sec" for e in ENGINES
+    ]
+    # Direct Topling-vs-dictzip10 cost: >1 means minDictZip=10 is slower.
+    headers.append("dictzip10 time / Topling")
+    for base, other in ratio_pairs:
+        headers.append(
+            f"{RATIO_OTHER_LABELS[other]} time / {RATIO_BASE_LABELS[base]}"
+        )
+    rows_html = []
+    for name in names:
+        cells = [f"<td>{html.escape(name)}</td>"]
+        for e in ENGINES:
+            v = ops_by[e].get(name)
+            cells.append(f"<td>{v if v is not None else '—'}</td>")
+        cells.append(
+            f"<td>{_subject_time_ratio_cell(sec_by['topling'].get(name), sec_by['topling-dictzip10'].get(name))}</td>"
+        )
+        for base, other in ratio_pairs:
+            cells.append(
+                f"<td>{_time_ratio_cell(sec_by[base].get(name), sec_by[other].get(name))}</td>"
+            )
+        rows_html.append("<tr>" + "".join(cells) + "</tr>")
+    if not rows_html:
+        rows_html.append(
+            f'<tr><td colspan="{len(headers)}"><em>no rows parsed</em></td></tr>'
+        )
+    th = "".join(f"<th>{html.escape(h)}</th>" for h in headers)
+    return (
+        "<table>\n<thead><tr>"
+        + th
+        + "</tr></thead>\n<tbody>\n"
+        + "\n".join(rows_html)
+        + "\n</tbody>\n</table>"
+    )
+
+
+def build_topling_omit_compare(
+    engines: Dict[str, List[Dict[str, str]]],
+) -> str:
+    """Parallel Topling variants lazy-load demo (ops/sec; last run per name)."""
+    ops_by = {e: _ops_by_benchmark(engines.get(e, [])) for e in TOPLING_ENGINES}
+    key_sets = [set(m.keys()) for m in ops_by.values() if m]
+    names = sorted(set().union(*key_sets)) if key_sets else []
+    headers = ["benchmark"] + [
+        f"{ENGINE_LABELS[e]} ops/sec" for e in TOPLING_ENGINES
+    ]
+    rows_html = []
+    for name in names:
+        cells = [f"<td>{html.escape(name)}</td>"]
+        for e in TOPLING_ENGINES:
+            v = ops_by[e].get(name)
+            cells.append(f"<td>{v if v is not None else '—'}</td>")
+        rows_html.append("<tr>" + "".join(cells) + "</tr>")
+    if not rows_html:
+        rows_html.append(
+            f'<tr><td colspan="{len(headers)}"><em>no rows parsed</em></td></tr>'
+        )
+    th = "".join(f"<th>{html.escape(h)}</th>" for h in headers)
+    return (
+        "<table>\n<thead><tr>"
+        + th
+        + "</tr></thead>\n<tbody>\n"
+        + "\n".join(rows_html)
+        + "\n</tbody>\n</table>"
+    )
+
+
+def build_memtable_compare(
+    engines: Dict[str, List[Dict[str, str]]],
+) -> str:
+    maps = {e: _metric_map(engines.get(e, [])) for e in MEMTABLE_ENGINES}
+    key_sets = [set(m.keys()) for m in maps.values() if m]
+    keys = sorted(set().union(*key_sets)) if key_sets else []
+    headers = ["benchmark", "metric"] + [
+        ENGINE_LABELS[e] for e in MEMTABLE_ENGINES
+    ]
+    rows_html = []
+    for key in keys:
+        bench, metric = key.split("|", 1)
+        cells = [
+            f"<td>{html.escape(bench)}</td>",
+            f"<td>{html.escape(metric)}</td>",
+        ]
+        for e in MEMTABLE_ENGINES:
+            cells.append(f"<td>{html.escape(maps[e].get(key, '—'))}</td>")
+        rows_html.append("<tr>" + "".join(cells) + "</tr>")
+    if not rows_html:
+        rows_html.append(
+            f'<tr><td colspan="{len(headers)}"><em>no rows parsed</em></td></tr>'
+        )
+    th = "".join(f"<th>{html.escape(h)}</th>" for h in headers)
+    return (
+        "<table>\n<thead><tr>"
+        + th
+        + "</tr></thead>\n<tbody>\n"
+        + "\n".join(rows_html)
+        + "\n</tbody>\n</table>"
+    )
+
+
+def _load_engine_logs(log_root: Path) -> Dict[str, Dict[str, Any]]:
+    """Load per-engine parsed rows from log-root/<engine>/..."""
+    result: Dict[str, Dict[str, Any]] = {}
+    for eng in ENGINES:
+        eng_dir = log_root / eng
+        db_path = eng_dir / "db_bench.log"
+        skip_path = eng_dir / "memtablerep_bench-skiplist.log"
+        cspp_path = eng_dir / "memtablerep_bench-cspp.log"
+        if not db_path.is_file():
+            continue
+        db_rows = parse_db_bench(
+            db_path.read_text(encoding="utf-8", errors="replace")
+        )
+        fr_path = eng_dir / "db_bench-fillrandom.log"
+        fr_rows: List[Dict[str, str]] = []
+        if fr_path.is_file():
+            fr_rows = parse_db_bench(
+                fr_path.read_text(encoding="utf-8", errors="replace")
+            )
+        omit_fr_rows: List[Dict[str, str]] = []
+        omit_fs_rows: List[Dict[str, str]] = []
+        omit_fr = eng_dir / "db_bench-fillrandom-omit.log"
+        omit_fs = eng_dir / "db_bench-fillseq-omit.log"
+        if omit_fr.is_file():
+            omit_fr_rows = parse_db_bench(
+                omit_fr.read_text(encoding="utf-8", errors="replace")
+            )
+        if omit_fs.is_file():
+            omit_fs_rows = parse_db_bench(
+                omit_fs.read_text(encoding="utf-8", errors="replace")
+            )
+        skiplist_rows: List[Dict[str, str]] = []
+        cspp_rows: List[Dict[str, str]] = []
+        if skip_path.is_file():
+            skiplist_rows = parse_memtablerep(
+                skip_path.read_text(encoding="utf-8", errors="replace")
+            )
+        if cspp_path.is_file():
+            cspp_rows = parse_memtablerep(
+                cspp_path.read_text(encoding="utf-8", errors="replace")
+            )
+        result[eng] = {
+            "db_bench": db_rows,
+            "db_bench_fillrandom": fr_rows,
+            "db_bench_omit_fillrandom": omit_fr_rows,
+            "db_bench_omit_fillseq": omit_fs_rows,
+            "memtablerep_skiplist": skiplist_rows,
+            "memtablerep_cspp": cspp_rows,
+            "shm_usage": load_shm_usages(eng_dir),
+        }
+    for req in TOPLING_ENGINES:
+        if req not in result:
+            raise SystemExit(f"missing required logs under {log_root}/{req}/")
+    return result
+
+
+def emit(args: argparse.Namespace) -> None:
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    log_root = Path(args.log_root)
+    engines_data = _load_engine_logs(log_root)
+
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+    run_dir_name = f"{ts}-{args.variant}-{args.run_id}"
+    run_dir = out / "runs" / run_dir_name
+    raw_dir = run_dir / "raw"
+    raw_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy raw logs preserving engine subdirs
+    for eng, data in engines_data.items():
+        eng_raw = raw_dir / eng
+        eng_raw.mkdir(parents=True, exist_ok=True)
+        src = log_root / eng
+        for name in (
+            "db_bench.log",
+            "db_bench-fillrandom.log",
+            "db_bench-fillrandom-omit.log",
+            "db_bench-fillseq-omit.log",
+            "memtablerep_bench-skiplist.log",
+            "memtablerep_bench-cspp.log",
+            "shm_usage.txt",
+            "shm_usage-fillrandom.txt",
+            "shm_usage-fillseq.txt",
+        ):
+            p = src / name
+            if p.is_file():
+                shutil.copy2(p, eng_raw / name)
+
+    db_compare = build_db_bench_compare(
+        {e: engines_data.get(e, {}).get("db_bench", []) for e in ENGINES}
+    )
+    fr_compare = build_db_bench_compare(
+        {
+            e: engines_data.get(e, {}).get("db_bench_fillrandom", [])
+            for e in ENGINES
+        }
+    )
+    skip_compare = build_memtable_compare(
+        {
+            e: engines_data.get(e, {}).get("memtablerep_skiplist", [])
+            for e in MEMTABLE_ENGINES
+        }
+    )
+    omit_fr_table = build_topling_omit_compare(
+        {
+            e: engines_data.get(e, {}).get("db_bench_omit_fillrandom") or []
+            for e in TOPLING_ENGINES
+        }
+    )
+    omit_fs_table = build_topling_omit_compare(
+        {
+            e: engines_data.get(e, {}).get("db_bench_omit_fillseq") or []
+            for e in TOPLING_ENGINES
+        }
+    )
+    shm_usages = {
+        e: engines_data.get(e, {}).get("shm_usage") or {} for e in ENGINES
+    }
+    shm_table = build_shm_usage_table(shm_usages)
+
+    db_bench_detail_keys = [
+        "benchmark",
+        "micros/op",
+        "ops/sec",
+        "seconds",
+        "operations",
+        "extra",
+    ]
+
+    # Per-engine detail tables
+    detail_parts = []
+    for eng in ENGINES:
+        data = engines_data.get(eng)
+        if not data:
+            detail_parts.append(
+                f"<h3>{html.escape(ENGINE_LABELS[eng])}</h3><p><em>no logs</em></p>"
+            )
+            continue
+        detail_parts.append(f"<h3>{html.escape(ENGINE_LABELS[eng])}</h3>")
+        if data.get("db_bench_fillrandom"):
+            detail_parts.append(
+                "<h4>db_bench (fillrandom+compact+readseq/readrandom)</h4>"
+            )
+            detail_parts.append(
+                _table(
+                    db_bench_detail_keys,
+                    data["db_bench_fillrandom"],
+                    db_bench_detail_keys,
+                )
+            )
+        detail_parts.append("<h4>db_bench (fillseq suite)</h4>")
+        detail_parts.append(
+            _table(db_bench_detail_keys, data["db_bench"], db_bench_detail_keys)
+        )
+        if eng in TOPLING_ENGINES:
+            if data.get("db_bench_omit_fillrandom"):
+                detail_parts.append(
+                    "<h4>db_bench omit lazy-load (fillrandom DB)</h4>"
+                )
+                detail_parts.append(
+                    _table(
+                        db_bench_detail_keys,
+                        data["db_bench_omit_fillrandom"],
+                        db_bench_detail_keys,
+                    )
+                )
+            if data.get("db_bench_omit_fillseq"):
+                detail_parts.append(
+                    "<h4>db_bench omit lazy-load (fillseq DB)</h4>"
+                )
+                detail_parts.append(
+                    _table(
+                        db_bench_detail_keys,
+                        data["db_bench_omit_fillseq"],
+                        db_bench_detail_keys,
+                    )
+                )
+        if data.get("memtablerep_skiplist"):
+            detail_parts.append("<h4>memtablerep_bench (skiplist)</h4>")
+            detail_parts.append(
+                _table(
+                    ["benchmark", "metric", "value"],
+                    data["memtablerep_skiplist"],
+                    ["benchmark", "metric", "value"],
+                )
+            )
+        if data.get("memtablerep_cspp"):
+            detail_parts.append("<h4>memtablerep_bench (cspp, ToplingDB only)</h4>")
+            detail_parts.append(
+                _table(
+                    ["benchmark", "metric", "value"],
+                    data["memtablerep_cspp"],
+                    ["benchmark", "metric", "value"],
+                )
+            )
+
+    raw_links = " | ".join(
+        f'<a href="raw/{eng}/db_bench.log">{html.escape(ENGINE_LABELS[eng])} db_bench</a>'
+        for eng in ENGINES
+        if (raw_dir / eng / "db_bench.log").is_file()
+    )
+
+    body = f"""
+  <h1>Bench run: {html.escape(args.variant)} / {html.escape(str(args.run_id))}</h1>
+  <p class="meta">generated (UTC): {html.escape(datetime.now(timezone.utc).isoformat())}</p>
+  <p>{raw_links}</p>
+  <h2>/dev/shm usage (space; after db_bench + omit, before delete)</h2>
+  <p class="meta">实际占盘 = allocated blocks (IEC). Parallel engines: default Topling (minDictZipValueSize=3000) vs minDictZip=10. Space ratio = dictzip10 / Topling; &lt;1 means minDictZip=10 uses less space.</p>
+  {shm_table}
+  <h2>Comparison: db_bench fillrandom suite (perf)</h2>
+  <p class="meta">Benchmarks aligned (includes fillrandom/compact/readseq/readrandom). minDictZip=10 raises compression but typically slows compact and reads. Column &quot;dictzip10 time / Topling&quot; = subject/baseline seconds; &gt;1 (red) means minDictZip=10 is slower, &lt;1 (green) means faster. RocksDB time ratios use rocksdb_seconds / topling*_seconds; &gt;1 (green) means that Topling variant is faster. Values show ops/sec.</p>
+  {fr_compare}
+  <h2>Comparison: db_bench fillseq suite (perf)</h2>
+  <p class="meta">Same as fillrandom suite. Watch compact / readseq / readrandom rows for minDictZip=10 cost vs space savings above.</p>
+  {db_compare}
+  <h2>Lazy load demo (ToplingDB only, scan_omit)</h2>
+  <p class="meta">Not a fair comparison vs RocksDB. Parallel Topling variants (default vs minDictZip=10). Throughput is a lazy-load demo (scan_omit_key/value).</p>
+  <h3>fillrandom-omit</h3>
+  {omit_fr_table}
+  <h3>fillseq-omit</h3>
+  {omit_fs_table}
+  <h2>Comparison: memtablerep_bench (skiplist)</h2>
+  {skip_compare}
+  <h2>Per-engine details</h2>
+  {"".join(detail_parts)}
+"""
+    (run_dir / "index.html").write_text(
+        _page(f"Bench {args.variant} {args.run_id}", body), encoding="utf-8"
+    )
+
+    meta = {
+        "variant": args.variant,
+        "run_id": str(args.run_id),
+        "run_dir": run_dir_name,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "engines": {
+            eng: {
+                "db_bench": engines_data.get(eng, {}).get("db_bench", []),
+                "memtablerep_skiplist": engines_data.get(eng, {}).get(
+                    "memtablerep_skiplist", []
+                ),
+                "memtablerep_cspp": engines_data.get(eng, {}).get(
+                    "memtablerep_cspp", []
+                ),
+                "db_bench_fillrandom": engines_data.get(eng, {}).get(
+                    "db_bench_fillrandom", []
+                ),
+                "db_bench_omit_fillrandom": engines_data.get(eng, {}).get(
+                    "db_bench_omit_fillrandom", []
+                ),
+                "db_bench_omit_fillseq": engines_data.get(eng, {}).get(
+                    "db_bench_omit_fillseq", []
+                ),
+                "shm_usage": engines_data.get(eng, {}).get("shm_usage")
+                or {wl: None for wl in SHM_WORKLOADS},
+            }
+            for eng in ENGINES
+        },
+        # Keep legacy flat fields for topling (homepage snippets)
+        "db_bench": engines_data.get("topling", {}).get("db_bench", []),
+        "memtablerep_skiplist": engines_data.get("topling", {}).get(
+            "memtablerep_skiplist", []
+        ),
+        "memtablerep_cspp": engines_data.get("topling", {}).get(
+            "memtablerep_cspp", []
+        ),
+    }
+    (out / "run-meta.json").write_text(
+        json.dumps(meta, indent=2) + "\n", encoding="utf-8"
+    )
+
+
+def _render_latest_section(variant: str, entry: Optional[Dict[str, Any]]) -> str:
+    if not entry:
+        return f"<h2>Latest: {html.escape(variant)}</h2><p><em>no runs yet</em></p>"
+    run_dir = entry["run_dir"]
+    engines = entry.get("engines") or {
+        "topling": {
+            "db_bench": entry.get("db_bench", []),
+            "memtablerep_skiplist": entry.get("memtablerep_skiplist", []),
+            "memtablerep_cspp": entry.get("memtablerep_cspp", []),
+        }
+    }
+    db_compare = build_db_bench_compare(
+        {e: engines.get(e, {}).get("db_bench", []) for e in ENGINES}
+    )
+    skip_compare = build_memtable_compare(
+        {
+            e: engines.get(e, {}).get("memtablerep_skiplist", [])
+            for e in MEMTABLE_ENGINES
+        }
+    )
+    return f"""
+  <h2>Latest: {html.escape(variant)}</h2>
+  <p class="meta">run_id={html.escape(str(entry.get('run_id', '')))} |
+     <a href="runs/{html.escape(run_dir)}/index.html">full report</a> |
+     {html.escape(str(entry.get('timestamp', '')))}</p>
+  <h3>db_bench comparison (time ratio = rocksdb / topling*)</h3>
+  {db_compare}
+  <h3>memtablerep_bench skiplist comparison</h3>
+  {skip_compare}
+"""
+
+
+def _render_history(history: List[Dict[str, Any]]) -> str:
+    if not history:
+        return "<ul><li><em>empty</em></li></ul>"
+    items = []
+    for entry in history:
+        run_dir = entry.get("run_dir", "")
+        items.append(
+            "<li>"
+            f'{html.escape(str(entry.get("timestamp", "")))} — '
+            f'<strong>{html.escape(str(entry.get("variant", "")))}</strong> '
+            f'run_id={html.escape(str(entry.get("run_id", "")))} — '
+            f'<a href="runs/{html.escape(run_dir)}/index.html">report</a>'
+            "</li>"
+        )
+    return "<ul>\n" + "\n".join(items) + "\n</ul>"
+
+
+def _latest_by_variant(
+    history: List[Dict[str, Any]],
+) -> Dict[str, Optional[Dict[str, Any]]]:
+    latest: Dict[str, Optional[Dict[str, Any]]] = {"plain": None, "avx512": None}
+    for entry in history:
+        v = entry.get("variant")
+        if v in latest and latest[v] is None:
+            latest[v] = entry
+    return latest
+
+
+def merge(args: argparse.Namespace) -> None:
+    merge_into = Path(args.merge_into)
+    from_dir = Path(args.from_dir)
+    merge_into.mkdir(parents=True, exist_ok=True)
+
+    meta_path = from_dir / "run-meta.json"
+    meta = json.loads(meta_path.read_text(encoding="utf-8"))
+    if args.variant:
+        meta["variant"] = args.variant
+
+    run_dir_name = meta["run_dir"]
+    src_run = from_dir / "runs" / run_dir_name
+    dst_run = merge_into / "runs" / run_dir_name
+    if not src_run.is_dir():
+        raise SystemExit(f"missing emit run dir: {src_run}")
+    dst_run.parent.mkdir(parents=True, exist_ok=True)
+    if dst_run.exists():
+        shutil.rmtree(dst_run)
+    shutil.copytree(src_run, dst_run)
+
+    history_path = merge_into / "history.json"
+    if history_path.is_file():
+        history = json.loads(history_path.read_text(encoding="utf-8"))
+        if not isinstance(history, list):
+            history = []
+    else:
+        history = []
+
+    history_entry = {
+        "variant": meta["variant"],
+        "run_id": meta["run_id"],
+        "run_dir": run_dir_name,
+        "timestamp": meta.get("timestamp")
+        or datetime.now(timezone.utc).isoformat(),
+        "engines": meta.get("engines", {}),
+        "db_bench": meta.get("db_bench", []),
+        "memtablerep_skiplist": meta.get("memtablerep_skiplist", []),
+        "memtablerep_cspp": meta.get("memtablerep_cspp", []),
+    }
+    history.insert(0, history_entry)
+    history_path.write_text(json.dumps(history, indent=2) + "\n", encoding="utf-8")
+
+    (merge_into / ".nojekyll").write_text("", encoding="utf-8")
+
+    latest = _latest_by_variant(history)
+    body = f"""
+  <h1>ToplingDB vs RocksDB bench results</h1>
+  <p class="meta">Updated (UTC): {html.escape(datetime.now(timezone.utc).isoformat())}</p>
+  {_render_latest_section("plain", latest["plain"])}
+  {_render_latest_section("avx512", latest["avx512"])}
+  <h2>History</h2>
+  {_render_history(history)}
+"""
+    (merge_into / "index.html").write_text(
+        _page("ToplingDB vs RocksDB bench results", body), encoding="utf-8"
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p_emit = sub.add_parser("emit", help="Parse multi-engine logs into _pages fragment")
+    p_emit.add_argument("--variant", required=True, choices=["plain", "avx512"])
+    p_emit.add_argument("--run-id", required=True)
+    p_emit.add_argument(
+        "--log-root",
+        required=True,
+        help="Directory with topling/, topling-dictzip10/, rocksdb-*/ log subdirs",
+    )
+    p_emit.add_argument("--out", required=True)
+    p_emit.set_defaults(func=emit)
+
+    p_merge = sub.add_parser("merge", help="Merge emit output into gh-pages tree")
+    p_merge.add_argument("--merge-into", required=True)
+    p_merge.add_argument("--from", dest="from_dir", required=True)
+    p_merge.add_argument("--variant", required=True, choices=["plain", "avx512"])
+    p_merge.set_defaults(func=merge)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/build_upstream_rocksdb.sh b/.github/scripts/build_upstream_rocksdb.sh
new file mode 100644
index 0000000000..d8ae6ae65d
--- /dev/null
+++ b/.github/scripts/build_upstream_rocksdb.sh
@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+# Build upstream facebook/rocksdb db_bench + memtablerep_bench into a staging prefix.
+# Usage: build_upstream_rocksdb.sh <git-ref> <dest-dir> [extra env assignments...]
+# Example: build_upstream_rocksdb.sh v8.10.2 "$BUNDLE/rocksdb-v8.10"
+#          build_upstream_rocksdb.sh main "$BUNDLE/rocksdb-master"
+set -euo pipefail
+
+REF="${1:?git ref required (tag/branch/sha)}"
+DEST="${2:?destination directory required}"
+shift 2 || true
+
+SRC_DIR="${RUNNER_TEMP:-/tmp}/rocksdb-src-${REF//\//_}"
+rm -rf "$SRC_DIR" "$DEST"
+mkdir -p "$SRC_DIR" "$DEST/bin" "$DEST/lib"
+
+echo "Cloning facebook/rocksdb @ ${REF} -> ${SRC_DIR}"
+if [[ "$REF" == "master" || "$REF" == "latest" ]]; then
+  # Upstream default branch is main; keep "master"/"latest" as aliases.
+  if ! git clone --depth 1 --branch main https://github.com/facebook/rocksdb.git "$SRC_DIR"; then
+    git clone --depth 1 --branch master https://github.com/facebook/rocksdb.git "$SRC_DIR"
+  fi
+else
+  git clone --depth 1 --branch "$REF" https://github.com/facebook/rocksdb.git "$SRC_DIR"
+fi
+
+
+# Allow caller to inject CC/CXX/CPU/EXTRA_* via environment
+export DEBUG_LEVEL="${DEBUG_LEVEL:-0}"
+cd "$SRC_DIR"
+make db_bench memtablerep_bench -j"$(nproc)" DEBUG_LEVEL="$DEBUG_LEVEL"
+
+test -x "$SRC_DIR/db_bench"
+test -x "$SRC_DIR/memtablerep_bench"
+cp -a "$SRC_DIR/db_bench" "$SRC_DIR/memtablerep_bench" "$DEST/bin/"
+
+# Shared libs if present (static-linked benches may have none)
+shopt -s nullglob
+for f in "$SRC_DIR"/librocksdb.so*; do
+  cp -a "$f" "$DEST/lib/"
+done
+shopt -u nullglob
+
+SHA="$(git -C "$SRC_DIR" rev-parse HEAD)"
+python3 - <<PY
+import json
+from pathlib import Path
+meta = {
+    "engine": "rocksdb",
+    "ref": "${REF}",
+    "git_sha": "${SHA}",
+}
+Path("${DEST}/engine-meta.json").write_text(json.dumps(meta, indent=2) + "\n", encoding="utf-8")
+PY
+
+echo "Staged upstream rocksdb ${REF} (${SHA}) -> ${DEST}"
+ldd "$DEST/bin/db_bench" || true
+
+# Drop clone + object tree; only DEST (bins/libs) is needed for the artifact.
+rm -rf "$SRC_DIR"
diff --git a/.github/testdata/db_bench.sample.log b/.github/testdata/db_bench.sample.log
new file mode 100644
index 0000000000..48c77623ea
--- /dev/null
+++ b/.github/testdata/db_bench.sample.log
@@ -0,0 +1,5 @@
+fillseq      :     1.234567 micros/op 810000 ops/sec 61.728 seconds 50000000 operations;    6.1 MB/s
+compact      :   123.456789 micros/op   8100 ops/sec 12.345 seconds   100000 operations;
+nextwithkey  :     0.250000 micros/op 4000000 ops/sec 12.500 seconds 50000000 operations;
+readseq      :     0.180000 micros/op 5555555 ops/sec 9.000 seconds 50000000 operations;
+readrandom   :     0.900000 micros/op 1111111 ops/sec 45.000 seconds 50000000 operations;
diff --git a/.github/testdata/memtablerep_bench-cspp.sample.log b/.github/testdata/memtablerep_bench-cspp.sample.log
new file mode 100644
index 0000000000..f9c8559739
--- /dev/null
+++ b/.github/testdata/memtablerep_bench-cspp.sample.log
@@ -0,0 +1,21 @@
+Running fillrandom
+Number of threads: 1
+Elapsed time: 987654 us
+Total bytes written: 1024.0 MiB
+Write throughput: 1036.0 MiB/s
+write us/op: 9.876
+Running readrandom
+Number of threads: 1
+Elapsed time: 876543 us
+Total bytes read: 512.0 MiB
+Read throughput: 584.0 MiB/s
+read us/op: 8.765
+Running readwrite
+Number of threads: 1
+Elapsed time: 765432 us
+Total bytes written: 256.0 MiB
+Write throughput: 334.0 MiB/s
+write us/op: 7.654
+Total bytes read: 128.0 MiB
+Read throughput: 167.0 MiB/s
+read us/op: 6.543
diff --git a/.github/testdata/memtablerep_bench-skiplist.sample.log b/.github/testdata/memtablerep_bench-skiplist.sample.log
new file mode 100644
index 0000000000..ebf959e5c5
--- /dev/null
+++ b/.github/testdata/memtablerep_bench-skiplist.sample.log
@@ -0,0 +1,21 @@
+Running fillrandom
+Number of threads: 1
+Elapsed time: 1234567 us
+Total bytes written: 1024.0 MiB
+Write throughput: 829.0 MiB/s
+write us/op: 12.345
+Running readrandom
+Number of threads: 1
+Elapsed time: 2345678 us
+Total bytes read: 512.0 MiB
+Read throughput: 218.0 MiB/s
+read us/op: 23.456
+Running readwrite
+Number of threads: 1
+Elapsed time: 3456789 us
+Total bytes written: 256.0 MiB
+Write throughput: 74.0 MiB/s
+write us/op: 34.567
+Total bytes read: 128.0 MiB
+Read throughput: 37.0 MiB/s
+read us/op: 45.678
diff --git a/.github/testdata/rocksdb-master/db_bench-fillrandom.log b/.github/testdata/rocksdb-master/db_bench-fillrandom.log
new file mode 100644
index 0000000000..a72563d896
--- /dev/null
+++ b/.github/testdata/rocksdb-master/db_bench-fillrandom.log
@@ -0,0 +1,4 @@
+fillrandom   :     2.000000 micros/op 500000 ops/sec 100.000 seconds 50000000 operations;    5.0 MB/s
+compact      :   100.000000 micros/op  10000 ops/sec 10.000 seconds   100000 operations;
+readseq      :     0.200000 micros/op 5000000 ops/sec 10.000 seconds 50000000 operations;
+readrandom   :     1.000000 micros/op 1000000 ops/sec 50.000 seconds 50000000 operations;
diff --git a/.github/testdata/rocksdb-master/db_bench.log b/.github/testdata/rocksdb-master/db_bench.log
new file mode 100644
index 0000000000..ad403600bf
--- /dev/null
+++ b/.github/testdata/rocksdb-master/db_bench.log
@@ -0,0 +1,4 @@
+fillseq      :     1.800000 micros/op 555555 ops/sec 90.000 seconds 50000000 operations;    4.2 MB/s
+compact      :   180.000000 micros/op   5555 ops/sec 18.000 seconds   100000 operations;
+readseq      :     0.280000 micros/op 3571428 ops/sec 14.000 seconds 50000000 operations;
+readrandom   :     1.400000 micros/op  714285 ops/sec 70.000 seconds 50000000 operations;
diff --git a/.github/testdata/rocksdb-master/memtablerep_bench-skiplist.log b/.github/testdata/rocksdb-master/memtablerep_bench-skiplist.log
new file mode 100644
index 0000000000..ebf959e5c5
--- /dev/null
+++ b/.github/testdata/rocksdb-master/memtablerep_bench-skiplist.log
@@ -0,0 +1,21 @@
+Running fillrandom
+Number of threads: 1
+Elapsed time: 1234567 us
+Total bytes written: 1024.0 MiB
+Write throughput: 829.0 MiB/s
+write us/op: 12.345
+Running readrandom
+Number of threads: 1
+Elapsed time: 2345678 us
+Total bytes read: 512.0 MiB
+Read throughput: 218.0 MiB/s
+read us/op: 23.456
+Running readwrite
+Number of threads: 1
+Elapsed time: 3456789 us
+Total bytes written: 256.0 MiB
+Write throughput: 74.0 MiB/s
+write us/op: 34.567
+Total bytes read: 128.0 MiB
+Read throughput: 37.0 MiB/s
+read us/op: 45.678
diff --git a/.github/testdata/rocksdb-master/shm_usage-fillrandom.txt b/.github/testdata/rocksdb-master/shm_usage-fillrandom.txt
new file mode 100644
index 0000000000..c3304350e4
--- /dev/null
+++ b/.github/testdata/rocksdb-master/shm_usage-fillrandom.txt
@@ -0,0 +1,2 @@
+apparent_bytes=1476395008
+allocated_bytes=1493172224
diff --git a/.github/testdata/rocksdb-master/shm_usage-fillseq.txt b/.github/testdata/rocksdb-master/shm_usage-fillseq.txt
new file mode 100644
index 0000000000..6c1afcd314
--- /dev/null
+++ b/.github/testdata/rocksdb-master/shm_usage-fillseq.txt
@@ -0,0 +1,2 @@
+apparent_bytes=1181116006
+allocated_bytes=1195376640
diff --git a/.github/testdata/rocksdb-master/shm_usage.txt b/.github/testdata/rocksdb-master/shm_usage.txt
new file mode 100644
index 0000000000..6c1afcd314
--- /dev/null
+++ b/.github/testdata/rocksdb-master/shm_usage.txt
@@ -0,0 +1,2 @@
+apparent_bytes=1181116006
+allocated_bytes=1195376640
diff --git a/.github/testdata/rocksdb-v8.10/db_bench-fillrandom.log b/.github/testdata/rocksdb-v8.10/db_bench-fillrandom.log
new file mode 100644
index 0000000000..a72563d896
--- /dev/null
+++ b/.github/testdata/rocksdb-v8.10/db_bench-fillrandom.log
@@ -0,0 +1,4 @@
+fillrandom   :     2.000000 micros/op 500000 ops/sec 100.000 seconds 50000000 operations;    5.0 MB/s
+compact      :   100.000000 micros/op  10000 ops/sec 10.000 seconds   100000 operations;
+readseq      :     0.200000 micros/op 5000000 ops/sec 10.000 seconds 50000000 operations;
+readrandom   :     1.000000 micros/op 1000000 ops/sec 50.000 seconds 50000000 operations;
diff --git a/.github/testdata/rocksdb-v8.10/db_bench.log b/.github/testdata/rocksdb-v8.10/db_bench.log
new file mode 100644
index 0000000000..9e2cfa6e97
--- /dev/null
+++ b/.github/testdata/rocksdb-v8.10/db_bench.log
@@ -0,0 +1,4 @@
+fillseq      :     2.000000 micros/op 500000 ops/sec 100.000 seconds 50000000 operations;    3.8 MB/s
+compact      :   200.000000 micros/op   5000 ops/sec 20.000 seconds   100000 operations;
+readseq      :     0.300000 micros/op 3333333 ops/sec 15.000 seconds 50000000 operations;
+readrandom   :     1.500000 micros/op  666666 ops/sec 75.000 seconds 50000000 operations;
diff --git a/.github/testdata/rocksdb-v8.10/memtablerep_bench-skiplist.log b/.github/testdata/rocksdb-v8.10/memtablerep_bench-skiplist.log
new file mode 100644
index 0000000000..ebf959e5c5
--- /dev/null
+++ b/.github/testdata/rocksdb-v8.10/memtablerep_bench-skiplist.log
@@ -0,0 +1,21 @@
+Running fillrandom
+Number of threads: 1
+Elapsed time: 1234567 us
+Total bytes written: 1024.0 MiB
+Write throughput: 829.0 MiB/s
+write us/op: 12.345
+Running readrandom
+Number of threads: 1
+Elapsed time: 2345678 us
+Total bytes read: 512.0 MiB
+Read throughput: 218.0 MiB/s
+read us/op: 23.456
+Running readwrite
+Number of threads: 1
+Elapsed time: 3456789 us
+Total bytes written: 256.0 MiB
+Write throughput: 74.0 MiB/s
+write us/op: 34.567
+Total bytes read: 128.0 MiB
+Read throughput: 37.0 MiB/s
+read us/op: 45.678
diff --git a/.github/testdata/rocksdb-v8.10/shm_usage-fillrandom.txt b/.github/testdata/rocksdb-v8.10/shm_usage-fillrandom.txt
new file mode 100644
index 0000000000..f8d75c2eb6
--- /dev/null
+++ b/.github/testdata/rocksdb-v8.10/shm_usage-fillrandom.txt
@@ -0,0 +1,2 @@
+apparent_bytes=1509949440
+allocated_bytes=1526726656
diff --git a/.github/testdata/rocksdb-v8.10/shm_usage-fillseq.txt b/.github/testdata/rocksdb-v8.10/shm_usage-fillseq.txt
new file mode 100644
index 0000000000..05f95ca31c
--- /dev/null
+++ b/.github/testdata/rocksdb-v8.10/shm_usage-fillseq.txt
@@ -0,0 +1,2 @@
+apparent_bytes=1207959552
+allocated_bytes=1224736768
diff --git a/.github/testdata/rocksdb-v8.10/shm_usage.txt b/.github/testdata/rocksdb-v8.10/shm_usage.txt
new file mode 100644
index 0000000000..05f95ca31c
--- /dev/null
+++ b/.github/testdata/rocksdb-v8.10/shm_usage.txt
@@ -0,0 +1,2 @@
+apparent_bytes=1207959552
+allocated_bytes=1224736768
diff --git a/.github/testdata/topling-dictzip10/db_bench-fillrandom-omit.log b/.github/testdata/topling-dictzip10/db_bench-fillrandom-omit.log
new file mode 100644
index 0000000000..8949c2db58
--- /dev/null
+++ b/.github/testdata/topling-dictzip10/db_bench-fillrandom-omit.log
@@ -0,0 +1,6 @@
+nextwithkey  :     0.100000 micros/op 10000000 ops/sec 5.000 seconds 50000000 operations;
+nextwithkey  :     0.095000 micros/op 10526315 ops/sec 4.750 seconds 50000000 operations;
+nextwithkey  :     0.090000 micros/op 11111111 ops/sec 4.500 seconds 50000000 operations;
+readseq      :     0.050000 micros/op 20000000 ops/sec 2.500 seconds 50000000 operations;
+readseq      :     0.048000 micros/op 20833333 ops/sec 2.400 seconds 50000000 operations;
+readseq      :     0.045000 micros/op 22222222 ops/sec 2.250 seconds 50000000 operations;
diff --git a/.github/testdata/topling-dictzip10/db_bench-fillrandom.log b/.github/testdata/topling-dictzip10/db_bench-fillrandom.log
new file mode 100644
index 0000000000..a72563d896
--- /dev/null
+++ b/.github/testdata/topling-dictzip10/db_bench-fillrandom.log
@@ -0,0 +1,4 @@
+fillrandom   :     2.000000 micros/op 500000 ops/sec 100.000 seconds 50000000 operations;    5.0 MB/s
+compact      :   100.000000 micros/op  10000 ops/sec 10.000 seconds   100000 operations;
+readseq      :     0.200000 micros/op 5000000 ops/sec 10.000 seconds 50000000 operations;
+readrandom   :     1.000000 micros/op 1000000 ops/sec 50.000 seconds 50000000 operations;
diff --git a/.github/testdata/topling-dictzip10/db_bench-fillseq-omit.log b/.github/testdata/topling-dictzip10/db_bench-fillseq-omit.log
new file mode 100644
index 0000000000..c77221ab21
--- /dev/null
+++ b/.github/testdata/topling-dictzip10/db_bench-fillseq-omit.log
@@ -0,0 +1,6 @@
+nextwithkey  :     0.110000 micros/op 9090909 ops/sec 5.500 seconds 50000000 operations;
+nextwithkey  :     0.105000 micros/op 9523809 ops/sec 5.250 seconds 50000000 operations;
+nextwithkey  :     0.100000 micros/op 10000000 ops/sec 5.000 seconds 50000000 operations;
+readseq      :     0.055000 micros/op 18181818 ops/sec 2.750 seconds 50000000 operations;
+readseq      :     0.052000 micros/op 19230769 ops/sec 2.600 seconds 50000000 operations;
+readseq      :     0.050000 micros/op 20000000 ops/sec 2.500 seconds 50000000 operations;
diff --git a/.github/testdata/topling-dictzip10/db_bench.log b/.github/testdata/topling-dictzip10/db_bench.log
new file mode 100644
index 0000000000..40bf33b688
--- /dev/null
+++ b/.github/testdata/topling-dictzip10/db_bench.log
@@ -0,0 +1,4 @@
+fillseq      :     1.234567 micros/op 810000 ops/sec 61.728 seconds 50000000 operations;    6.1 MB/s
+compact      :   123.456789 micros/op   8100 ops/sec 12.345 seconds   100000 operations;
+readseq      :     0.180000 micros/op 5555555 ops/sec 9.000 seconds 50000000 operations;
+readrandom   :     0.900000 micros/op 1111111 ops/sec 45.000 seconds 50000000 operations;
diff --git a/.github/testdata/topling-dictzip10/shm_usage-fillrandom.txt b/.github/testdata/topling-dictzip10/shm_usage-fillrandom.txt
new file mode 100644
index 0000000000..7b85ba80a9
--- /dev/null
+++ b/.github/testdata/topling-dictzip10/shm_usage-fillrandom.txt
@@ -0,0 +1,2 @@
+apparent_bytes=534773760
+allocated_bytes=545259520
diff --git a/.github/testdata/topling-dictzip10/shm_usage-fillseq.txt b/.github/testdata/topling-dictzip10/shm_usage-fillseq.txt
new file mode 100644
index 0000000000..8b9ad516d1
--- /dev/null
+++ b/.github/testdata/topling-dictzip10/shm_usage-fillseq.txt
@@ -0,0 +1,2 @@
+apparent_bytes=445644800
+allocated_bytes=452984832
diff --git a/.github/testdata/topling/db_bench-fillrandom-omit.log b/.github/testdata/topling/db_bench-fillrandom-omit.log
new file mode 100644
index 0000000000..8949c2db58
--- /dev/null
+++ b/.github/testdata/topling/db_bench-fillrandom-omit.log
@@ -0,0 +1,6 @@
+nextwithkey  :     0.100000 micros/op 10000000 ops/sec 5.000 seconds 50000000 operations;
+nextwithkey  :     0.095000 micros/op 10526315 ops/sec 4.750 seconds 50000000 operations;
+nextwithkey  :     0.090000 micros/op 11111111 ops/sec 4.500 seconds 50000000 operations;
+readseq      :     0.050000 micros/op 20000000 ops/sec 2.500 seconds 50000000 operations;
+readseq      :     0.048000 micros/op 20833333 ops/sec 2.400 seconds 50000000 operations;
+readseq      :     0.045000 micros/op 22222222 ops/sec 2.250 seconds 50000000 operations;
diff --git a/.github/testdata/topling/db_bench-fillrandom.log b/.github/testdata/topling/db_bench-fillrandom.log
new file mode 100644
index 0000000000..a72563d896
--- /dev/null
+++ b/.github/testdata/topling/db_bench-fillrandom.log
@@ -0,0 +1,4 @@
+fillrandom   :     2.000000 micros/op 500000 ops/sec 100.000 seconds 50000000 operations;    5.0 MB/s
+compact      :   100.000000 micros/op  10000 ops/sec 10.000 seconds   100000 operations;
+readseq      :     0.200000 micros/op 5000000 ops/sec 10.000 seconds 50000000 operations;
+readrandom   :     1.000000 micros/op 1000000 ops/sec 50.000 seconds 50000000 operations;
diff --git a/.github/testdata/topling/db_bench-fillseq-omit.log b/.github/testdata/topling/db_bench-fillseq-omit.log
new file mode 100644
index 0000000000..c77221ab21
--- /dev/null
+++ b/.github/testdata/topling/db_bench-fillseq-omit.log
@@ -0,0 +1,6 @@
+nextwithkey  :     0.110000 micros/op 9090909 ops/sec 5.500 seconds 50000000 operations;
+nextwithkey  :     0.105000 micros/op 9523809 ops/sec 5.250 seconds 50000000 operations;
+nextwithkey  :     0.100000 micros/op 10000000 ops/sec 5.000 seconds 50000000 operations;
+readseq      :     0.055000 micros/op 18181818 ops/sec 2.750 seconds 50000000 operations;
+readseq      :     0.052000 micros/op 19230769 ops/sec 2.600 seconds 50000000 operations;
+readseq      :     0.050000 micros/op 20000000 ops/sec 2.500 seconds 50000000 operations;
diff --git a/.github/testdata/topling/db_bench.log b/.github/testdata/topling/db_bench.log
new file mode 100644
index 0000000000..40bf33b688
--- /dev/null
+++ b/.github/testdata/topling/db_bench.log
@@ -0,0 +1,4 @@
+fillseq      :     1.234567 micros/op 810000 ops/sec 61.728 seconds 50000000 operations;    6.1 MB/s
+compact      :   123.456789 micros/op   8100 ops/sec 12.345 seconds   100000 operations;
+readseq      :     0.180000 micros/op 5555555 ops/sec 9.000 seconds 50000000 operations;
+readrandom   :     0.900000 micros/op 1111111 ops/sec 45.000 seconds 50000000 operations;
diff --git a/.github/testdata/topling/memtablerep_bench-cspp.log b/.github/testdata/topling/memtablerep_bench-cspp.log
new file mode 100644
index 0000000000..f9c8559739
--- /dev/null
+++ b/.github/testdata/topling/memtablerep_bench-cspp.log
@@ -0,0 +1,21 @@
+Running fillrandom
+Number of threads: 1
+Elapsed time: 987654 us
+Total bytes written: 1024.0 MiB
+Write throughput: 1036.0 MiB/s
+write us/op: 9.876
+Running readrandom
+Number of threads: 1
+Elapsed time: 876543 us
+Total bytes read: 512.0 MiB
+Read throughput: 584.0 MiB/s
+read us/op: 8.765
+Running readwrite
+Number of threads: 1
+Elapsed time: 765432 us
+Total bytes written: 256.0 MiB
+Write throughput: 334.0 MiB/s
+write us/op: 7.654
+Total bytes read: 128.0 MiB
+Read throughput: 167.0 MiB/s
+read us/op: 6.543
diff --git a/.github/testdata/topling/memtablerep_bench-skiplist.log b/.github/testdata/topling/memtablerep_bench-skiplist.log
new file mode 100644
index 0000000000..ebf959e5c5
--- /dev/null
+++ b/.github/testdata/topling/memtablerep_bench-skiplist.log
@@ -0,0 +1,21 @@
+Running fillrandom
+Number of threads: 1
+Elapsed time: 1234567 us
+Total bytes written: 1024.0 MiB
+Write throughput: 829.0 MiB/s
+write us/op: 12.345
+Running readrandom
+Number of threads: 1
+Elapsed time: 2345678 us
+Total bytes read: 512.0 MiB
+Read throughput: 218.0 MiB/s
+read us/op: 23.456
+Running readwrite
+Number of threads: 1
+Elapsed time: 3456789 us
+Total bytes written: 256.0 MiB
+Write throughput: 74.0 MiB/s
+write us/op: 34.567
+Total bytes read: 128.0 MiB
+Read throughput: 37.0 MiB/s
+read us/op: 45.678
diff --git a/.github/testdata/topling/shm_usage-fillrandom.txt b/.github/testdata/topling/shm_usage-fillrandom.txt
new file mode 100644
index 0000000000..05f95ca31c
--- /dev/null
+++ b/.github/testdata/topling/shm_usage-fillrandom.txt
@@ -0,0 +1,2 @@
+apparent_bytes=1207959552
+allocated_bytes=1224736768
diff --git a/.github/testdata/topling/shm_usage-fillseq.txt b/.github/testdata/topling/shm_usage-fillseq.txt
new file mode 100644
index 0000000000..b8188a9499
--- /dev/null
+++ b/.github/testdata/topling/shm_usage-fillseq.txt
@@ -0,0 +1,2 @@
+apparent_bytes=891289600
+allocated_bytes=905969664
diff --git a/.github/testdata/topling/shm_usage.txt b/.github/testdata/topling/shm_usage.txt
new file mode 100644
index 0000000000..b8188a9499
--- /dev/null
+++ b/.github/testdata/topling/shm_usage.txt
@@ -0,0 +1,2 @@
+apparent_bytes=891289600
+allocated_bytes=905969664
diff --git a/.github/workflows/db_bench-avx512-build.yml b/.github/workflows/db_bench-avx512-build.yml
new file mode 100644
index 0000000000..dcb1ee686f
--- /dev/null
+++ b/.github/workflows/db_bench-avx512-build.yml
@@ -0,0 +1,134 @@
+# Replaces the old db_bench-avx512.yml (compile+run monolith).
+# Builds ToplingDB (avx512) + upstream RocksDB v8.10 + RocksDB master for comparison.
+name: "db_bench-avx512-build"
+
+on:
+  workflow_dispatch:
+    inputs:
+      use_clang:
+        type: boolean
+        required: false
+        default: false
+        description: use clang
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    env:
+      GITHUB_TOKEN: ${{github.token}}
+    permissions:
+      contents: read
+      actions: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Install Prerequisites
+        run: |
+          set -xe
+          sudo apt-get update -y && sudo apt-get install -y \
+            libjemalloc-dev libaio-dev libgflags-dev zlib1g-dev \
+            libbz2-dev libcurl4-openssl-dev liburing-dev \
+            libsnappy-dev libbz2-dev liblz4-dev libzstd-dev
+
+      - name: Init submodule & Setup ssh
+        run: |
+          git submodule update --init --recursive
+          mkdir -p ~/.ssh && mkdir -p /opt/lib
+          ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
+          echo nproc = `nproc`
+
+      - name: Git clone SidePlugin(s)
+        run: |
+          make clean
+
+      - name: Compile ToplingDB db_bench
+        run: |
+          set -xe
+          if ${{inputs.use_clang}}; then
+            export CXX=clang++
+            export CC=clang
+          fi
+          export CPU=-march=skylake-avx512
+          make db_bench memtablerep_bench -j`nproc` DEBUG_LEVEL=0 UPDATE_REPO=0
+
+      - name: Stage ToplingDB prefix
+        run: |
+          set -xe
+          BUNDLE="$PWD/_bench_bundle"
+          STAGE="$PWD/_bench_stage"
+          PREFIX="/usr/local"
+          rm -rf "$BUNDLE" "$STAGE"
+          mkdir -p "$BUNDLE"
+          make install DESTDIR="$STAGE" PREFIX="$PREFIX" DEBUG_LEVEL=0 UPDATE_REPO=0
+          mkdir -p "$STAGE$PREFIX/bin" "$STAGE$PREFIX/toplingdb-conf" "$STAGE$PREFIX/site"
+          cp -a db_bench memtablerep_bench "$STAGE$PREFIX/bin/"
+          cp -a sideplugin/rockside/sample-conf/db_bench_enterprise.yaml \
+                "$STAGE$PREFIX/toplingdb-conf/"
+          # CI-only override in staged copy (do not edit rockside submodule).
+          sed -i 's/^\([[:space:]]*write_buffer_size:[[:space:]]*\)2G/\1512M/' \
+            "$STAGE$PREFIX/toplingdb-conf/db_bench_enterprise.yaml"
+          grep -E 'write_buffer_size:[[:space:]]*512M' \
+            "$STAGE$PREFIX/toplingdb-conf/db_bench_enterprise.yaml"
+          cp -a sideplugin/rockside/src/topling/web/index.html \
+                sideplugin/rockside/src/topling/web/style.css \
+                "$STAGE$PREFIX/site/"
+          test -x "$STAGE$PREFIX/bin/db_bench"
+          mv "$STAGE$PREFIX" "$BUNDLE/topling"
+          rm -rf "$STAGE"
+          echo "BUNDLE=$BUNDLE" >> "$GITHUB_ENV"
+
+      - name: Build upstream RocksDB v8.10 and master
+        run: |
+          set -xe
+          chmod +x .github/scripts/build_upstream_rocksdb.sh
+          if ${{inputs.use_clang}}; then
+            export CXX=clang++
+            export CC=clang
+          fi
+          # Match Topling avx512 flags when possible (runner may still lack AVX512).
+          export EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS:-} -march=skylake-avx512"
+          export EXTRA_CFLAGS="${EXTRA_CFLAGS:-} -march=skylake-avx512"
+          # Script removes each clone tree after staging that engine.
+          .github/scripts/build_upstream_rocksdb.sh v8.10.2 "$BUNDLE/rocksdb-v8.10"
+          df -h
+          .github/scripts/build_upstream_rocksdb.sh master "$BUNDLE/rocksdb-master"
+          test -x "$BUNDLE/rocksdb-v8.10/bin/db_bench"
+          test -x "$BUNDLE/rocksdb-master/bin/db_bench"
+          df -h
+
+      - name: Pack bench bundle artifact
+        run: |
+          set -xe
+          python3 - <<'PY'
+          import json, os
+          from datetime import datetime, timezone
+          from pathlib import Path
+          bundle = Path(os.environ["BUNDLE"])
+          meta = {
+              "git_sha": os.environ.get("GITHUB_SHA", ""),
+              "run_id": os.environ.get("GITHUB_RUN_ID", ""),
+              "variant": "avx512",
+              "use_clang": os.environ.get("USE_CLANG", "false"),
+              "timestamp": datetime.now(timezone.utc).isoformat(),
+              "engines": ["topling", "rocksdb-v8.10", "rocksdb-master"],
+          }
+          (bundle / "build-meta.json").write_text(
+              json.dumps(meta, indent=2) + "\n", encoding="utf-8"
+          )
+          PY
+          tar -C "$BUNDLE" -czf bench-prefix.tgz .
+          rm -rf "$BUNDLE"
+          df -h
+        env:
+          USE_CLANG: ${{ inputs.use_clang }}
+
+      - name: Upload bench prefix artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: db_bench-bin-avx512
+          path: bench-prefix.tgz
+          retention-days: 14
diff --git a/.github/workflows/db_bench-avx512-run.yml b/.github/workflows/db_bench-avx512-run.yml
new file mode 100644
index 0000000000..bbf0346674
--- /dev/null
+++ b/.github/workflows/db_bench-avx512-run.yml
@@ -0,0 +1,386 @@
+# Triggered after db_bench-avx512-build. Runs ToplingDB + RocksDB v8.10 + RocksDB master,
+# emits comparison tables, publishes Pages.
+name: "db_bench-avx512-run"
+
+on:
+  workflow_run:
+    workflows: ["db_bench-avx512-build"]
+    types: [completed]
+  workflow_dispatch:
+    inputs:
+      build_run_id:
+        description: Build workflow run id whose artifact to download
+        required: true
+        type: string
+
+concurrency:
+  group: pages-deploy
+  cancel-in-progress: false
+
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+  actions: read
+
+jobs:
+  bench-and-publish:
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }}
+    runs-on: ubuntu-latest
+    env:
+      VARIANT: avx512
+      ARTIFACT_NAME: db_bench-bin-avx512
+    steps:
+      - name: Checkout build commit
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+          ref: ${{ github.event_name == 'workflow_run' && github.event.workflow_run.head_sha || github.sha }}
+
+      - name: Install runtime dependencies
+        run: |
+          set -xe
+          sudo apt-get update -y && sudo apt-get install -y \
+            libjemalloc-dev libaio-dev libgflags-dev zlib1g-dev \
+            libbz2-dev libcurl4-openssl-dev liburing-dev \
+            libsnappy-dev liblz4-dev libzstd-dev
+
+      - name: Download build artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ env.ARTIFACT_NAME }}
+          run-id: ${{ github.event_name == 'workflow_dispatch' && inputs.build_run_id || github.event.workflow_run.id }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          path: _artifact
+
+      - name: Unpack bench bundle
+        run: |
+          set -xe
+          RUN_PREFIX="$PWD/_run_prefix"
+          rm -rf "$RUN_PREFIX" logs
+          mkdir -p "$RUN_PREFIX" logs
+          tar -C "$RUN_PREFIX" -xzf _artifact/bench-prefix.tgz
+          test -d "$RUN_PREFIX/topling"
+          test -d "$RUN_PREFIX/rocksdb-v8.10"
+          test -d "$RUN_PREFIX/rocksdb-master"
+          test -x "$RUN_PREFIX/topling/bin/db_bench"
+          test -x "$RUN_PREFIX/rocksdb-v8.10/bin/db_bench"
+          test -x "$RUN_PREFIX/rocksdb-master/bin/db_bench"
+          echo "RUN_PREFIX=$RUN_PREFIX" >> "$GITHUB_ENV"
+
+      - name: Probe /dev/shm
+        run: |
+          set -xe
+          # Engines rotate exclusive use of /dev/shm (one DB at a time).
+          # Do not pre-create all three DB dirs here.
+          df -h /dev/shm
+
+      - name: Run ToplingDB benches
+        run: |
+          set -xe
+          TOPLING="$RUN_PREFIX/topling"
+          export LD_LIBRARY_PATH="$TOPLING/lib:${LD_LIBRARY_PATH:-}"
+          ldd "$TOPLING/bin/db_bench"
+          export TOPLINGDB_GetContext_sampling=kNone
+          export ROCKSDB_KICK_OUT_OPTIONS_FILE=1
+          DB_PATH=/dev/shm/db_bench_enterprise
+          YAML_BASE="$TOPLING/toplingdb-conf/db_bench_enterprise.yaml"
+          # CI-only: shrink write_buffer without touching rockside submodule.
+          sed -i 's/^\([[:space:]]*write_buffer_size:[[:space:]]*\)2G/\1512M/' "$YAML_BASE"
+          grep -E 'write_buffer_size:[[:space:]]*512M' "$YAML_BASE"
+          # Parallel config: enable DictZip for value_size=15 (default yaml is 3000).
+          YAML_DZ10="$TOPLING/toplingdb-conf/db_bench_enterprise_dictzip10.yaml"
+          cp -a "$YAML_BASE" "$YAML_DZ10"
+          sed -i 's/^\([[:space:]]*minDictZipValueSize:[[:space:]]*\)3000/\110/' "$YAML_DZ10"
+          grep -E 'minDictZipValueSize:[[:space:]]*10$' "$YAML_DZ10"
+
+          prepare_db() {
+            rm -rf "$DB_PATH"
+            mkdir -p "$DB_PATH"
+            if [ -d "$TOPLING/site" ]; then
+              cp -a "$TOPLING/site/." "$DB_PATH/"
+            fi
+          }
+
+          # eng_id log dir name; yaml path; run_memtable 0|1
+          run_topling_suite() {
+            local eng_id="$1"
+            local yaml="$2"
+            local run_memtable="$3"
+            local logdir="logs/${eng_id}"
+            mkdir -p "$logdir"
+            record_shm() {
+              local label="$1"
+              {
+                echo "apparent_bytes=$(du -sb "$DB_PATH" | awk '{print $1}')"
+                echo "allocated_bytes=$(du -s -B1 "$DB_PATH" | awk '{print $1}')"
+              } | tee "${logdir}/shm_usage-${label}.txt"
+              du -sh --apparent-size "$DB_PATH" || true
+              du -sh "$DB_PATH" || true
+              df -h /dev/shm
+            }
+
+            # Pass 1: fillrandom suite, then omit lazy-load demo.
+            prepare_db
+            args_fr=(
+                -json "$yaml"
+                -num=50000000
+                -key_size=8
+                -value_size=15
+                -batch_size=1000
+                -benchmarks=fillrandom,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+                -enable_zero_copy
+                -progress_reports=false
+            )
+            "$TOPLING/bin/db_bench" "${args_fr[@]}" 2>&1 | tee "${logdir}/db_bench-fillrandom.log"
+            args_omit=(
+                -json "$yaml"
+                -num=50000000
+                -key_size=8
+                -value_size=15
+                -batch_size=1000
+                -benchmarks=nextwithkey,nextwithkey,nextwithkey,readseq,readseq,readseq
+                -scan_omit_key -scan_omit_value
+                -use_existing_db=1
+                -enable_zero_copy
+                -progress_reports=false
+            )
+            "$TOPLING/bin/db_bench" "${args_omit[@]}" 2>&1 | tee "${logdir}/db_bench-fillrandom-omit.log"
+            record_shm fillrandom
+            rm -rf "$DB_PATH"
+
+            # Pass 2: fillseq suite, then omit lazy-load demo.
+            prepare_db
+            args=(
+                -json "$yaml"
+                -num=50000000
+                -key_size=8
+                -value_size=15
+                -batch_size=1000
+                -benchmarks=fillseq,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+                -enable_zero_copy
+                -progress_reports=false
+            )
+            "$TOPLING/bin/db_bench" "${args[@]}" 2>&1 | tee "${logdir}/db_bench.log"
+            "$TOPLING/bin/db_bench" "${args_omit[@]}" 2>&1 | tee "${logdir}/db_bench-fillseq-omit.log"
+            record_shm fillseq
+            if [ "$run_memtable" = "1" ]; then
+              mt=(
+                -benchmarks=fillrandom,readrandom,readwrite
+                -item_size=0
+                -num_operations=100000000
+                -write_buffer_size=536870912
+              )
+              "$TOPLING/bin/memtablerep_bench" "${mt[@]}" -memtablerep=skiplist \
+                2>&1 | tee "${logdir}/memtablerep_bench-skiplist.log"
+              "$TOPLING/bin/memtablerep_bench" "${mt[@]}" \
+                -memtablerep='cspp:{"mem_cap":"16G","use_hugepage":false}' \
+                2>&1 | tee "${logdir}/memtablerep_bench-cspp.log"
+            fi
+            rm -rf "$DB_PATH"
+          }
+
+          run_topling_suite topling "$YAML_BASE" 1
+          run_topling_suite topling-dictzip10 "$YAML_DZ10" 0
+
+      - name: Run RocksDB v8.10 benches
+        run: |
+          set -xe
+          ENG="$RUN_PREFIX/rocksdb-v8.10"
+          export LD_LIBRARY_PATH="$ENG/lib:${LD_LIBRARY_PATH:-}"
+          ldd "$ENG/bin/db_bench" || true
+          mkdir -p logs/rocksdb-v8.10
+          DB_PATH=/dev/shm/db_bench_rocksdb_v810
+          record_shm() {
+            local label="$1"
+            {
+              echo "apparent_bytes=$(du -sb "$DB_PATH" | awk '{print $1}')"
+              echo "allocated_bytes=$(du -s -B1 "$DB_PATH" | awk '{print $1}')"
+            } | tee "logs/rocksdb-v8.10/shm_usage-${label}.txt"
+            du -sh --apparent-size "$DB_PATH" || true
+            du -sh "$DB_PATH" || true
+            df -h /dev/shm
+          }
+
+          # Pass 1: fillrandom + compact.
+          rm -rf "$DB_PATH"
+          mkdir -p "$DB_PATH"
+          args_fr=(
+              -db="$DB_PATH"
+              -num=50000000
+              -key_size=8
+              -value_size=15
+              -batch_size=1000
+              -benchmarks=fillrandom,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+              -progress_reports=false
+          )
+          "$ENG/bin/db_bench" "${args_fr[@]}" 2>&1 | tee logs/rocksdb-v8.10/db_bench-fillrandom.log
+          record_shm fillrandom
+          rm -rf "$DB_PATH"
+
+          # Pass 2: existing fillseq suite.
+          mkdir -p "$DB_PATH"
+          args=(
+              -db="$DB_PATH"
+              -num=50000000
+              -key_size=8
+              -value_size=15
+              -batch_size=1000
+              -benchmarks=fillseq,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+              -progress_reports=false
+          )
+          "$ENG/bin/db_bench" "${args[@]}" 2>&1 | tee logs/rocksdb-v8.10/db_bench.log
+          record_shm fillseq
+          mt=(
+            -benchmarks=fillrandom,readrandom,readwrite
+            -item_size=0
+            -num_operations=100000000
+            -write_buffer_size=536870912
+          )
+          "$ENG/bin/memtablerep_bench" "${mt[@]}" -memtablerep=skiplist \
+            2>&1 | tee logs/rocksdb-v8.10/memtablerep_bench-skiplist.log
+          rm -rf "$DB_PATH"
+
+      - name: Run RocksDB master benches
+        run: |
+          set -xe
+          ENG="$RUN_PREFIX/rocksdb-master"
+          export LD_LIBRARY_PATH="$ENG/lib:${LD_LIBRARY_PATH:-}"
+          ldd "$ENG/bin/db_bench" || true
+          mkdir -p logs/rocksdb-master
+          DB_PATH=/dev/shm/db_bench_rocksdb_master
+          record_shm() {
+            local label="$1"
+            {
+              echo "apparent_bytes=$(du -sb "$DB_PATH" | awk '{print $1}')"
+              echo "allocated_bytes=$(du -s -B1 "$DB_PATH" | awk '{print $1}')"
+            } | tee "logs/rocksdb-master/shm_usage-${label}.txt"
+            du -sh --apparent-size "$DB_PATH" || true
+            du -sh "$DB_PATH" || true
+            df -h /dev/shm
+          }
+
+          # Pass 1: fillrandom + compact.
+          rm -rf "$DB_PATH"
+          mkdir -p "$DB_PATH"
+          args_fr=(
+              -db="$DB_PATH"
+              -num=50000000
+              -key_size=8
+              -value_size=15
+              -batch_size=1000
+              -benchmarks=fillrandom,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+              -progress_reports=false
+          )
+          "$ENG/bin/db_bench" "${args_fr[@]}" 2>&1 | tee logs/rocksdb-master/db_bench-fillrandom.log
+          record_shm fillrandom
+          rm -rf "$DB_PATH"
+
+          # Pass 2: existing fillseq suite.
+          mkdir -p "$DB_PATH"
+          args=(
+              -db="$DB_PATH"
+              -num=50000000
+              -key_size=8
+              -value_size=15
+              -batch_size=1000
+              -benchmarks=fillseq,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+              -progress_reports=false
+          )
+          "$ENG/bin/db_bench" "${args[@]}" 2>&1 | tee logs/rocksdb-master/db_bench.log
+          record_shm fillseq
+          mt=(
+            -benchmarks=fillrandom,readrandom,readwrite
+            -item_size=0
+            -num_operations=100000000
+            -write_buffer_size=536870912
+          )
+          "$ENG/bin/memtablerep_bench" "${mt[@]}" -memtablerep=skiplist \
+            2>&1 | tee logs/rocksdb-master/memtablerep_bench-skiplist.log
+          rm -rf "$DB_PATH"
+
+      - name: Emit pages fragment
+        run: |
+          set -xe
+          python3 .github/scripts/bench_logs_to_pages.py emit \
+            --variant "$VARIANT" \
+            --run-id "$GITHUB_RUN_ID" \
+            --log-root logs \
+            --out _pages
+
+      - name: Checkout gh-pages
+        id: checkout_pages
+        continue-on-error: true
+        uses: actions/checkout@v4
+        with:
+          ref: gh-pages
+          path: _gh_pages
+
+      - name: Init gh-pages if missing
+        if: steps.checkout_pages.outcome == 'failure'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -xe
+          rm -rf _gh_pages
+          mkdir -p _gh_pages
+          cd _gh_pages
+          git init
+          git checkout -b gh-pages
+          echo '[]' > history.json
+          touch .nojekyll
+          printf '%s\n' '<!DOCTYPE html><html><body><h1>ToplingDB vs RocksDB</h1><p>empty</p></body></html>' > index.html
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add .
+          git commit -m "Initialize gh-pages for db_bench results"
+          git remote add origin "https://x-access-token:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}.git"
+          git push -u origin gh-pages
+
+      - name: Merge into gh-pages tree
+        run: |
+          set -xe
+          python3 .github/scripts/bench_logs_to_pages.py merge \
+            --merge-into _gh_pages \
+            --from _pages \
+            --variant "$VARIANT"
+
+      - name: Push gh-pages
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -xe
+          cd _gh_pages
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git remote set-url origin "https://x-access-token:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}.git"
+          git add -A
+          if git diff --cached --quiet; then
+            echo "No site changes to commit"
+          else
+            git commit -m "db_bench ${VARIANT} comparison from run ${GITHUB_RUN_ID}"
+          fi
+          git push origin HEAD:gh-pages
+
+      - name: Prepare Pages payload without .git
+        run: |
+          set -xe
+          rm -rf _pages_payload
+          mkdir -p _pages_payload
+          tar -C _gh_pages --exclude .git -cf - . | tar -C _pages_payload -xf -
+
+      - name: Upload Pages artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: _pages_payload
+
+  deploy:
+    needs: bench-and-publish
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/.github/workflows/db_bench-avx512.yml b/.github/workflows/db_bench-avx512.yml
deleted file mode 100644
index 9d2fa4c867..0000000000
--- a/.github/workflows/db_bench-avx512.yml
+++ /dev/null
@@ -1,93 +0,0 @@
-# TODO: How to cache make files / speed up build progress here?
-name: "db_bench-avx512"
-
-on:
-  workflow_dispatch:
-    inputs:
-      use_clang:
-        type: boolean
-        required: false
-        default: false
-        description: use clang
-
-jobs:
-  build:
-    # refer https://github.com/actions/runner-images to get the details
-    runs-on: ubuntu-latest
-    env:
-      GITHUB_TOKEN: ${{github.token}}
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 1
-
-      - name: Install Prerequisites
-        run: |
-         set -xe
-         sudo apt-get update -y && sudo apt-get install -y \
-         libjemalloc-dev libaio-dev libgflags-dev zlib1g-dev \
-         libbz2-dev libcurl4-openssl-dev liburing-dev \
-         libsnappy-dev libbz2-dev liblz4-dev libzstd-dev
-
-      - name: Init submodule & Setup ssh
-        run: |
-         git submodule update --init --recursive
-         mkdir -p ~/.ssh && mkdir -p /opt/lib
-         ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
-         echo nproc = `nproc`
-
-      - name: Git clone SidePlugin(s)
-        run: |
-          # this will be auto triggerred in normal build, we defined
-          # it here is just for seperate steps more clearly.
-          # there is no dedicated target for this purpose, so we use `clean`
-          # as the target, it need not any `clean` at this point.
-          # `clean` is just used for triggers auto git clone
-          make clean
-
-      - name: Compile db_bench
-        run: |
-          set -xe
-          if ${{inputs.use_clang}}; then
-            export CXX=clang++
-            export CC=clang
-          fi
-          export CPU=-march=skylake-avx512
-          make db_bench memtablerep_bench -j`nproc` DEBUG_LEVEL=0 UPDATE_REPO=0
-
-      - name: Run db_bench
-        run: |
-          set -xe
-          make db_bench -j`nproc` DEBUG_LEVEL=0 UPDATE_REPO=0
-          export TOPLINGDB_GetContext_sampling=kNone
-          export ROCKSDB_KICK_OUT_OPTIONS_FILE=1
-          args=(
-              -json sideplugin/rockside/sample-conf/db_bench_enterprise.yaml
-              -num=50000000
-              -key_size=8
-              -value_size=10
-              -batch_size=1000
-              -benchmarks=fillseq,compact,nextwithkey,nextwithkey,nextwithkey,readseq,readseq,readseq,readrandom,readrandom,readrandom
-              -scan_omit_key -scan_omit_value # ToplingDB specific
-              -enable_zero_copy # ToplingDB specific, for point search by Get/MultiGet
-              -progress_reports=false
-          )
-          ./db_bench ${args[@]}
-
-      - name: Run memtablerep_bench
-        run: |
-          args=(
-            -benchmarks=fillrandom,readrandom,readwrite
-            -item_size=0
-            -num_operations=100000000
-            -write_buffer_size=536870912
-          )
-          set -xe
-          ./memtablerep_bench ${args[@]} -memtablerep=skiplist
-          echo
-          ./memtablerep_bench ${args[@]} -memtablerep='cspp:{"mem_cap":"16G","use_hugepage":false}'
diff --git a/.github/workflows/db_bench-build.yml b/.github/workflows/db_bench-build.yml
new file mode 100644
index 0000000000..8676ee0ab0
--- /dev/null
+++ b/.github/workflows/db_bench-build.yml
@@ -0,0 +1,139 @@
+# Replaces the old db_bench.yml (compile+run monolith).
+# Builds ToplingDB + upstream RocksDB v8.10 + RocksDB master for comparison.
+# db_bench-run.yml executes benches and publishes Pages.
+name: "db_bench-build"
+
+on:
+  workflow_dispatch:
+    inputs:
+      use_clang:
+        type: boolean
+        required: false
+        default: false
+        description: use clang
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    env:
+      GITHUB_TOKEN: ${{github.token}}
+    permissions:
+      contents: read
+      actions: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Install Prerequisites
+        run: |
+          set -xe
+          sudo apt-get update -y && sudo apt-get install -y \
+            libjemalloc-dev libaio-dev libgflags-dev zlib1g-dev \
+            libbz2-dev libcurl4-openssl-dev liburing-dev \
+            libsnappy-dev libbz2-dev liblz4-dev libzstd-dev
+
+      - name: Init submodule & Setup ssh
+        run: |
+          git submodule update --init --recursive
+          mkdir -p ~/.ssh && mkdir -p /opt/lib
+          ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
+          echo nproc = `nproc`
+
+      - name: Git clone SidePlugin(s)
+        run: |
+          # make clean triggers SidePlugin auto git clone
+          make clean
+
+      - name: Compile ToplingDB db_bench
+        run: |
+          set -xe
+          if ${{inputs.use_clang}}; then
+            export CXX=clang++
+            export CC=clang
+          fi
+          make db_bench memtablerep_bench -j`nproc` DEBUG_LEVEL=0 UPDATE_REPO=0
+
+      - name: Stage ToplingDB prefix
+        run: |
+          set -xe
+          BUNDLE="$PWD/_bench_bundle"
+          STAGE="$PWD/_bench_stage"
+          PREFIX="/usr/local"
+          rm -rf "$BUNDLE" "$STAGE"
+          mkdir -p "$BUNDLE"
+          make install DESTDIR="$STAGE" PREFIX="$PREFIX" DEBUG_LEVEL=0 UPDATE_REPO=0
+          mkdir -p "$STAGE$PREFIX/bin" "$STAGE$PREFIX/toplingdb-conf" "$STAGE$PREFIX/site"
+          cp -a db_bench memtablerep_bench "$STAGE$PREFIX/bin/"
+          cp -a sideplugin/rockside/sample-conf/db_bench_enterprise.yaml \
+                "$STAGE$PREFIX/toplingdb-conf/"
+          # CI-only override in staged copy (do not edit rockside submodule).
+          sed -i 's/^\([[:space:]]*write_buffer_size:[[:space:]]*\)2G/\1512M/' \
+            "$STAGE$PREFIX/toplingdb-conf/db_bench_enterprise.yaml"
+          grep -E 'write_buffer_size:[[:space:]]*512M' \
+            "$STAGE$PREFIX/toplingdb-conf/db_bench_enterprise.yaml"
+          cp -a sideplugin/rockside/src/topling/web/index.html \
+                sideplugin/rockside/src/topling/web/style.css \
+                "$STAGE$PREFIX/site/"
+          test -x "$STAGE$PREFIX/bin/db_bench"
+          test -x "$STAGE$PREFIX/bin/memtablerep_bench"
+          test -f "$STAGE$PREFIX/toplingdb-conf/db_bench_enterprise.yaml"
+          test -d "$STAGE$PREFIX/lib"
+          mv "$STAGE$PREFIX" "$BUNDLE/topling"
+          rm -rf "$STAGE"
+          echo "BUNDLE=$BUNDLE" >> "$GITHUB_ENV"
+        env:
+          USE_CLANG: ${{ inputs.use_clang }}
+
+      - name: Build upstream RocksDB v8.10 and master
+        run: |
+          set -xe
+          chmod +x .github/scripts/build_upstream_rocksdb.sh
+          if ${{inputs.use_clang}}; then
+            export CXX=clang++
+            export CC=clang
+          fi
+          # Script removes each clone tree after staging that engine.
+          .github/scripts/build_upstream_rocksdb.sh v8.10.2 "$BUNDLE/rocksdb-v8.10"
+          df -h
+          .github/scripts/build_upstream_rocksdb.sh master "$BUNDLE/rocksdb-master"
+          test -x "$BUNDLE/rocksdb-v8.10/bin/db_bench"
+          test -x "$BUNDLE/rocksdb-master/bin/db_bench"
+          df -h
+
+      - name: Pack bench bundle artifact
+        run: |
+          set -xe
+          python3 - <<'PY'
+          import json, os
+          from datetime import datetime, timezone
+          from pathlib import Path
+          bundle = Path(os.environ["BUNDLE"])
+          meta = {
+              "git_sha": os.environ.get("GITHUB_SHA", ""),
+              "run_id": os.environ.get("GITHUB_RUN_ID", ""),
+              "variant": "plain",
+              "use_clang": os.environ.get("USE_CLANG", "false"),
+              "timestamp": datetime.now(timezone.utc).isoformat(),
+              "engines": ["topling", "rocksdb-v8.10", "rocksdb-master"],
+          }
+          (bundle / "build-meta.json").write_text(
+              json.dumps(meta, indent=2) + "\n", encoding="utf-8"
+          )
+          PY
+          tar -C "$BUNDLE" -czf bench-prefix.tgz .
+          tar -tzf bench-prefix.tgz | head -40
+          # Keep only the tarball for upload.
+          rm -rf "$BUNDLE"
+          df -h
+        env:
+          USE_CLANG: ${{ inputs.use_clang }}
+
+      - name: Upload bench prefix artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: db_bench-bin-plain
+          path: bench-prefix.tgz
+          retention-days: 14
diff --git a/.github/workflows/db_bench-run.yml b/.github/workflows/db_bench-run.yml
new file mode 100644
index 0000000000..1ad1566507
--- /dev/null
+++ b/.github/workflows/db_bench-run.yml
@@ -0,0 +1,386 @@
+# Triggered after db_bench-build. Runs ToplingDB + RocksDB v8.10 + RocksDB master,
+# emits comparison tables, publishes Pages.
+name: "db_bench-run"
+
+on:
+  workflow_run:
+    workflows: ["db_bench-build"]
+    types: [completed]
+  workflow_dispatch:
+    inputs:
+      build_run_id:
+        description: Build workflow run id whose artifact to download
+        required: true
+        type: string
+
+concurrency:
+  group: pages-deploy
+  cancel-in-progress: false
+
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+  actions: read
+
+jobs:
+  bench-and-publish:
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }}
+    runs-on: ubuntu-latest
+    env:
+      VARIANT: plain
+      ARTIFACT_NAME: db_bench-bin-plain
+    steps:
+      - name: Checkout build commit
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+          ref: ${{ github.event_name == 'workflow_run' && github.event.workflow_run.head_sha || github.sha }}
+
+      - name: Install runtime dependencies
+        run: |
+          set -xe
+          sudo apt-get update -y && sudo apt-get install -y \
+            libjemalloc-dev libaio-dev libgflags-dev zlib1g-dev \
+            libbz2-dev libcurl4-openssl-dev liburing-dev \
+            libsnappy-dev liblz4-dev libzstd-dev
+
+      - name: Download build artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ env.ARTIFACT_NAME }}
+          run-id: ${{ github.event_name == 'workflow_dispatch' && inputs.build_run_id || github.event.workflow_run.id }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          path: _artifact
+
+      - name: Unpack bench bundle
+        run: |
+          set -xe
+          RUN_PREFIX="$PWD/_run_prefix"
+          rm -rf "$RUN_PREFIX" logs
+          mkdir -p "$RUN_PREFIX" logs
+          tar -C "$RUN_PREFIX" -xzf _artifact/bench-prefix.tgz
+          test -d "$RUN_PREFIX/topling"
+          test -d "$RUN_PREFIX/rocksdb-v8.10"
+          test -d "$RUN_PREFIX/rocksdb-master"
+          test -x "$RUN_PREFIX/topling/bin/db_bench"
+          test -x "$RUN_PREFIX/rocksdb-v8.10/bin/db_bench"
+          test -x "$RUN_PREFIX/rocksdb-master/bin/db_bench"
+          echo "RUN_PREFIX=$RUN_PREFIX" >> "$GITHUB_ENV"
+
+      - name: Probe /dev/shm
+        run: |
+          set -xe
+          # Engines rotate exclusive use of /dev/shm (one DB at a time).
+          # Do not pre-create all three DB dirs here.
+          df -h /dev/shm
+
+      - name: Run ToplingDB benches
+        run: |
+          set -xe
+          TOPLING="$RUN_PREFIX/topling"
+          export LD_LIBRARY_PATH="$TOPLING/lib:${LD_LIBRARY_PATH:-}"
+          ldd "$TOPLING/bin/db_bench"
+          export TOPLINGDB_GetContext_sampling=kNone
+          export ROCKSDB_KICK_OUT_OPTIONS_FILE=1
+          DB_PATH=/dev/shm/db_bench_enterprise
+          YAML_BASE="$TOPLING/toplingdb-conf/db_bench_enterprise.yaml"
+          # CI-only: shrink write_buffer without touching rockside submodule.
+          sed -i 's/^\([[:space:]]*write_buffer_size:[[:space:]]*\)2G/\1512M/' "$YAML_BASE"
+          grep -E 'write_buffer_size:[[:space:]]*512M' "$YAML_BASE"
+          # Parallel config: enable DictZip for value_size=15 (default yaml is 3000).
+          YAML_DZ10="$TOPLING/toplingdb-conf/db_bench_enterprise_dictzip10.yaml"
+          cp -a "$YAML_BASE" "$YAML_DZ10"
+          sed -i 's/^\([[:space:]]*minDictZipValueSize:[[:space:]]*\)3000/\110/' "$YAML_DZ10"
+          grep -E 'minDictZipValueSize:[[:space:]]*10$' "$YAML_DZ10"
+
+          prepare_db() {
+            rm -rf "$DB_PATH"
+            mkdir -p "$DB_PATH"
+            if [ -d "$TOPLING/site" ]; then
+              cp -a "$TOPLING/site/." "$DB_PATH/"
+            fi
+          }
+
+          # eng_id log dir name; yaml path; run_memtable 0|1
+          run_topling_suite() {
+            local eng_id="$1"
+            local yaml="$2"
+            local run_memtable="$3"
+            local logdir="logs/${eng_id}"
+            mkdir -p "$logdir"
+            record_shm() {
+              local label="$1"
+              {
+                echo "apparent_bytes=$(du -sb "$DB_PATH" | awk '{print $1}')"
+                echo "allocated_bytes=$(du -s -B1 "$DB_PATH" | awk '{print $1}')"
+              } | tee "${logdir}/shm_usage-${label}.txt"
+              du -sh --apparent-size "$DB_PATH" || true
+              du -sh "$DB_PATH" || true
+              df -h /dev/shm
+            }
+
+            # Pass 1: fillrandom suite, then omit lazy-load demo.
+            prepare_db
+            args_fr=(
+                -json "$yaml"
+                -num=50000000
+                -key_size=8
+                -value_size=15
+                -batch_size=1000
+                -benchmarks=fillrandom,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+                -enable_zero_copy
+                -progress_reports=false
+            )
+            "$TOPLING/bin/db_bench" "${args_fr[@]}" 2>&1 | tee "${logdir}/db_bench-fillrandom.log"
+            args_omit=(
+                -json "$yaml"
+                -num=50000000
+                -key_size=8
+                -value_size=15
+                -batch_size=1000
+                -benchmarks=nextwithkey,nextwithkey,nextwithkey,readseq,readseq,readseq
+                -scan_omit_key -scan_omit_value
+                -use_existing_db=1
+                -enable_zero_copy
+                -progress_reports=false
+            )
+            "$TOPLING/bin/db_bench" "${args_omit[@]}" 2>&1 | tee "${logdir}/db_bench-fillrandom-omit.log"
+            record_shm fillrandom
+            rm -rf "$DB_PATH"
+
+            # Pass 2: fillseq suite, then omit lazy-load demo.
+            prepare_db
+            args=(
+                -json "$yaml"
+                -num=50000000
+                -key_size=8
+                -value_size=15
+                -batch_size=1000
+                -benchmarks=fillseq,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+                -enable_zero_copy
+                -progress_reports=false
+            )
+            "$TOPLING/bin/db_bench" "${args[@]}" 2>&1 | tee "${logdir}/db_bench.log"
+            "$TOPLING/bin/db_bench" "${args_omit[@]}" 2>&1 | tee "${logdir}/db_bench-fillseq-omit.log"
+            record_shm fillseq
+            if [ "$run_memtable" = "1" ]; then
+              mt=(
+                -benchmarks=fillrandom,readrandom,readwrite
+                -item_size=0
+                -num_operations=100000000
+                -write_buffer_size=536870912
+              )
+              "$TOPLING/bin/memtablerep_bench" "${mt[@]}" -memtablerep=skiplist \
+                2>&1 | tee "${logdir}/memtablerep_bench-skiplist.log"
+              "$TOPLING/bin/memtablerep_bench" "${mt[@]}" \
+                -memtablerep='cspp:{"mem_cap":"16G","use_hugepage":false}' \
+                2>&1 | tee "${logdir}/memtablerep_bench-cspp.log"
+            fi
+            rm -rf "$DB_PATH"
+          }
+
+          run_topling_suite topling "$YAML_BASE" 1
+          run_topling_suite topling-dictzip10 "$YAML_DZ10" 0
+
+      - name: Run RocksDB v8.10 benches
+        run: |
+          set -xe
+          ENG="$RUN_PREFIX/rocksdb-v8.10"
+          export LD_LIBRARY_PATH="$ENG/lib:${LD_LIBRARY_PATH:-}"
+          ldd "$ENG/bin/db_bench" || true
+          mkdir -p logs/rocksdb-v8.10
+          DB_PATH=/dev/shm/db_bench_rocksdb_v810
+          record_shm() {
+            local label="$1"
+            {
+              echo "apparent_bytes=$(du -sb "$DB_PATH" | awk '{print $1}')"
+              echo "allocated_bytes=$(du -s -B1 "$DB_PATH" | awk '{print $1}')"
+            } | tee "logs/rocksdb-v8.10/shm_usage-${label}.txt"
+            du -sh --apparent-size "$DB_PATH" || true
+            du -sh "$DB_PATH" || true
+            df -h /dev/shm
+          }
+
+          # Pass 1: fillrandom + compact.
+          rm -rf "$DB_PATH"
+          mkdir -p "$DB_PATH"
+          args_fr=(
+              -db="$DB_PATH"
+              -num=50000000
+              -key_size=8
+              -value_size=15
+              -batch_size=1000
+              -benchmarks=fillrandom,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+              -progress_reports=false
+          )
+          "$ENG/bin/db_bench" "${args_fr[@]}" 2>&1 | tee logs/rocksdb-v8.10/db_bench-fillrandom.log
+          record_shm fillrandom
+          rm -rf "$DB_PATH"
+
+          # Pass 2: existing fillseq suite.
+          mkdir -p "$DB_PATH"
+          args=(
+              -db="$DB_PATH"
+              -num=50000000
+              -key_size=8
+              -value_size=15
+              -batch_size=1000
+              -benchmarks=fillseq,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+              -progress_reports=false
+          )
+          "$ENG/bin/db_bench" "${args[@]}" 2>&1 | tee logs/rocksdb-v8.10/db_bench.log
+          record_shm fillseq
+          mt=(
+            -benchmarks=fillrandom,readrandom,readwrite
+            -item_size=0
+            -num_operations=100000000
+            -write_buffer_size=536870912
+          )
+          "$ENG/bin/memtablerep_bench" "${mt[@]}" -memtablerep=skiplist \
+            2>&1 | tee logs/rocksdb-v8.10/memtablerep_bench-skiplist.log
+          rm -rf "$DB_PATH"
+
+      - name: Run RocksDB master benches
+        run: |
+          set -xe
+          ENG="$RUN_PREFIX/rocksdb-master"
+          export LD_LIBRARY_PATH="$ENG/lib:${LD_LIBRARY_PATH:-}"
+          ldd "$ENG/bin/db_bench" || true
+          mkdir -p logs/rocksdb-master
+          DB_PATH=/dev/shm/db_bench_rocksdb_master
+          record_shm() {
+            local label="$1"
+            {
+              echo "apparent_bytes=$(du -sb "$DB_PATH" | awk '{print $1}')"
+              echo "allocated_bytes=$(du -s -B1 "$DB_PATH" | awk '{print $1}')"
+            } | tee "logs/rocksdb-master/shm_usage-${label}.txt"
+            du -sh --apparent-size "$DB_PATH" || true
+            du -sh "$DB_PATH" || true
+            df -h /dev/shm
+          }
+
+          # Pass 1: fillrandom + compact.
+          rm -rf "$DB_PATH"
+          mkdir -p "$DB_PATH"
+          args_fr=(
+              -db="$DB_PATH"
+              -num=50000000
+              -key_size=8
+              -value_size=15
+              -batch_size=1000
+              -benchmarks=fillrandom,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+              -progress_reports=false
+          )
+          "$ENG/bin/db_bench" "${args_fr[@]}" 2>&1 | tee logs/rocksdb-master/db_bench-fillrandom.log
+          record_shm fillrandom
+          rm -rf "$DB_PATH"
+
+          # Pass 2: existing fillseq suite.
+          mkdir -p "$DB_PATH"
+          args=(
+              -db="$DB_PATH"
+              -num=50000000
+              -key_size=8
+              -value_size=15
+              -batch_size=1000
+              -benchmarks=fillseq,compact,readseq,readseq,readseq,readrandom,readrandom,readrandom
+              -progress_reports=false
+          )
+          "$ENG/bin/db_bench" "${args[@]}" 2>&1 | tee logs/rocksdb-master/db_bench.log
+          record_shm fillseq
+          mt=(
+            -benchmarks=fillrandom,readrandom,readwrite
+            -item_size=0
+            -num_operations=100000000
+            -write_buffer_size=536870912
+          )
+          "$ENG/bin/memtablerep_bench" "${mt[@]}" -memtablerep=skiplist \
+            2>&1 | tee logs/rocksdb-master/memtablerep_bench-skiplist.log
+          rm -rf "$DB_PATH"
+
+      - name: Emit pages fragment
+        run: |
+          set -xe
+          python3 .github/scripts/bench_logs_to_pages.py emit \
+            --variant "$VARIANT" \
+            --run-id "$GITHUB_RUN_ID" \
+            --log-root logs \
+            --out _pages
+
+      - name: Checkout gh-pages
+        id: checkout_pages
+        continue-on-error: true
+        uses: actions/checkout@v4
+        with:
+          ref: gh-pages
+          path: _gh_pages
+
+      - name: Init gh-pages if missing
+        if: steps.checkout_pages.outcome == 'failure'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -xe
+          rm -rf _gh_pages
+          mkdir -p _gh_pages
+          cd _gh_pages
+          git init
+          git checkout -b gh-pages
+          echo '[]' > history.json
+          touch .nojekyll
+          printf '%s\n' '<!DOCTYPE html><html><body><h1>ToplingDB vs RocksDB</h1><p>empty</p></body></html>' > index.html
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add .
+          git commit -m "Initialize gh-pages for db_bench results"
+          git remote add origin "https://x-access-token:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}.git"
+          git push -u origin gh-pages
+
+      - name: Merge into gh-pages tree
+        run: |
+          set -xe
+          python3 .github/scripts/bench_logs_to_pages.py merge \
+            --merge-into _gh_pages \
+            --from _pages \
+            --variant "$VARIANT"
+
+      - name: Push gh-pages
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -xe
+          cd _gh_pages
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git remote set-url origin "https://x-access-token:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}.git"
+          git add -A
+          if git diff --cached --quiet; then
+            echo "No site changes to commit"
+          else
+            git commit -m "db_bench ${VARIANT} comparison from run ${GITHUB_RUN_ID}"
+          fi
+          git push origin HEAD:gh-pages
+
+      - name: Prepare Pages payload without .git
+        run: |
+          set -xe
+          rm -rf _pages_payload
+          mkdir -p _pages_payload
+          tar -C _gh_pages --exclude .git -cf - . | tar -C _pages_payload -xf -
+
+      - name: Upload Pages artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: _pages_payload
+
+  deploy:
+    needs: bench-and-publish
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/.github/workflows/db_bench.yml b/.github/workflows/db_bench.yml
deleted file mode 100644
index 0ae0d1eb28..0000000000
--- a/.github/workflows/db_bench.yml
+++ /dev/null
@@ -1,92 +0,0 @@
-# TODO: How to cache make files / speed up build progress here?
-name: "db_bench"
-
-on:
-  workflow_dispatch:
-    inputs:
-      use_clang:
-        type: boolean
-        required: false
-        default: false
-        description: use clang
-
-jobs:
-  build:
-    # refer https://github.com/actions/runner-images to get the details
-    runs-on: ubuntu-latest
-    env:
-      GITHUB_TOKEN: ${{github.token}}
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 1
-
-      - name: Install Prerequisites
-        run: |
-         set -xe
-         sudo apt-get update -y && sudo apt-get install -y \
-         libjemalloc-dev libaio-dev libgflags-dev zlib1g-dev \
-         libbz2-dev libcurl4-openssl-dev liburing-dev \
-         libsnappy-dev libbz2-dev liblz4-dev libzstd-dev
-
-      - name: Init submodule & Setup ssh
-        run: |
-         git submodule update --init --recursive
-         mkdir -p ~/.ssh && mkdir -p /opt/lib
-         ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
-         echo nproc = `nproc`
-
-      - name: Git clone SidePlugin(s)
-        run: |
-          # this will be auto triggerred in normal build, we defined
-          # it here is just for seperate steps more clearly.
-          # there is no dedicated target for this purpose, so we use `clean`
-          # as the target, it need not any `clean` at this point.
-          # `clean` is just used for triggers auto git clone
-          make clean
-
-      - name: Compile db_bench
-        run: |
-          set -xe
-          if ${{inputs.use_clang}}; then
-            export CXX=clang++
-            export CC=clang
-          fi
-          make db_bench memtablerep_bench -j`nproc` DEBUG_LEVEL=0 UPDATE_REPO=0
-
-      - name: Run db_bench
-        run: |
-          set -xe
-          make db_bench -j`nproc` DEBUG_LEVEL=0 UPDATE_REPO=0
-          export TOPLINGDB_GetContext_sampling=kNone
-          export ROCKSDB_KICK_OUT_OPTIONS_FILE=1
-          args=(
-              -json sideplugin/rockside/sample-conf/db_bench_enterprise.yaml
-              -num=50000000
-              -key_size=8
-              -value_size=10
-              -batch_size=1000
-              -benchmarks=fillseq,compact,nextwithkey,nextwithkey,nextwithkey,readseq,readseq,readseq,readrandom,readrandom,readrandom
-              -scan_omit_key -scan_omit_value # ToplingDB specific
-              -enable_zero_copy # ToplingDB specific, for point search by Get/MultiGet
-              -progress_reports=false
-          )
-          ./db_bench ${args[@]}
-
-      - name: Run memtablerep_bench
-        run: |
-          args=(
-            -benchmarks=fillrandom,readrandom,readwrite
-            -item_size=0
-            -num_operations=100000000
-            -write_buffer_size=536870912
-          )
-          set -xe
-          ./memtablerep_bench ${args[@]} -memtablerep=skiplist
-          echo
-          ./memtablerep_bench ${args[@]} -memtablerep='cspp:{"mem_cap":"16G","use_hugepage":false}'
diff --git a/.gitignore b/.gitignore
index 6b6adc03fd..683bfebed5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -108,3 +108,5 @@ third-party/folly/
 
 generated-sources
 target
+
+bconf-*
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 1decc8b01b..e8e43ad687 100644
--- a/Makefile
+++ b/Makefile
@@ -61,8 +61,8 @@ quoted_perl_command = $(subst ','\'',$(perl_command))
 # `make install-shared`, `make static_lib`, `make install-static` or
 # `make install`
 
-# Set the default DEBUG_LEVEL to 1
-DEBUG_LEVEL?=1
+# Set the default DEBUG_LEVEL to 2
+DEBUG_LEVEL?=2
 
 # OBJ_DIR is where the object files reside.  Default to the current directory
 OBJ_DIR?=.
@@ -120,7 +120,7 @@ endif
 ifeq (${DISABLE_JEMALLOC},1)
   ifeq  (${ROCKSDB_DISABLE_JEMALLOC},)
     export_ROCKSDB_DISABLE_JEMALLOC := export ROCKSDB_DISABLE_JEMALLOC=1;
-	export ROCKSDB_DISABLE_JEMALLOC = 1
+    export ROCKSDB_DISABLE_JEMALLOC = 1
   endif
 endif
 
@@ -244,9 +244,15 @@ endif
 # interfaces/internal abstractions, like in the iterator hierarchy. It works
 # better when combined with profile-guided optimizations (not currently
 # supported natively in Makefile).
+OPTION_jemalloc := jemalloc-$(if $(filter 1,${DISABLE_JEMALLOC}),0,1)
+OPTION_dyna_tls := dyna_tls-$(if $(filter 1,${TOPLING_USE_DYNAMIC_TLS}),1,0)
+OPTION_lto := lto-0
 ifeq ($(USE_LTO), 1)
-	CXXFLAGS += -flto
-	LDFLAGS += -flto=auto -fuse-linker-plugin
+	ifeq (${DEBUG_LEVEL},0)
+		CXXFLAGS += -flto
+		LDFLAGS += -flto=auto -fuse-linker-plugin
+		OPTION_lto := lto-$(if $(filter 1,${USE_LTO}),1,0)
+	endif
 endif
 
 # `COERCE_CONTEXT_SWITCH=1` will inject spurious wakeup and
@@ -389,7 +395,7 @@ endif
 TOPLING_LIB_OBJECTS = $(addprefix ${TOPLING_CORE_DIR}/, ${TOPLING_LIB_OBJ_LIST_VAR})
 LDFLAGS += ${TOPLING_CORE_LD_LIBS_EXTRA}
 
-ifneq ($(filter auto_all_tests check check_0 watch-log gen_parallel_tests %_test %_test2 jtest, $(MAKECMDGOALS)),)
+ifneq ($(filter auto_all_tests check check_0 watch-log gen_parallel_tests %_test %_test2 jtest %_test.o %_test2.o, $(MAKECMDGOALS)),)
   MAKE_UNIT_TEST ?= 1
 endif
 ifeq (${MAKE_UNIT_TEST},1)
@@ -406,6 +412,15 @@ endif
 ORIG_OBJ_DIR := ${OBJ_DIR}
 OBJ_DIR := ${BUILD_PREFIX}${OBJ_DIR}/v${ROCKSDB_FULL_VERSION}
 
+# COMPILER is in ignored
+TRIAL_urldir := toplingdb/gpl-trial/${OPTION_lto}-${OPTION_jemalloc}-${OPTION_dyna_tls}/${UNAME_MachineSystem}-bmi2-${WITH_BMI2}/${BUILD_TYPE_SIG}
+ifeq (${PLATFORM},OS_LINUX)
+LINUX_NAME := $(shell source /etc/os-release; echo $$ID)
+ifeq (${LINUX_NAME},centos)
+TRIAL_urldir := ${TRIAL_urldir}/$(shell source /etc/os-release; echo $$ID$$VERSION_ID)
+endif
+endif
+
 # 1. we define ROCKSDB_DISABLE_ZSTD=1 on build_detect_platform.
 # 2. zstd lib is included in libterark-zbs
 # 3. we alway use ZSTD
@@ -432,33 +447,26 @@ ifndef WITH_TOPLING_ROCKS
       cd topling-rocks; \
       git submodule update --init --recursive \
     )
-  endif
-  ifeq (,$(wildcard sideplugin/topling-rocks))
-    WITH_TOPLING_ROCKS := 0
   else
-    WITH_TOPLING_ROCKS := 1
+    ifeq (,$(wildcard sideplugin/topling-rocks/src/table/top_patent_algo.cc))
+      dummy := $(shell rm -rf sideplugin/topling-rocks)
+      dummy := $(shell rm -rf sideplugin/cspp-memtable/cspp_memtable.cc)
+               # check with topling-rocks, not graceful, just works
+    endif
   endif
+  # default 1
+  WITH_TOPLING_ROCKS := 1
 endif
 
 ifeq (${WITH_TOPLING_ROCKS},1)
-ifeq (,$(wildcard sideplugin/topling-rocks))
-  # topling specific: just for people who has permission to topling-rocks
-  dummy := $(shell set -e -x; \
-    cd sideplugin; \
-    git clone ${GIT_TOPLING_ROCKS}; \
-    cd topling-rocks; \
-    git submodule update --init --recursive \
-  )
-else
+ifneq (,$(wildcard sideplugin/topling-rocks))
   ifneq (${UPDATE_REPO},0)
    ifeq (${MAKE_RESTARTS},)
     dummy := $(shell set -ex; cd sideplugin/topling-rocks && git pull)
    endif
   endif
 endif
-ifeq (,$(wildcard sideplugin/topling-rocks/src/table/top_zip_table_builder.cc))
-  $(error WITH_TOPLING_ROCKS=1 but repo sideplugin/topling-rocks is broken)
-endif
+CXXFLAGS += -DHAS_TOPLING_ROCKS
 endif
 
 ifeq (,$(wildcard sideplugin/cspp-memtable))
@@ -489,14 +497,35 @@ else
   endif
 endif
 
-ifneq (,$(wildcard sideplugin/cspp-memtable))
-  # now we have cspp-memtable
-  CXXFLAGS   += -DHAS_TOPLING_CSPP_MEMTABLE
-  CSPP_MEMTABLE_GIT_VER_SRC = ${BUILD_ROOT}/git-version-cspp_memtable.cc
-  EXTRA_LIB_SOURCES += sideplugin/cspp-memtable/cspp_memtable.cc \
-                       sideplugin/cspp-memtable/${CSPP_MEMTABLE_GIT_VER_SRC}
+WITH_CSPP_MEMTABLE ?= 1 # allow override by env or cmd line
+
+ifeq (${WITH_CSPP_MEMTABLE}${WITH_TOPLING_ROCKS},10)
+  $(error "When WITH_CSPP_MEMTABLE is 1, WITH_TOPLING_ROCKS must be 1 also")
+endif
+
+ifneq (,$(wildcard sideplugin/cspp-memtable/cspp_memtable.cc))
+  ifeq (${WITH_CSPP_MEMTABLE},0)
+    $(warning cspp-memtable exists but intentional disabled)
+  else
+    # now we have cspp-memtable
+    CXXFLAGS   += -DHAS_TOPLING_CSPP_MEMTABLE
+    CSPP_MEMTABLE_GIT_VER_SRC = ${BUILD_ROOT}/git-version-cspp_memtable.cc
+    ifeq (,${TOPLING_ZIP_TABLE_TRIAL_DAYS})
+      EXTRA_LIB_SOURCES += sideplugin/cspp-memtable/cspp_memtable.cc \
+                           sideplugin/cspp-memtable/${CSPP_MEMTABLE_GIT_VER_SRC}
+    else
+      # no CSPP_MEMTABLE_GIT_VER_SRC
+      EXTRA_LIB_SOURCES += sideplugin/topling-zip_table_reader/cspp_memtable.cc
+    endif
+  endif
 else
-  $(warning NotFound sideplugin/cspp-memtable, this is ok, only Topling CSPP MemTab is disabled)
+  ifeq (${WITH_CSPP_MEMTABLE},0)
+    $(warning cspp-memtable does not exist, intentional disabled, not use trial)
+  else
+    # use dir topling-zip_table_reader, not graceful, just works
+    # this file does not exist, just for generating filepath cspp_memtable.o
+    EXTRA_LIB_SOURCES += sideplugin/topling-zip_table_reader/cspp_memtable.cc
+  endif
 endif
 
 ifneq (,$(wildcard sideplugin/cspp-wbwi))
@@ -611,13 +640,14 @@ endif # WITH_TOPLING_DCOMPACT
 ifeq (${WITH_TOPLING_ROCKS},1)
 ifneq (,$(wildcard sideplugin/topling-rocks))
   CXXFLAGS   +=  -Isideplugin/topling-rocks/src
-  CXXFLAGS   +=  -DHAS_TOPLING_ROCKS
   TOPLING_ROCKS_GIT_VER_SRC = ${BUILD_ROOT}/git-version-topling_rocks.cc
-  EXTRA_LIB_SOURCES += \
-    $(wildcard sideplugin/topling-rocks/src/table/*.cc) \
-    sideplugin/topling-rocks/${TOPLING_ROCKS_GIT_VER_SRC}
-else
-  $(warning NotFound sideplugin/topling-rocks, this is ok, only ToplingZipTable is disabled)
+  ifeq (,${TOPLING_ZIP_TABLE_TRIAL_DAYS})
+    EXTRA_LIB_SOURCES += $(wildcard sideplugin/topling-rocks/src/table/*.cc)
+    EXTRA_LIB_SOURCES += sideplugin/topling-rocks/${TOPLING_ROCKS_GIT_VER_SRC}
+  else
+    # no TOPLING_ROCKS_GIT_VER_SRC
+    EXTRA_LIB_SOURCES += sideplugin/topling-zip_table_reader/top_zip_table_builder.cc
+  endif
 endif
 endif
 
@@ -785,7 +815,7 @@ endif
 
 ifeq ($(LIB_MODE),shared)
 # So that binaries are executable from build location, in addition to install location
-EXEC_LDFLAGS += -Wl,-rpath -Wl,'$$ORIGIN'
+EXEC_LDFLAGS += -Wl,-rpath -Wl,'$$ORIGIN:$$ORIGIN/../lib'
 endif
 
 ifeq ($(PLATFORM), OS_MACOSX)
@@ -1033,6 +1063,9 @@ endif
 # topling specific WARNING_FLAGS
 WARNING_FLAGS := -Wall -Wno-shadow
 ifeq "$(shell a=${COMPILER};echo $${a:0:5})" "clang"
+  CXXFLAGS := $(patsubst -flto, -flto=thin, ${CXXFLAGS})
+  LLD_LTO_FLAGS := -fuse-ld=lld -flto=thin -Wl,--thinlto-jobs=all
+  LDFLAGS := $(patsubst -flto=auto, ${LLD_LTO_FLAGS}, ${LDFLAGS})
   LDFLAGS += -latomic
   #$(error LDFLAGS = ${LDFLAGS})
   WARNING_FLAGS += -Wno-deprecated-builtins
@@ -1100,6 +1133,12 @@ ifneq ($(PPC_LIBC_IS_GNU),0)
   LIB_OBJECTS += $(patsubst %.cc, $(OBJ_DIR)/%.o, $(RANGE_TREE_SOURCES))
 endif
 
+ifeq (${WITH_TOPLING_ROCKS},1)
+  ifeq (,$(wildcard sideplugin/topling-rocks))
+    LIB_OBJECTS += $(OBJ_DIR)/sideplugin/topling-zip_table_reader/top_zip_table_builder.o
+  endif
+endif
+
 GTEST = $(OBJ_DIR)/$(GTEST_DIR)/gtest/gtest-all.o
 TESTUTIL = $(OBJ_DIR)/test_util/testutil.o
 TESTHARNESS = $(OBJ_DIR)/test_util/testharness.o $(TESTUTIL) $(GTEST)
@@ -2592,39 +2631,44 @@ install-headers: gen-pc
 	install -d $(INSTALL_LIBDIR)
 	install -d $(INSTALL_LIBDIR)/pkgconfig
 	for header_dir in `$(FIND) "include/rocksdb" -type d`; do \
-		install -d $(DESTDIR)/$(PREFIX)/$$header_dir; \
+		install -d $(DESTDIR)$(PREFIX)/$$header_dir; \
 	done
 	for header in `$(FIND) "include/rocksdb" -type f -name *.h`; do \
-		install -C -m 644 $$header $(DESTDIR)/$(PREFIX)/$$header; \
+		install -C -m 644 $$header $(DESTDIR)$(PREFIX)/$$header; \
 	done
 	for header in $(ROCKSDB_PLUGIN_HEADERS); do \
-		install -d $(DESTDIR)/$(PREFIX)/include/rocksdb/`dirname $$header`; \
-		install -C -m 644 $$header $(DESTDIR)/$(PREFIX)/include/rocksdb/$$header; \
+		install -d $(DESTDIR)$(PREFIX)/include/rocksdb/`dirname $$header`; \
+		install -C -m 644 $$header $(DESTDIR)$(PREFIX)/include/rocksdb/$$header; \
 	done
-	install -d                                  $(DESTDIR)/$(PREFIX)/include/topling
-	install -C -m 644 sideplugin/rockside/src/topling/json.h     $(DESTDIR)/$(PREFIX)/include/topling
-	install -C -m 644 sideplugin/rockside/src/topling/json_fwd.h $(DESTDIR)/$(PREFIX)/include/topling
-	install -C -m 644 sideplugin/rockside/src/topling/builtin_table_factory.h $(DESTDIR)/$(PREFIX)/include/topling
-	install -C -m 644 sideplugin/rockside/src/topling/side_plugin_repo.h      $(DESTDIR)/$(PREFIX)/include/topling
-	install -C -m 644 sideplugin/rockside/src/topling/side_plugin_factory.h   $(DESTDIR)/$(PREFIX)/include/topling
-	install -d $(DESTDIR)/$(PREFIX)/include/terark
-	install -d $(DESTDIR)/$(PREFIX)/include/terark/io
-	install -d $(DESTDIR)/$(PREFIX)/include/terark/succinct
-	install -d $(DESTDIR)/$(PREFIX)/include/terark/thread
-	install -d $(DESTDIR)/$(PREFIX)/include/terark/util
-	install -d $(DESTDIR)/$(PREFIX)/include/terark/fsa
-	install -d $(DESTDIR)/$(PREFIX)/include/terark/fsa/ppi
-	install -d $(DESTDIR)/$(PREFIX)/include/terark/zbs
-	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/*.hpp          $(DESTDIR)/$(PREFIX)/include/terark
-	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/io/*.hpp       $(DESTDIR)/$(PREFIX)/include/terark/io
-	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/succinct/*.hpp $(DESTDIR)/$(PREFIX)/include/terark/succinct
-	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/thread/*.hpp   $(DESTDIR)/$(PREFIX)/include/terark/thread
-	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/util/*.hpp     $(DESTDIR)/$(PREFIX)/include/terark/util
-	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/fsa/*.hpp      $(DESTDIR)/$(PREFIX)/include/terark/fsa
-	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/fsa/*.inl      $(DESTDIR)/$(PREFIX)/include/terark/fsa
-	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/fsa/ppi/*.hpp  $(DESTDIR)/$(PREFIX)/include/terark/fsa/ppi
-	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/zbs/*.hpp      $(DESTDIR)/$(PREFIX)/include/terark/zbs
-	cp -ar ${TOPLING_CORE_DIR}/boost-include/boost  $(DESTDIR)/$(PREFIX)/include
+	install -d                                  $(DESTDIR)$(PREFIX)/include/topling
+	install -C -m 644 sideplugin/rockside/src/topling/json.h     $(DESTDIR)$(PREFIX)/include/topling
+	install -C -m 644 sideplugin/rockside/src/topling/json_fwd.h $(DESTDIR)$(PREFIX)/include/topling
+	install -C -m 644 sideplugin/rockside/src/topling/builtin_table_factory.h $(DESTDIR)$(PREFIX)/include/topling
+	install -C -m 644 sideplugin/rockside/src/topling/side_plugin_repo.h      $(DESTDIR)$(PREFIX)/include/topling
+	install -C -m 644 sideplugin/rockside/src/topling/side_plugin_factory.h   $(DESTDIR)$(PREFIX)/include/topling
+	install -d $(DESTDIR)$(PREFIX)/include/terark
+	install -d $(DESTDIR)$(PREFIX)/include/terark/io
+	install -d $(DESTDIR)$(PREFIX)/include/terark/succinct
+	install -d $(DESTDIR)$(PREFIX)/include/terark/thread
+	install -d $(DESTDIR)$(PREFIX)/include/terark/util
+	install -d $(DESTDIR)$(PREFIX)/include/terark/fsa
+	install -d $(DESTDIR)$(PREFIX)/include/terark/fsa/ppi
+	install -d $(DESTDIR)$(PREFIX)/include/terark/zbs
+	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/*.hpp          $(DESTDIR)$(PREFIX)/include/terark
+	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/io/*.hpp       $(DESTDIR)$(PREFIX)/include/terark/io
+	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/succinct/*.hpp $(DESTDIR)$(PREFIX)/include/terark/succinct
+	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/thread/*.hpp   $(DESTDIR)$(PREFIX)/include/terark/thread
+	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/util/*.hpp     $(DESTDIR)$(PREFIX)/include/terark/util
+	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/fsa/*.hpp      $(DESTDIR)$(PREFIX)/include/terark/fsa
+	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/fsa/*.inl      $(DESTDIR)$(PREFIX)/include/terark/fsa
+	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/fsa/ppi/*.hpp  $(DESTDIR)$(PREFIX)/include/terark/fsa/ppi
+	install -C -m 644 ${TOPLING_CORE_DIR}/src/terark/zbs/*.hpp      $(DESTDIR)$(PREFIX)/include/terark/zbs
+	cp -ar ${TOPLING_CORE_DIR}/boost-include/boost  $(DESTDIR)$(PREFIX)/include
+	install -d $(DESTDIR)$(PREFIX)/site
+	install -d $(DESTDIR)$(PREFIX)/toplingdb-conf
+	install -C -m 644 sideplugin/rockside/src/topling/web/index.html $(DESTDIR)$(PREFIX)/site
+	install -C -m 644 sideplugin/rockside/src/topling/web/style.css  $(DESTDIR)$(PREFIX)/site
+	install -C -m 644 sideplugin/rockside/sample-conf/db_bench_enterprise.yaml $(DESTDIR)$(PREFIX)/toplingdb-conf
 	install -C -m 644 rocksdb.pc $(INSTALL_LIBDIR)/pkgconfig/rocksdb.pc
 
 install-static: $(LIBRARY) static_lib
@@ -2634,6 +2678,9 @@ install-static: $(LIBRARY) static_lib
 install-shared: $(SHARED4) shared_lib
 	install -d $(INSTALL_LIBDIR)
 	install -C -m 755 $(SHARED4) $(INSTALL_LIBDIR)
+ifeq ($(STRIP_DEBUG_INFO),1)
+	$(STRIP_CMD) $(INSTALL_LIBDIR)/$(SHARED4)
+endif
 	ln -fs $(SHARED4) $(INSTALL_LIBDIR)/$(SHARED3)
 	ln -fs $(SHARED4) $(INSTALL_LIBDIR)/$(SHARED2)
 	ln -fs $(SHARED4) $(INSTALL_LIBDIR)/$(SHARED1)
@@ -2643,10 +2690,22 @@ install: install-${LIB_MODE}
 install-dev-static: install-headers install-static
 install-dev-shared: install-headers install-shared
 install-dev: install-dev-${LIB_MODE}
+upload-trial: \
+  ${OBJ_DIR}/sideplugin/topling-zip_table_reader/top_zip_table_builder.o \
+  ${OBJ_DIR}/sideplugin/topling-zip_table_reader/cspp_memtable.o
+	ossutil cp --region=cn-qingdao -f \
+		$(OBJ_DIR)/sideplugin/topling-zip_table_reader/top_zip_table_builder.o \
+		oss://topling-tools/${TRIAL_urldir}/
+	ossutil cp --region=cn-qingdao -f \
+		$(OBJ_DIR)/sideplugin/topling-zip_table_reader/cspp_memtable.o \
+		oss://topling-tools/${TRIAL_urldir}/
 
 install-dcompact: install dcompact_worker
 	install -d $(DESTDIR)$(PREFIX)/bin
 	install -C -m 755 sideplugin/topling-dcompact/tools/dcompact/${ORIG_OBJ_DIR}/dcompact_worker.exe $(DESTDIR)$(PREFIX)/bin
+ifeq ($(STRIP_DEBUG_INFO),1)
+	$(STRIP_CMD) $(DESTDIR)$(PREFIX)/bin/dcompact_worker.exe
+endif
 
 install-tools: install tools
 	mkdir -p $(DESTDIR)$(PREFIX)/bin
@@ -3284,18 +3343,41 @@ ${BUILD_ROOT}/lib_static/libterark-zbs-${COMPILER}-${BUILD_TYPE_SIG}.a:
 	+make -C ${TOPLING_CORE_DIR} core fsa zbs
 
 ifeq (${WITH_TOPLING_ROCKS},1)
-ifneq (,$(wildcard sideplugin/topling-rocks))
+ifneq (,$(wildcard sideplugin/topling-rocks/src/table/top_patent_algo.cc))
 sideplugin/topling-rocks/${TOPLING_ROCKS_GIT_VER_SRC}: \
+  sideplugin/topling-rocks/Makefile \
   $(shell find sideplugin/topling-rocks/{src,tools} -name '*.cc' -o -name '*.h')
 	+make -C sideplugin/topling-rocks ${TOPLING_ROCKS_GIT_VER_SRC}
+sideplugin/topling-zip_table_reader/top_zip_table_builder.cc: \
+ sideplugin/topling-rocks/src/table/top_zip_table_builder.cc \
+ sideplugin/topling-rocks/${TOPLING_ROCKS_GIT_VER_SRC}
+	@rm -f sideplugin/topling-rocks/${TOPLING_ROCKS_GIT_VER_SRC}
+	+make -C sideplugin/topling-rocks ${TOPLING_ROCKS_GIT_VER_SRC}
+else
+${OBJ_DIR}/sideplugin/topling-zip_table_reader/top_zip_table_builder.o:
+	@mkdir -p $(dir $@)
+	@cd $(dir $@) && \
+	 wget https://topling-tools.oss-cn-qingdao.aliyuncs.com/${TRIAL_urldir}/top_zip_table_builder.o || \
+	 echo 'Download top_zip_table_builder fail, add WITH_TOPLING_ROCKS=0 to make command and try again'
 endif
 endif
 
-ifneq (,$(wildcard sideplugin/cspp-memtable))
+ifneq (,$(wildcard sideplugin/cspp-memtable/cspp_memtable.cc))
 sideplugin/cspp-memtable/${CSPP_MEMTABLE_GIT_VER_SRC}: \
   sideplugin/cspp-memtable/cspp_memtable.cc \
   sideplugin/cspp-memtable/Makefile
 	+make -C sideplugin/cspp-memtable ${CSPP_MEMTABLE_GIT_VER_SRC}
+sideplugin/topling-zip_table_reader/cspp_memtable.cc: \
+  sideplugin/cspp-memtable/cspp_memtable.cc \
+  sideplugin/cspp-memtable/${CSPP_MEMTABLE_GIT_VER_SRC}
+	@rm -f sideplugin/cspp-memtable/${CSPP_MEMTABLE_GIT_VER_SRC}
+	+make -C sideplugin/cspp-memtable ${CSPP_MEMTABLE_GIT_VER_SRC}
+else
+${OBJ_DIR}/sideplugin/topling-zip_table_reader/cspp_memtable.o:
+	@mkdir -p $(dir $@)
+	@cd $(dir $@) && \
+	 wget https://topling-tools.oss-cn-qingdao.aliyuncs.com/${TRIAL_urldir}/cspp_memtable.o || \
+	 echo 'Download cspp_memtable fail, add WITH_CSPP_MEMTABLE=0 to make command and try again'
 endif
 ifneq (,$(wildcard sideplugin/cspp-wbwi))
 sideplugin/cspp-wbwi/${CSPP_WBWI_GIT_VER_SRC}: \
diff --git a/README-zh_cn.md b/README-zh_cn.md
index 9be6c5e326..179d92b764 100644
--- a/README-zh_cn.md
+++ b/README-zh_cn.md
@@ -4,7 +4,7 @@ ToplingDB 由[北京拓扑岭科技有限公司](https://topling.cn)开发与维
 ## 快速开始
 ToplingDB 需要 C++17，推荐 gcc 8.3 以上，或者 clang 也行。
 
-ToplingDB 比 RocksDB 快得多，您可以自己快速验证：
+ToplingDB 比 RocksDB 快得多，您可以自己快速验证，[下载 ToplingDB 企业版](https://topling-tools.oss-cn-qingdao.aliyuncs.com/toplingdb-8.10-trail90.tgz)，或者自己编译：
 ### Compile & run db_bench
 ```bash
 sudo yum -y install git libaio-devel gcc-c++ gflags-devel zlib-devel bzip2-devel libcurl-devel liburing-devel snappy-devel jemalloc-devel
@@ -15,7 +15,10 @@ make -j`nproc` db_bench DEBUG_LEVEL=0
 sudo make install PREFIX=/some/path # default is /usr/local
 ```
 
-以上编译命令执行后，运行 [db_bench.sh](db_bench.sh)(需要[端口 2011](https://github.com/topling/rockside/blob/master/sample-conf/db_bench_enterprise.yaml#L4 "内嵌的 http web 服务使用端口 2011"))，然后使用 ToplingDB：[原生 C++](https://github.com/topling/rockside/wiki/101 "典型场景是从 rocksdb 迁移过来)")，也支持 [Java](https://github.com/topling/rockside/wiki/SidePlugin-Java-Binding "内置在本 github 仓库中") 和 [Rust](https://github.com/topling/rust-toplingdb "另外的专门的 github 仓库")。
+下载解压或者自行编译后，运行 [db_bench.sh](db_bench.sh)(需要[端口 2011](https://github.com/topling/rockside/blob/master/sample-conf/db_bench_enterprise.yaml#L4 "内嵌的 http web 服务使用端口 2011"))，然后使用 ToplingDB：[原生 C++](https://github.com/topling/rockside/wiki/101 "典型场景是从 rocksdb 迁移过来)")，也支持 [Java](https://github.com/topling/rockside/wiki/SidePlugin-Java-Binding "内置在本 github 仓库中") 和 [Rust](https://github.com/topling/rust-toplingdb "另外的专门的 github 仓库")。
+
+> 自己编译开源版时会自动下载预编译的试用版(90天) ToplingZipTable，如果下载失败，可以给 `make` 传递变量 `WITH_TOPLING_ROCKS=0` 禁用它(或[联系我们](mailto:contact@topling.cn))。
+> CSPP-MemTable 也是以这种方式分发的。
 
 ## 简单介绍
 ToplingDB 的子模块 **[rockside](https://github.com/topling/rockside)** 是 ToplingDB 的入口，详情参考 **[SidePlugin wiki](https://github.com/topling/rockside/wiki)**。
@@ -62,7 +65,7 @@ toplingdb
 [ToplingDB](https://github.com/topling/toplingdb) | public | 顶级仓库，分叉自 [RocksDB](https://github.com/facebook/rocksdb)，增加了我们的改进与修复
 [rockside](https://github.com/topling/rockside) | public | ToplingDB 子模块，包含：<ul><li>SidePlugin 框架和内置插件</li><li>内嵌的 Http 服务和 Prometheus 指标</li></ul>
 [cspp-wbwi<br>(**W**rite**B**atch**W**ith**I**ndex)](https://github.com/topling/cspp-wbwi) | public | 使用 Topling CSPP Trie 实现的 **CSPP_WBWI** 相比 rocksdb SkipList WBWI 最多有 20 倍以上的性能提升
-[cspp-memtable](https://github.com/topling/cspp-memtable) | public | (**CSPP** is **C**rash **S**afe **P**arallel **P**atricia trie) MemTab, 相比 SkipList：内存用量更低，单线程性能提升 7 倍，多线程线性提升，可[直接转化为 SST](https://github.com/topling/cspp-memtable#%E4%BA%8Cmemtable-%E7%9B%B4%E6%8E%A5%E8%BD%AC%E5%8C%96%E6%88%90-sst)
+[cspp-memtable](https://github.com/topling/rockside/wiki/CSPP-MemTable) | **private** | (**CSPP** is **C**rash **S**afe **P**arallel **P**atricia trie) MemTab, 相比 SkipList：内存用量更低，单线程性能提升 7 倍，多线程线性提升，可[直接转化为 SST](https://github.com/topling/cspp-memtable#%E4%BA%8Cmemtable-%E7%9B%B4%E6%8E%A5%E8%BD%AC%E5%8C%96%E6%88%90-sst)
 [topling-sst](https://github.com/topling/topling-sst) | public | 1. [SingleFastTable](https://github.com/topling/rockside/wiki/SingleFastTable)(主要用于 L0 和 L1)<br/> 2. VecAutoSortTable(主要用于 MyTopling bulk_load).<br/> 3. 已弃用：[ToplingFastTable](https://github.com/topling/rockside/wiki/ToplingFastTable), CSPPAutoSortTable
 [topling-dcompact](https://github.com/topling/topling-dcompact) | public | 分布式 Compact 与通用的 dcompact_worker 程序, 将 Compact 转移到弹性计算集群。<br/>相比 RocksDB 自身的 Remote Compaction，ToplingDB 的分布式 Compact 功能完备，使用便捷，对上层应用非常友好
 [topling-rocks](https://github.com/topling/topling-rocks) | **private** | 创建 [Topling**Zip**Table](https://github.com/topling/rockside/wiki/ToplingZipTable)，基于 Topling 可检索内存压缩算法的 SST，压缩率更高，且内存占用更低，一般用于 L2 及更深层 SST
@@ -84,12 +87,6 @@ toplingdb
 ```
 make -j`nproc` EXTRA_CXXFLAGS='-DROCKSDB_DYNAMIC_CREATE_CF' rocksdbjava
 ```
-## License
-为了兼容开源协议，下列原先禁止字节跳动使用本软件的条款从 2023-04-24 起已被删除，也就是说，字节跳动使用 ToplingDB 的行为不再是非法的，也不是无耻的。
-
-~~我们禁止字节跳动使用本软件，其它条款与上游 RocksDB 完全相同，~~ 详情参考 [LICENSE.Apache](LICENSE.Apache), [COPYING](COPYING), [LICENSE.leveldb](LICENSE.leveldb).
-
-相应 LICENSE 文件中禁止字节跳动使用本软件的条款也已经删除：[LICENSE.Apache](LICENSE.Apache), [COPYING](COPYING), [LICENSE.leveldb](LICENSE.leveldb).
 
 <hr/>
 以下是上游 RocksDB 的原版 README
diff --git a/README.md b/README.md
index f1220135e1..a2c90295ee 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ ToplingDB is developed and maintained by [Topling Inc](https://topling.cn). See
 ## Quick Start
 ToplingDB requires C++17, gcc 8.3 or newer is recommended, clang also works.
 
-ToplingDB is forked form [RocksDB](https://github.com/facebook/rocksdb), much faster than RocksDB, try it by yourself:
+ToplingDB is forked form [RocksDB](https://github.com/facebook/rocksdb), much faster than RocksDB, you can [download ToplingDB Enterprise](https://topling-tools.oss-cn-qingdao.aliyuncs.com/toplingdb-8.10-trail90.tgz) or compile it by yourself:
 ### Compile & run db_bench
 ```bash
 sudo yum -y install git libaio-devel gcc-c++ gflags-devel zlib-devel bzip2-devel libcurl-devel liburing-devel snappy-devel jemalloc-devel
@@ -16,7 +16,10 @@ make -j`nproc` db_bench DEBUG_LEVEL=0
 sudo make install PREFIX=/some/path # default is /usr/local
 ```
 
-After compile, you can run bundled [db_bench.sh](db_bench.sh)(need [port 2011](https://github.com/topling/rockside/blob/master/sample-conf/db_bench_enterprise.yaml#L4 "use port 2011 for embeded http server")), then use ToplingDB [in C++](https://github.com/topling/sideplugin-wiki-en/wiki/101 "maybe migrate from rocksdb"), or in [Java](https://github.com/topling/sideplugin-wiki-en/wiki/SidePlugin-Java-Binding "Bundled in this repo"), [Rust](https://github.com/topling/rust-toplingdb "A seperated repo").
+After download+uncompress or compile, you can run bundled [db_bench.sh](db_bench.sh)(need [port 2011](https://github.com/topling/rockside/blob/master/sample-conf/db_bench_enterprise.yaml#L4 "use port 2011 for embeded http server")), then use ToplingDB [in C++](https://github.com/topling/sideplugin-wiki-en/wiki/101 "maybe migrate from rocksdb"), or in [Java](https://github.com/topling/sideplugin-wiki-en/wiki/SidePlugin-Java-Binding "Bundled in this repo"), [Rust](https://github.com/topling/rust-toplingdb "A seperated repo").
+
+> During compiling, precompiled ToplingZipTable(90 days trial) will be auto downloaded, if download failed, you can pass `WITH_TOPLING_ROCKS=0` to `make` to disalbe it(or [contact us](mailto:contact@topling.cn)).
+> CSPPMemTable is also distributed this way.
 
 ## Introduction
 ToplingDB's submodule **[rockside](https://github.com/topling/rockside)** is the entry point of ToplingDB, see **[SidePlugin wiki](https://github.com/topling/sideplugin-wiki-en/wiki)**.
@@ -66,7 +69,7 @@ toplingdb
 [ToplingDB](https://github.com/topling/toplingdb) | public | Top repository, forked from [RocksDB](https://github.com/facebook/rocksdb) with our fixes, refactories and enhancements
 [rockside](https://github.com/topling/rockside) | public | This is a submodule, contains:<ul><li>SidePlugin framework and Builtin SidePlugin**s**</li><li>Embedded Http Server and Prometheus metrics</li></ul>
 [cspp-wbwi<br>(**W**rite**B**atch**W**ith**I**ndex)](https://github.com/topling/cspp-wbwi) | public | With CSPP and carefully coding, **CSPP_WBWI** is 20x faster than rocksdb SkipList based WBWI
-[cspp-memtable](https://github.com/topling/cspp-memtable/blob/memtable_as_log_index/README_EN.md) | public | (**CSPP** is **C**rash **S**afe **P**arallel **P**atricia trie) MemTab, which outperforms SkipList on all aspects: 3x lower memory usage, 7x single thread performance, perfect multi-thread scaling)
+[cspp-memtable](https://github.com/topling/sideplugin-wiki-en/wiki/CSPP-MemTable) | **private** | (**CSPP** is **C**rash **S**afe **P**arallel **P**atricia trie) MemTab, which outperforms SkipList on all aspects: 3x lower memory usage, 7x single thread performance, perfect multi-thread scaling
 [topling-sst](https://github.com/topling/topling-sst) | public | 1. [SingleFastTable](https://github.com/topling/sideplugin-wiki-en/wiki/SingleFastTable)(designed for L0 and L1)<br/> 2. VecAutoSortTable(designed for MyTopling bulk_load).<br/> 3. Deprecated [ToplingFastTable](https://github.com/topling/sideplugin-wiki-en/wiki/ToplingFastTable), CSPPAutoSortTable
 [topling-dcompact](https://github.com/topling/topling-dcompact) | public | Distributed Compaction with general dcompact_worker application, offload compactions to elastic computing clusters, much more powerful than RocksDB's Remote Compaction
 [topling-rocks](https://github.com/topling/topling-rocks) | **private** | For build [Topling**Zip**Table](https://github.com/topling/sideplugin-wiki-en/wiki/ToplingZipTable), an SST implementation optimized for RAM and SSD space, aimed for L2+ level compaction, which uses topling dedicated searchable in-memory data compression algorithms
@@ -88,16 +91,6 @@ To enable these features, add `-D${MACRO_NAME}` to var `EXTRA_CXXFLAGS`, such as
 ```
 make -j`nproc` EXTRA_CXXFLAGS='-DROCKSDB_DYNAMIC_CREATE_CF' rocksdbjava
 ```
-## License
-To conform open source license, the following term of disallowing bytedance is deleted since 2023-04-24,
-that is say: bytedance using ToplingDB is no longer illeagal and is not a shame.
-
-~~We disallow bytedance using this software, other terms are identidal with
-upstream rocksdb license,~~ see [LICENSE.Apache](LICENSE.Apache), [COPYING](COPYING) and
-[LICENSE.leveldb](LICENSE.leveldb).
-
-The terms of disallowing bytedance are also deleted in [LICENSE.Apache](LICENSE.Apache), [COPYING](COPYING) and
-[LICENSE.leveldb](LICENSE.leveldb).
 
 <hr/>
 <hr/>
diff --git a/btest-trial.sh b/btest-trial.sh
new file mode 100644
index 0000000000..5d6f75d236
--- /dev/null
+++ b/btest-trial.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/bash
+
+if [ -e sideplugin/topling-rocks-bak ]; then
+    echo sideplugin/topling-rocks-bak exists >&2
+    exit 1
+fi
+mv sideplugin/{topling-rocks,topling-rocks-bak}
+mv sideplugin/cspp-memtable{,-bak}
+mkdir sideplugin/cspp-memtable # create empty dir
+make WITH_TOPLING_ROCKS=1 $@
+mv sideplugin/{topling-rocks-bak,topling-rocks}
+mv -fT sideplugin/cspp-memtable{-bak,}
diff --git a/build-min-dep-jni.sh b/build-min-dep-jni.sh
new file mode 100644
index 0000000000..d94fad8d92
--- /dev/null
+++ b/build-min-dep-jni.sh
@@ -0,0 +1,63 @@
+#!/usr/bin/bash
+
+ROCKSDB_VERSION=`build_tools/version.sh full`
+
+if [ -z "${TOPLING_VERSION}" ]; then
+    GITHUB_REF=`git describe --tags --exact-match || git branch --show-current`
+    # GITHUB_REF seems like: topling-8.10.2-frocksdb-1.0, part <frocksdb> will be ignored
+    TOPLING_VERSION=`echo ${GITHUB_REF} | sed -n 's:^topling-'${ROCKSDB_VERSION}'[-_a-z]*\([.0-9]\):\1:p'`
+    if [ -z "${TOPLING_VERSION}" ]; then
+        echo TOPLING_VERSION is not set and can not parse from HEAD ref >&2
+        exit 1
+    fi
+fi
+#ROCKSDB_JAVA_VERSION=${ROCKSDB_VERSION}-topling-${TOPLING_VERSION}-trial${TOPLING_ZIP_TABLE_TRIAL_DAYS}
+ROCKSDB_JAVA_VERSION=${ROCKSDB_VERSION}-topling-${TOPLING_VERSION}
+
+export USE_LTO=1
+export UPDATE_REPO=0
+export DEBUG_LEVEL=0
+export DISABLE_JEMALLOC=1
+export ROCKSDB_DISABLE_GFLAGS=1
+export TOPLING_USE_DYNAMIC_TLS=1
+export TOPLING_ZIP_TABLE_TRIAL_DAYS=90
+MAJOR_DOT_MINOR=`build_tools/version.sh major`.`build_tools/version.sh minor`
+
+rm -rf java/include
+rm -rf snappy* lz4* bzip2*
+rm -f libsnappy.a liblz4.a libbz2.a
+make -j60 libsnappy.a liblz4.a libbz2.a
+make rocksdbjava install-dcompact -j`nproc` BUILD_PREFIX=min-dep-jni/ \
+    PREFIX=min-dep-jni STRIP_DEBUG_INFO=1 ROCKSDB_JAR_WITH_DYNAMIC_LIBS=1
+
+patchelf --replace-needed librocksdb.so.${MAJOR_DOT_MINOR} librocksdbjni-linux64.so min-dep-jni/bin/dcompact_worker.exe
+
+cd java/target
+db_artifactId=`sed -n 's/.*<artifactId>\(f\?rocksdbjni\)<\/artifactId>.*/\1/p' ../pom.xml.template`
+TARGET_JAR=${db_artifactId}-${ROCKSDB_JAVA_VERSION}.jar
+mv rocksdbjni-${ROCKSDB_VERSION}-linux64.jar ${TARGET_JAR}
+rm *.sha1
+( # in sub shell
+    cd ../../min-dep-jni/bin
+    jar -uf ../../java/target/${TARGET_JAR} dcompact_worker.exe
+)
+shasum -a 1 ${TARGET_JAR} > ${TARGET_JAR}.sha1
+md5sum      ${TARGET_JAR} > ${TARGET_JAR}.md5
+
+source /etc/os-release
+if [ "${ID}" = "centos" ]; then
+    ospart=/${ID}${VERSION_ID}
+fi
+#ospart # e.g. "/centos7"
+dir=toplingdb${ospart}/cn/topling/${db_artifactId}/${ROCKSDB_JAVA_VERSION}
+for file in ${TARGET_JAR}{,.sha1,.md5} ; do
+  ossutil cp --region=cn-qingdao -f $file oss://topling-tools/${dir}/
+done
+set +x
+echo ===========================================
+echo ======== Download URL
+echo ===========================================
+echo https://topling-tools.oss-cn-qingdao.aliyuncs.com/${dir}/${TARGET_JAR}
+echo https://topling-tools.oss-cn-qingdao.aliyuncs.com/${dir}/${TARGET_JAR}.sha1
+echo https://topling-tools.oss-cn-qingdao.aliyuncs.com/${dir}/${TARGET_JAR}.md5
+echo ===========================================
diff --git a/build-min-dep-release.sh b/build-min-dep-release.sh
new file mode 100644
index 0000000000..8bb12c2501
--- /dev/null
+++ b/build-min-dep-release.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/bash
+
+export USE_LTO=1
+export ROCKSDB_DISABLE_GFLAGS=1
+export TOPLING_ZIP_TABLE_TRIAL_DAYS=90
+make UPDATE_REPO=0 DEBUG_LEVEL=0 DISABLE_JEMALLOC=1 TOPLING_USE_DYNAMIC_TLS=1 -j60 libsnappy.a liblz4.a libbz2.a
+make rocksdbjava install-dcompact -j`nproc`
+    DEBUG_LEVEL=0 UPDATE_REPO=0 PREFIX=install-here \
+    DISABLE_JEMALLOC=1 TOPLING_USE_DYNAMIC_TLS=1 \
+    STRIP_DEBUG_INFO=1 ROCKSDB_JAR_WITH_DYNAMIC_LIBS=1
+
diff --git a/build-trial.sh b/build-trial.sh
new file mode 100644
index 0000000000..cbd27cc466
--- /dev/null
+++ b/build-trial.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/bash
+
+export UPDATE_REPO=0
+#export ROCKSDB_DISABLE_GFLAGS=1
+export TOPLING_ZIP_TABLE_TRIAL_DAYS=90
+MAJOR_DOT_MINOR=`build_tools/version.sh major`.`build_tools/version.sh minor`
+
+make -j60 libsnappy.a liblz4.a libbz2.a BUILD_PREFIX=bconf-0/
+GetDebugLevel=(2 0)
+for ((i=0;i<16;i++)); do
+    export DEBUG_LEVEL=${GetDebugLevel[$((i/1%2))]}
+    export USE_LTO=$((i/2%2))
+    export DISABLE_JEMALLOC=$((i/4%2))
+    export TOPLING_USE_DYNAMIC_TLS=$((i/8%2))
+    make -j`nproc` upload-trial BUILD_PREFIX=bconf-${i}/
+done
+# The last bconf-15 is release build which:
+# DEBUG_LEVEL=0,USE_LTO=1,DISABLE_JEMALLOC=1,TOPLING_USE_DYNAMIC_TLS=1
+export BUILD_PREFIX=bconf-15/
+rm -rf toplingdb-${MAJOR_DOT_MINOR}
+rm -rf librocksdb* db_bench
+rm -rf sideplugin/topling-dcompact/tools/dcompact/build
+make install-dcompact install-dev db_bench -j`nproc` \
+    PREFIX=toplingdb-${MAJOR_DOT_MINOR} STRIP_DEBUG_INFO=1
+
+install -C -m 755 db_bench    toplingdb-${MAJOR_DOT_MINOR}/bin
+install -C -m 755 db_bench.sh toplingdb-${MAJOR_DOT_MINOR}
+strip toplingdb-${MAJOR_DOT_MINOR}/bin/db_bench
+sed -e 's:sideplugin/rockside/src/topling/web:site:' \
+    -e 's:sideplugin/rockside/sample-conf:toplingdb-conf:' \
+    -e 's:\./db_bench:bin/db_bench:' \
+    -e '/ulimit/iexport LD_LIBRARY_PATH=lib:$LD_LIBRARY_PATH' \
+    -i toplingdb-${MAJOR_DOT_MINOR}/db_bench.sh
+source /etc/os-release
+if [ "${ID}" = "centos" ]; then
+    ospart=-${ID}${VERSION_ID} # e.g. "-centos7"
+else
+    ospart="" # keep empty
+fi
+sdk=toplingdb-${MAJOR_DOT_MINOR}-trail${TOPLING_ZIP_TABLE_TRIAL_DAYS}${ospart}.tgz
+tar czf ${sdk} toplingdb-${MAJOR_DOT_MINOR}
+ossutil cp --region=cn-qingdao -f ${sdk} oss://topling-tools/
diff --git a/compile.sh b/compile.sh
new file mode 100644
index 0000000000..b50a735c9f
--- /dev/null
+++ b/compile.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+
+export SANDCASTLE=1
+export BUILD_PREFIX=../build-toplingdb/
+export PATH=/usr/local/bin:$PATH
+export CXX=clang++
+export CC=clang
+
+ROCKSDB_VERSION=`build_tools/version.sh full`
+TOPLING_CORE_DIR=sideplugin/topling-zip
+COMPILER=`bash ${TOPLING_CORE_DIR}/get-compiler-name.sh`
+WITH_BMI2=`bash ${TOPLING_CORE_DIR}/cpu_has_bmi2.sh`
+UNAME_MachineSystem=`uname -m -s | sed 's:[ /]:-:g'`
+BUILD_NAME=${UNAME_MachineSystem}-${COMPILER}-bmi2-${WITH_BMI2}
+BUILD_ROOT=build/${BUILD_NAME}
+
+dir=${BUILD_PREFIX}build/${BUILD_NAME}/dbg/v${ROCKSDB_VERSION}
+dir_ut=${BUILD_PREFIX}build-ut/${BUILD_NAME}/dbg/v${ROCKSDB_VERSION}
+DEBUG_LEVEL=2
+function map() {
+    if [[ $1 == *test*.o ]]; then
+        echo $dir_ut/$1
+    elif [[ $1 == *.o ]]; then
+        echo $dir/$1
+    else
+        echo $1
+    fi
+}
+targets=(`for i in $@;do map $i;done`)
+
+make PREFIX=/opt UPDATE_REPO=0 -j`nproc` ${targets[@]}
diff --git a/db/blob/db_blob_basic_test.cc b/db/blob/db_blob_basic_test.cc
index 1c0caba93d..617b7939fc 100644
--- a/db/blob/db_blob_basic_test.cc
+++ b/db/blob/db_blob_basic_test.cc
@@ -942,9 +942,11 @@ TEST_F(DBBlobBasicTest, MultiGetBlob_CorruptIndex) {
       "Version::MultiGet::TamperWithBlobIndex", [&key](void* arg) {
         KeyContext* const key_context = static_cast<KeyContext*>(arg);
         assert(key_context);
+      #if defined(TOPLINGDB_WITH_TIMESTAMP)
         assert(key_context->key);
+      #endif
 
-        if (*(key_context->key) == key) {
+        if (key_context->ukey_without_ts == key) {
           Slice* const blob_index = key_context->value;
           assert(blob_index);
           assert(!blob_index->empty());
diff --git a/db/c.cc b/db/c.cc
index 407316f7ca..d62bfbfd71 100644
--- a/db/c.cc
+++ b/db/c.cc
@@ -50,7 +50,9 @@
 #include "rocksdb/write_buffer_manager.h"
 #include "util/stderr_logger.h"
 #include "utilities/merge_operators.h"
-#include "topling/side_plugin_repo.h"
+#include "topling/side_plugin_factory.h"
+#include "db/compaction/compaction_executor.h"
+#include "logging/logging.h"
 
 using ROCKSDB_NAMESPACE::BackupEngine;
 using ROCKSDB_NAMESPACE::BackupEngineOptions;
@@ -4544,6 +4546,10 @@ void rocksdb_readoptions_finish_pin(rocksdb_readoptions_t* opt) {
   return opt->rep.FinishPin();
 }
 
+unsigned char rocksdb_readoptions_is_in_pinning_section(rocksdb_readoptions_t* opt) {
+  return opt->rep.internal_is_in_pinning_section ? 1 : 0;
+}
+
 void rocksdb_readoptions_set_async_queue_depth(rocksdb_readoptions_t* opt, size_t v) {
   v = std::min(v, (size_t)1024);
   opt->rep.async_queue_depth = v;
@@ -6754,6 +6760,16 @@ const char* rocksdb_pinnableslice_value(const rocksdb_pinnableslice_t* v,
   return v->rep.data();
 }
 
+struct rocksdb_stdstr_t {
+  std::string rep;
+};
+
+rocksdb_stdstr_t* rocksdb_stdstr_create(const char* str, size_t len) {
+  return new rocksdb_stdstr_t{std::string(str, len)};
+}
+
+void rocksdb_stdstr_destroy(rocksdb_stdstr_t* v) { delete v; }
+
 // container to keep databases and caches in order to use
 // ROCKSDB_NAMESPACE::MemoryUtil
 struct rocksdb_memory_consumers_t {
@@ -7005,6 +7021,12 @@ void side_plugin_repo_import_auto_file(side_plugin_repo_t* r,
   SaveError(errptr, s);
 }
 
+void side_plugin_repo_import(side_plugin_repo_t* r,
+                              const char* json_str, char** errptr) {
+  auto s = r->repo.Import(std::string(json_str));
+  SaveError(errptr, s);
+}
+
 rocksdb_t* side_plugin_repo_open(side_plugin_repo_t* r,
     rocksdb_column_family_handle_t*** p_cfhs, size_t* num_cf, char** errptr) {
   if (p_cfhs) { // Open with column families
@@ -7070,13 +7092,280 @@ void side_plugin_repo_put_cf_options(side_plugin_repo_t* r, const char* name,
   r->repo.Put(name, std::make_shared<ColumnFamilyOptions>(opt->rep));
 }
 
+bool side_plugin_db_options_update_from(rocksdb_options_t* opt, const side_plugin_repo_t* r, const char* name) {
+  return r->repo.DBOptionsUpdateFrom(&opt->rep, name);
+}
+
+bool side_plugin_cf_options_update_from(rocksdb_options_t* opt, const side_plugin_repo_t* r, const char* name) {
+  return r->repo.CFOptionsUpdateFrom(&opt->rep, name);
+}
+
 void side_plugin_repo_close_all(side_plugin_repo_t* r) {
   r->repo.CloseAllDB(false); // also close http
   delete r;
 }
 
+void side_plugin_repo_forget_db(side_plugin_repo_t* r, rocksdb_t* db) {
+  r->repo.CloseOneDB(db->rep, false);
+}
+
 const char* rocksdb_get_name(rocksdb_t* p) {
   return p->rep->GetName().c_str();
 }
 
+} // end extern "C"
+
+#define DoPrintLog(...) \
+    info_log ? ROCKS_LOG_INFO(info_log, __VA_ARGS__) \
+             : (void)fprintf(stderr, __VA_ARGS__)
+#define PrintLog(level, fmt, ...) \
+  do { if (SidePluginRepo::DebugLevel() >= level) \
+    DoPrintLog("%s: " fmt "\n", \
+            TERARK_PP_SmartForPrintf(rocksdb::StrDateTimeNow(), ## __VA_ARGS__)); \
+  } while (0)
+#define TRAC(...) PrintLog(4, "TRAC: " __VA_ARGS__)
+#define DEBG(...) PrintLog(3, "DEBG: " __VA_ARGS__)
+#define INFO(...) PrintLog(2, "INFO: " __VA_ARGS__)
+#define WARN(...) PrintLog(1, "WARN: " __VA_ARGS__)
+
+namespace ROCKSDB_NAMESPACE {
+
+template<class FFI_BridgeObject>
+static void* get_ffi_obj(const FFI_BridgeObject* bridge) {
+  // existing rocksdb bridge class consitently name ffi_obj as state_.
+  // bridge itself is always const.
+  return bridge->state_;
+}
+
+using terark::llong;
+template<class Object, class FFI_BridgeObject>
+struct FFI_SerDe : public DcompactSerDeFunc<Object> {
+  virtual void SerializeRequest(FILE* fp, const Object& obj) const final {
+    ROCKSDB_VERIFY(!IsCompactionWorker()); // phase 1, DB Side
+    auto bridge = dynamic_cast<const FFI_BridgeObject*>(&obj);
+    ROCKSDB_VERIFY(nullptr != bridge);
+    DEBG("job-%05d cf-%d %s::SerializeRequest: job raw = %.3f GB, zip = %.3f GB, smallest_seqno = %lld",
+          job_id, m_cp->cf_id, m_name, rawzip[0]/1e9, rawzip[1]/1e9, (llong)m_cp->smallest_seqno);
+    ffi_vtab.serialize_request(fp, get_ffi_obj(bridge));
+  }
+  virtual void DeSerializeRequest(FILE* fp, Object* obj) const final {
+    ROCKSDB_VERIFY(IsCompactionWorker()); // phase 2, compact worker side
+    DEBG("job-%05d cf-%d %s::DeSerializeRequest: job raw = %.3f GB, zip = %.3f GB, smallest_seqno = %lld",
+          job_id, m_cp->cf_id, m_name, rawzip[0]/1e9, rawzip[1]/1e9, (llong)m_cp->smallest_seqno);
+    auto bridge = dynamic_cast<const FFI_BridgeObject*>(obj);
+    ROCKSDB_VERIFY(nullptr != bridge);
+    ffi_vtab.deserialize_request(fp, get_ffi_obj(bridge));
+  }
+  virtual void SerializeResponse(FILE* fp, const Object& obj) const final {
+    ROCKSDB_VERIFY(IsCompactionWorker()); // phase 3, compact worker side
+    auto bridge = dynamic_cast<const FFI_BridgeObject*>(&obj);
+    ROCKSDB_VERIFY(nullptr != bridge);
+    ffi_vtab.serialize_response(fp, get_ffi_obj(bridge));
+  }
+  virtual void DeSerializeResponse(FILE* fp, Object* obj) const final {
+    ROCKSDB_VERIFY(!IsCompactionWorker()); // phase 4, DB side
+    auto bridge = dynamic_cast<const FFI_BridgeObject*>(obj);
+    ROCKSDB_VERIFY(nullptr != bridge);
+    ffi_vtab.deserialize_response(fp, get_ffi_obj(bridge));
+  }
+  FFI_SerDe(const json& js, const SidePluginRepo& repo,
+            const std::string& name, const side_plugin_ex_vtab_t& vtab)
+  : m_name(name)
+  {
+    ffi_vtab = vtab;
+    auto  cp = m_cp = JS_CompactionParamsDecodePtr(js);
+    info_log = cp->info_log;
+    const auto& smallest_user_key = Slice(cp->smallest_user_key).ToString(true/*hex*/);
+    const auto& largest_user_key = Slice(cp->largest_user_key).ToString(true/*hex*/);
+    job_id = cp->job_id;
+    cp->InputBytes(rawzip);
+    TRAC("job-%05d cf-%d %s::FFI_SerDe: smallest_user_key = %s, largest_user_key = %s, job raw = %.3f GB, zip = %.3f GB",
+      cp->job_id, cp->cf_id, name, smallest_user_key.c_str(), largest_user_key.c_str(), rawzip[0]/1e9, rawzip[1]/1e9);
+  }
+  std::string m_name;
+  side_plugin_ex_vtab_t ffi_vtab;
+  const CompactionParams* m_cp;
+  rocksdb::Logger* info_log;
+  int job_id;
+  size_t rawzip[2];
+};
+
+template<class Object, class FFI_BridgeObject>
+struct FFI_WebManip : public PluginManipFunc<Object> {
+  virtual void Update(Object* obj, const json& query, const json& body,
+                      const SidePluginRepo& repo) const {
+    std::string str_qry = query.dump();
+    std::string str_body = body.dump();
+    auto bridge = dynamic_cast<const FFI_BridgeObject*>(obj);
+    ROCKSDB_VERIFY(nullptr != bridge);
+    auto ffi_repo = (const side_plugin_repo_t*)(&repo);
+    if (m_ffi_vtab.web_update) {
+      m_ffi_vtab.web_update(get_ffi_obj(bridge), str_qry.c_str(), str_body.c_str(), ffi_repo);
+    }
+  }
+  virtual std::string ToString(const Object& obj, const json& query,
+                               const SidePluginRepo& repo) const {
+    std::string str_qry = query.dump();
+    auto bridge = dynamic_cast<const FFI_BridgeObject*>(&obj);
+    ROCKSDB_VERIFY(nullptr != bridge);
+    auto ffi_repo = (const side_plugin_repo_t*)(&repo);
+    rocksdb_stdstr_t* result = m_ffi_vtab.web_view(get_ffi_obj(bridge), str_qry.c_str(), ffi_repo);
+    TERARK_VERIFY(nullptr != result);
+    TERARK_SCOPE_EXIT(rocksdb_stdstr_destroy(result));
+    return std::move(result->rep);
+  }
+  FFI_WebManip(const side_plugin_ex_vtab_t& ffi_vtab) : m_ffi_vtab(ffi_vtab) {}
+  side_plugin_ex_vtab_t m_ffi_vtab;
+};
+
+template<class Object, class FFI_BridgeObject>
+static void side_plugin_register_ex(const char* name, const side_plugin_ex_vtab_t* ex_vtab) {
+  if (ex_vtab->serialize_request) {
+    ROCKSDB_VERIFY(nullptr != ex_vtab->deserialize_request );
+    ROCKSDB_VERIFY(nullptr != ex_vtab->  serialize_response);
+    ROCKSDB_VERIFY(nullptr != ex_vtab->deserialize_response);
+    using NoConstObj = std::remove_const_t<Object>;
+    auto cxx_creator = [name=std::string(name), cp_vtab=*ex_vtab]
+    (const json& js, const SidePluginRepo& repo) -> std::shared_ptr<SerDeFunc<NoConstObj> > {
+      static_assert(offsetof(side_plugin_repo_t, repo) == 0);
+      return std::make_shared<FFI_SerDe<NoConstObj, FFI_BridgeObject> >(js, repo, name, cp_vtab);
+    };
+    SerDeFactory<NoConstObj>::DoReg(name, cxx_creator, __FILE__, __LINE__);
+  }
+  if (ex_vtab->web_view) {
+    auto cxx_creator = [
+      singleton=std::make_shared<FFI_WebManip<Object, FFI_BridgeObject> >(*ex_vtab)
+    ](const json&, const SidePluginRepo&) -> const PluginManipFunc<Object>* {
+      static_assert(offsetof(side_plugin_repo_t, repo) == 0);
+      return singleton.get();
+    };
+    PluginManip<Object>::DoReg(name, cxx_creator, __FILE__, __LINE__);
+  }
+}
+
+} // ROCKSDB_NAMESPACE
+
+using ROCKSDB_NAMESPACE::SidePluginRepo;
+using ROCKSDB_NAMESPACE::PluginFactory;
+using ROCKSDB_NAMESPACE::json;
+using ROCKSDB_NAMESPACE::side_plugin_register_ex;
+using ROCKSDB_NAMESPACE::SerDeFactory;
+using ROCKSDB_NAMESPACE::PluginManip;
+
+template<class Object>
+static void side_plugin_unregister_ex(const char* name) {
+  using NoConstObj = std::remove_const_t<Object>;
+  SerDeFactory<NoConstObj>::UnReg(name);
+  PluginManip<Object>::UnReg(name);
+}
+
+template<class Object, class FFI_BridgeObject>
+static void side_plugin_register_raw_ptr_plugin
+(const char* name, FFI_BridgeObject*(*creator)(const char* strjson, const side_plugin_repo_t*),
+ const side_plugin_ex_vtab_t* ex_vtab)
+{
+  auto cxx_creator = [creator](const json& js, const SidePluginRepo& repo) {
+    std::string strjson = js.dump();
+    static_assert(offsetof(side_plugin_repo_t, repo) == 0);
+    Object* ptr = creator(strjson.c_str(), (const side_plugin_repo_t*)(&repo));
+    return ptr;
+  };
+  PluginFactory<Object*>::DoReg(name, cxx_creator, __FILE__, __LINE__);
+  if (ex_vtab) {
+    side_plugin_register_ex<Object, FFI_BridgeObject>(name, ex_vtab);
+  }
+}
+
+template<class Object, class FFI_BridgeObject>
+static void side_plugin_register_shared_ptr_plugin
+(const char* name, FFI_BridgeObject*(*creator)(const char* strjson, const side_plugin_repo_t*),
+ const side_plugin_ex_vtab_t* ex_vtab)
+{
+  auto cxx_creator = [creator](const json& js, const SidePluginRepo& repo) {
+    std::string strjson = js.dump();
+    static_assert(offsetof(side_plugin_repo_t, repo) == 0);
+    Object* ptr = creator(strjson.c_str(), (const side_plugin_repo_t*)(&repo));
+    return std::shared_ptr<Object>(ptr);
+  };
+  PluginFactory<std::shared_ptr<Object> >::DoReg(name, cxx_creator, __FILE__, __LINE__);
+  if (ex_vtab) {
+    side_plugin_register_ex<Object, FFI_BridgeObject>(name, ex_vtab);
+  }
+}
+
+extern "C" {
+
+void side_plugin_register_comparator
+(const char* name, rocksdb_comparator_creator_t creator, const side_plugin_ex_vtab_t* ex_vtab) {
+  side_plugin_register_raw_ptr_plugin<const Comparator>(name, creator, ex_vtab);
+}
+void side_plugin_unregister_comparator(const char* name) {
+  PluginFactory<const Comparator*>::UnReg(name);
+  side_plugin_unregister_ex<const Comparator>(name);
+}
+void* side_plugin_comparator_get_state(const rocksdb_comparator_t* p) {
+  return p->state_;
+}
+
+void side_plugin_register_compaction_filter_factory
+(const char* name, rocksdb_compactionfilterfactory_creator_t creator, const side_plugin_ex_vtab_t* ex_vtab) {
+  side_plugin_register_shared_ptr_plugin<CompactionFilterFactory>(name, creator, ex_vtab);
+}
+void side_plugin_unregister_compaction_filter_factory(const char* name) {
+  PluginFactory<std::shared_ptr<CompactionFilterFactory> >::UnReg(name);
+  side_plugin_unregister_ex<CompactionFilterFactory>(name);
+}
+void* side_plugin_compactionfilterfactory_get_state(const rocksdb_compactionfilterfactory_t* p) {
+  return p->state_;
+}
+
+void side_plugin_register_merge_operator
+(const char* name, rocksdb_mergeoperator_creator_t creator, const side_plugin_ex_vtab_t* ex_vtab) {
+  side_plugin_register_shared_ptr_plugin<MergeOperator>(name, creator, ex_vtab);
+}
+void side_plugin_unregister_merge_operator(const char* name) {
+  PluginFactory<std::shared_ptr<MergeOperator> >::UnReg(name);
+  side_plugin_unregister_ex<MergeOperator>(name);
+}
+void* side_plugin_mergeoperator_get_state(const rocksdb_mergeoperator_t* p) {
+  return p->state_;
+}
+
+void side_plugin_register_slicetransform
+(const char* name, rocksdb_slicetransform_creator_t creator, const side_plugin_ex_vtab_t* ex_vtab) {
+  side_plugin_register_shared_ptr_plugin<const SliceTransform>(name, creator, ex_vtab);
+}
+void side_plugin_unregister_slicetransform(const char* name) {
+  PluginFactory<std::shared_ptr<const SliceTransform> >::UnReg(name);
+  side_plugin_unregister_ex<const SliceTransform>(name);
+}
+void* side_plugin_slicetransform_get_state(const rocksdb_slicetransform_t* p) {
+  return p->state_;
+}
+
+void side_plugin_register_filterpolicy
+(const char* name, rocksdb_filterpolicy_creator_t creator, const side_plugin_ex_vtab_t* ex_vtab) {
+  side_plugin_register_shared_ptr_plugin<const FilterPolicy>(name, creator, ex_vtab);
+}
+void side_plugin_unregister_filterpolicy(const char* name) {
+  PluginFactory<std::shared_ptr<const FilterPolicy> >::UnReg(name);
+  side_plugin_unregister_ex<const FilterPolicy>(name);
+}
+void* side_plugin_filterpolicy_get_state(const rocksdb_filterpolicy_t* p) {
+  return p->state_;
+}
+
+#if 0 // rocksdb c api does not support custom rate limiter
+void side_plugin_register_ratelimiter
+(const char* name, rocksdb_ratelimiter_creator_t creator, const side_plugin_ex_vtab_t* ex_vtab) {
+  side_plugin_register_shared_ptr_plugin<RateLimiter>(name, creator, ex_vtab);
+}
+void side_plugin_unregister_ratelimiter(const char* name) {
+  PluginFactory<std::shared_ptr<RateLimiter> >::UnReg(name);
+}
+void* side_plugin_ratelimiter_get_state(const rocksdb_ratelimiter_creator_t* p) {
+  return p->state_;
+}
+#endif
+
 }  // end extern "C"
diff --git a/db/compaction/compaction_executor.cc b/db/compaction/compaction_executor.cc
index c4a1888704..534abd5b3a 100644
--- a/db/compaction/compaction_executor.cc
+++ b/db/compaction/compaction_executor.cc
@@ -278,19 +278,6 @@ std::string ReplacePrefix(Slice Old, Slice New, Slice str) {
               int(str.size()), str.data(), int(Old.size()), Old.data());
 }
 
-void ReplaceAll(std::string& str, Slice from, Slice to) {
-  if (from.empty()) return;
-  size_t start_pos = 0;
-  while ((start_pos = str.find(from.data(), start_pos)) != std::string::npos) {
-    str.replace(start_pos, from.size(), to.data(), to.size());
-    start_pos += to.size();
-  }
-}
-std::string ReplaceAll(Slice str, Slice from, Slice to) {
-  std::string tmp(str.data(), str.size());
-  ReplaceAll(tmp, from, to);
-  return tmp;
-}
 std::string MakePath(std::string dir, Slice sub) {
   while (!dir.empty() && '/' == dir.back()) {
     dir.pop_back();
diff --git a/db/compaction/compaction_executor.h b/db/compaction/compaction_executor.h
index 477d369ec0..5fd4cb29a0 100644
--- a/db/compaction/compaction_executor.h
+++ b/db/compaction/compaction_executor.h
@@ -182,8 +182,6 @@ class CompactionExecutorFactory {
 std::string GetDirFromEnv(const char* name, const char* Default = nullptr);
 bool ReplacePrefix(Slice Old, Slice New, Slice str, std::string* res);
 std::string ReplacePrefix(Slice Old, Slice New, Slice str);
-void ReplaceAll(std::string& str, Slice from, Slice to);
-std::string ReplaceAll(Slice str, Slice from, Slice to);
 std::string MakePath(std::string dir, Slice sub);
 std::string& AppendJobID(std::string& path, int job_id);
 std::string CatJobID(const std::string& path, int job_id);
diff --git a/db/db_impl/db_impl.cc b/db/db_impl/db_impl.cc
index 097163c60d..e284001c94 100644
--- a/db/db_impl/db_impl.cc
+++ b/db/db_impl/db_impl.cc
@@ -151,16 +151,20 @@ struct ToplingMGetCtx : protected MergeContext {
 
 #if defined(TOPLINGDB_WITH_TIMESTAMP)
   std::string* timestamp = nullptr;
-#endif
   union {
     LookupKey lkey;
   };
+#endif
+  union {
+    ParsedInternalKey pikey;
+  };
   void InitLookupKey(const Slice& user_key, SequenceNumber seq,
                      const Slice* ts) {
    #if defined(TOPLINGDB_WITH_TIMESTAMP)
     new(&lkey)LookupKey(user_key, seq, ts);
+    new(&pikey)ParsedInternalKey(lkey.internal_key());
    #else
-    new(&lkey)LookupKey(user_key, seq);
+    new(&pikey)ParsedInternalKey(user_key, seq, kValueTypeForSeek);
     (void)ts;
     assert(ts == nullptr);
    #endif
@@ -168,8 +172,10 @@ struct ToplingMGetCtx : protected MergeContext {
   }
   ToplingMGetCtx() {}
   ~ToplingMGetCtx() {
+#if defined(TOPLINGDB_WITH_TIMESTAMP)
     if (this->ext_flags_ & FLAG_lkey_initialized)
       lkey.~LookupKey();
+#endif
   }
   void set_done() { this->ext_flags_ |= FLAG_done; }
   bool is_done() const { return (this->ext_flags_ & FLAG_done) != 0; }
@@ -828,6 +834,8 @@ Status DBImpl::CloseHelper() {
 Status DBImpl::CloseImpl() { return CloseHelper(); }
 
 DBImpl::~DBImpl() {
+  MaybeForgetDB(this);
+
   // TODO: remove this.
   init_logger_creation_s_.PermitUncheckedError();
 
@@ -2442,7 +2450,7 @@ Status DBImpl::GetInst(const ReadOptions& read_options, const Slice& key,
 #if defined(TOPLINGDB_WITH_TIMESTAMP)
   LookupKey lkey(key, snapshot, read_options.timestamp);
 #else
-  LookupKey lkey(key, snapshot);
+  ParsedInternalKey lkey(key, snapshot, kValueTypeForSeek);
 #endif
   PERF_TIMER_STOP(get_snapshot_time);
 
@@ -2511,7 +2519,7 @@ Status DBImpl::GetInst(const ReadOptions& read_options, const Slice& key,
   PinnedIteratorsManager pinned_iters_mgr;
   if (!done) {
     PERF_TIMER_GUARD(get_from_output_files_time);
-    sv->current->Get(
+    sv->current->template Get<PerfStepTimer, typename StopWatch::WatchNano>(
         read_options, lkey, get_impl_options.value, get_impl_options.columns,
         timestamp, &s, &merge_context, &max_covering_tombstone_seq,
         &pinned_iters_mgr,
@@ -2769,7 +2777,7 @@ std::vector<Status> DBImpl::MultiGet(
     LookupKey lkey(keys[keys_read], consistent_seqnum, read_options.timestamp);
 #else
     std::string* timestamp = nullptr;
-    LookupKey lkey(keys[keys_read], consistent_seqnum);
+    ParsedInternalKey lkey(keys[keys_read], consistent_seqnum, kValueTypeForSeek);
 #endif
 
     auto cfh = static_cast_with_check<ColumnFamilyHandleImpl>(
@@ -3241,7 +3249,7 @@ struct CompareKeyContext {
 
     // Both keys are from the same column family
     int cmp = comparator->CompareWithoutTimestamp(
-        *(lhs->key), /*a_has_ts=*/false, *(rhs->key), /*b_has_ts=*/false);
+        lhs->ukey_without_ts, /*a_has_ts=*/false, rhs->ukey_without_ts, /*b_has_ts=*/false);
     if (cmp < 0) {
       return true;
     }
@@ -3253,7 +3261,7 @@ struct CompareKeyContextSameCF {
   const Comparator* comparator;
   inline bool operator()(const KeyContext* lhs, const KeyContext* rhs) {
     int cmp = comparator->CompareWithoutTimestamp(
-        *(lhs->key), /*a_has_ts=*/false, *(rhs->key), /*b_has_ts=*/false);
+        lhs->ukey_without_ts, /*a_has_ts=*/false, rhs->ukey_without_ts, /*b_has_ts=*/false);
     return cmp < 0;
   }
 };
@@ -3498,7 +3506,7 @@ if (UNLIKELY(!g_MultiGetUseFiber)) {
       auto& max_covering_tombstone_seq = ctx_vec[i].max_covering_tombstone_seq;
       MergeContext& merge_context = ctx_vec[i].merge_context();
       Status& s = statuses[i];
-      if (sv->mem->Get(ctx_vec[i].lkey, &values[i], columns,
+      if (sv->mem->Get(ctx_vec[i].pikey, &values[i], columns,
                        timestamp, &s, &merge_context,
                        &max_covering_tombstone_seq, read_options,
                        false, // immutable_memtable
@@ -3506,7 +3514,7 @@ if (UNLIKELY(!g_MultiGetUseFiber)) {
         ctx_vec[i].set_done();
         hits++;
       } else if ((s.ok() || s.IsMergeInProgress()) &&
-                sv->imm->Get(ctx_vec[i].lkey, &values[i], columns,
+                sv->imm->Get(ctx_vec[i].pikey, &values[i], columns,
                              timestamp, &s, &merge_context,
                              &max_covering_tombstone_seq, read_options,
                              callback, is_blob_index)) {
@@ -3527,7 +3535,7 @@ if (UNLIKELY(!g_MultiGetUseFiber)) {
     bool* value_found = nullptr;
     bool get_value = true;
     sv->current->Get(
-        read_options, ctx_vec[i].lkey, &values[i], columns,
+        read_options, ctx_vec[i].pikey, &values[i], columns,
         timestamp, &statuses[i],
         &merge_context, &max_covering_tombstone_seq, &pinned_iters_mgr,
         value_found,
@@ -3537,13 +3545,14 @@ if (UNLIKELY(!g_MultiGetUseFiber)) {
         get_value);
     counting++;
   };
-  if (read_options.async_io) {
+  const bool async_io = read_options.async_io;
+  if (async_io) {
     gt_fiber_pool.update_fiber_count(read_options.async_queue_depth);
   }
   size_t memtab_miss = 0;
   for (size_t i = 0; i < num_keys; i++) {
     if (!ctx_vec[i].is_done()) {
-      if (read_options.async_io) {
+      if (async_io) {
         gt_fiber_pool.push({TERARK_C_CALLBACK(get_in_sst), i});
       } else {
         get_in_sst(i);
@@ -3578,6 +3587,10 @@ if (UNLIKELY(!g_MultiGetUseFiber)) {
   if (!read_options.internal_is_in_pinning_section)
     ReturnAndCleanupSuperVersion(cfd, sv);
 
+#else
+  for (size_t i = 0; i < num_keys; i++) {
+    statuses[i] = Status::NotSupported("macro TOPLINGDB_WITH_FIBER_AIO is 0 but env MultiGetUseFiber is true");
+  }
 #endif // TOPLINGDB_WITH_FIBER_AIO
 } // g_MultiGetUseFiber
 }
@@ -4008,6 +4021,10 @@ void DB_UpdateMaxColumnFamily(DB* db, uint32_t max_cf_id) {
   cfset->UpdateMaxColumnFamily(max_cf_id);
 }
 
+ColumnFamilyHandle* DB_persist_stats_cf_handle(const DB* db) {
+  return static_cast_with_check<const DBImpl>(db)->persist_stats_cf_handle();
+}
+
 Status DBImpl::CreateColumnFamilyImpl(const ColumnFamilyOptions& cf_options,
                                       const std::string& column_family_name,
                                       ColumnFamilyHandle** handle) {
@@ -4017,6 +4034,9 @@ Status DBImpl::CreateColumnFamilyImpl(const ColumnFamilyOptions& cf_options,
   Status s;
   *handle = nullptr;
 
+  MaybeCFOptionsUpdateFrom(const_cast<ColumnFamilyOptions*>(&cf_options),
+                           column_family_name, dbname_);
+  ROCKSDB_SCOPE_EXIT(MaybeRetainCF(this, *handle));
   DBOptions db_options =
       BuildDBOptions(immutable_db_options_, mutable_db_options_);
   s = ColumnFamilyData::ValidateOptions(db_options, cf_options);
@@ -4190,6 +4210,7 @@ Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
   }
 
   if (s.ok()) {
+    MaybeForgetCF(this, column_family);
     // Note that here we erase the associated cf_info of the to-be-dropped
     // cfd before its ref-count goes to zero to avoid having to erase cf_info
     // later inside db_mutex.
@@ -5140,7 +5161,7 @@ ReadOptions::~ReadOptions() {
 
 SuperVersion*
 DBImpl::GetAndRefSuperVersion(ColumnFamilyData* cfd, const ReadOptions* ro) {
-  if (!ro->internal_is_in_pinning_section) {
+  if (UNLIKELY(!ro->internal_is_in_pinning_section)) {
     // do not use zero copy, same as old behavior
     return GetAndRefSuperVersion(cfd);
   }
@@ -5148,7 +5169,7 @@ DBImpl::GetAndRefSuperVersion(ColumnFamilyData* cfd, const ReadOptions* ro) {
   ROCKSDB_ASSERT_EQ(tls->thread_id, ThisThreadID());
   size_t cfid = cfd->GetID();
   SuperVersion*& sv = tls->GetSuperVersionRef(cfid);
-  if (sv) {
+  if (LIKELY(sv != nullptr)) {
     if (LIKELY(sv->version_number == cfd->GetSuperVersionNumberNoAtomic())) {
       ROCKSDB_ASSERT_EQ(sv->cfd, cfd);
       return sv;
@@ -6249,7 +6270,7 @@ Status DBImpl::GetLatestSequenceForKey(
  #if !defined(NDEBUG)
   constexpr size_t ts_sz = 0;
  #endif
-  LookupKey lkey(key, current_seq);
+  ParsedInternalKey lkey(key, current_seq, kValueTypeForSeek);
 #endif
 
   *seq = kMaxSequenceNumber;
diff --git a/db/db_impl/db_impl.h b/db/db_impl/db_impl.h
index 97bc9c3e2e..e26709b39b 100644
--- a/db/db_impl/db_impl.h
+++ b/db/db_impl/db_impl.h
@@ -448,7 +448,7 @@ class DBImpl : public DB {
   virtual Status LockWAL() override;
   virtual Status UnlockWAL() override;
 
-  virtual SequenceNumber GetLatestSequenceNumber() const override;
+  virtual SequenceNumber GetLatestSequenceNumber() const override final;
 
   // IncreaseFullHistoryTsLow(ColumnFamilyHandle*, std::string) will acquire
   // and release db_mutex
@@ -466,7 +466,7 @@ class DBImpl : public DB {
 
   virtual Status GetDbSessionId(std::string& session_id) const override;
 
-  ColumnFamilyHandle* DefaultColumnFamily() const override;
+  ColumnFamilyHandle* DefaultColumnFamily() const override final;
 
   ColumnFamilyHandle* PersistentStatsColumnFamily() const;
 
@@ -677,7 +677,7 @@ class DBImpl : public DB {
                                       bool expose_blob_index = false,
                                       bool allow_refresh = true);
 
-  virtual SequenceNumber GetLastPublishedSequence() const {
+  virtual SequenceNumber GetLastPublishedSequence() const final {
     if (last_seq_same_as_publish_seq_) {
       return versions_->LastSequence();
     } else {
@@ -687,7 +687,7 @@ class DBImpl : public DB {
 
   // REQUIRES: joined the main write queue if two_write_queues is disabled, and
   // the second write queue otherwise.
-  virtual void SetLastPublishedSequence(SequenceNumber seq);
+  virtual void SetLastPublishedSequence(SequenceNumber seq) final;
   // Returns LastSequence in last_seq_same_as_publish_seq_
   // mode and LastAllocatedSequence otherwise. This is useful when visiblility
   // depends also on data written to the WAL but not to the memtable.
@@ -2241,6 +2241,8 @@ class DBImpl : public DB {
   SnapshotImpl* GetSnapshotImpl(SequenceNumber snapshot_seq,
                                 bool is_write_conflict_boundary,
                                 bool lock = true);
+  ColumnFamilyHandle* persist_stats_cf_handle() const { return persist_stats_cf_handle_; }
+
 protected:
 
   // If snapshot_seq != kMaxSequenceNumber, then this function can only be
@@ -2805,6 +2807,15 @@ class GetWithTimestampReadCallback : public ReadCallback {
   }
 };
 
+extern bool MaybeCFOptionsUpdateFrom
+(ColumnFamilyOptions*, const std::string& cfname, const std::string& dbpath);
+extern bool MaybeOptionsUpdateFrom
+(DBOptions*, std::vector<ColumnFamilyDescriptor>*, const std::string& dbpath);
+extern void MaybeRetainDB(DB*, const std::vector<ColumnFamilyHandle*>&);
+extern void MaybeForgetDB(DB*);
+extern void MaybeRetainCF(DB*, ColumnFamilyHandle*);
+extern void MaybeForgetCF(DB*, ColumnFamilyHandle*);
+
 extern Options SanitizeOptions(const std::string& db, const Options& src,
                                bool read_only = false,
                                Status* logger_creation_s = nullptr);
diff --git a/db/db_impl/db_impl_open.cc b/db/db_impl/db_impl_open.cc
index 476ea032fa..8c62470ac0 100644
--- a/db/db_impl/db_impl_open.cc
+++ b/db/db_impl/db_impl_open.cc
@@ -1167,6 +1167,15 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
       logFileDropped();
       continue;
     }
+    bool wal_memtable_format = immutable_db_options_.memtable_as_log_index;
+    if (immutable_db_options_.check_wal_format) {
+      if (IOStatus ios = log::Reader::IsMemTableAsLogIndexFile
+                   (*fs_, fname, &wal_memtable_format); !ios.ok()) {
+        auto info_log = immutable_db_options_.info_log.get();
+        ROCKS_LOG_WARN(info_log, "%s: %s", fname.c_str(), *ios.ToSSO());
+        return Status(ios);
+      }
+    }
 
     std::unique_ptr<SequentialFileReader> file_reader;
     {
@@ -1207,7 +1216,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
     log::Reader reader(immutable_db_options_.info_log, std::move(file_reader),
                        &reporter, true /*checksum*/, wal_number);
     boost::intrusive_ptr<ReadonlyFileMmap> fmap;
-    if (immutable_db_options_.memtable_as_log_index) {
+    if (wal_memtable_format) {
       reader.InitSetMemTableAsLogIndex(*fs_);
       IOStatus ios = ReadonlyFileMmap::New(&fmap, *fs_, wal_number, fname);
       if (!ios.ok() && ios.ToString() != "Invalid argument: Empty File")
@@ -1255,7 +1264,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& wal_numbers,
       if (!status.ok()) {
         return status;
       }
-      if (new_batch && immutable_db_options_.memtable_as_log_index) {
+      if (new_batch && wal_memtable_format) {
         return Status::NotSupported("memtable_as_log_index",
                                     "WriteBatchTimestampSizeDifference");
       }
@@ -1980,6 +1989,12 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
                     const std::vector<ColumnFamilyDescriptor>& column_families,
                     std::vector<ColumnFamilyHandle*>* handles, DB** dbptr,
                     const bool seq_per_batch, const bool batch_per_txn) {
+  MaybeOptionsUpdateFrom(const_cast<DBOptions*>(&db_options),
+      const_cast<std::vector<ColumnFamilyDescriptor>*>(&column_families),
+      dbname);
+  *dbptr = nullptr;
+  ROCKSDB_SCOPE_EXIT(MaybeRetainDB(*dbptr, *handles));
+
   Status s = ValidateOptionsByTable(db_options, column_families);
   if (!s.ok()) {
     return s;
diff --git a/db/db_impl/db_impl_readonly.cc b/db/db_impl/db_impl_readonly.cc
index 83e7a9a3bb..2cf43b8f07 100644
--- a/db/db_impl/db_impl_readonly.cc
+++ b/db/db_impl/db_impl_readonly.cc
@@ -94,10 +94,12 @@ Status DBImplReadOnly::GetImpl(const ReadOptions& read_options,
       return s;
     }
   }
+  LookupKey lkey(key, snapshot, read_options.timestamp);
+ #else
+  ParsedInternalKey lkey(key, snapshot, kValueTypeForSeek);
  #endif
   MergeContext merge_context;
   SequenceNumber max_covering_tombstone_seq = 0;
-  LookupKey lkey(key, snapshot, read_options.timestamp);
   PERF_TIMER_STOP(get_snapshot_time);
 
   // Look up starts here
@@ -345,6 +347,11 @@ Status DBImplReadOnly::OpenForReadOnlyWithoutCheck(
   *dbptr = nullptr;
   handles->clear();
 
+  MaybeOptionsUpdateFrom(const_cast<DBOptions*>(&db_options),
+      const_cast<std::vector<ColumnFamilyDescriptor>*>(&column_families),
+      dbname);
+  ROCKSDB_SCOPE_EXIT(MaybeRetainDB(*dbptr, *handles));
+
   SuperVersionContext sv_context(/* create_superversion */ true);
   DBImplReadOnly* impl = new DBImplReadOnly(db_options, dbname);
   impl->mutex_.Lock();
diff --git a/db/db_impl/db_impl_secondary.cc b/db/db_impl/db_impl_secondary.cc
index 99422b4eb1..8f4d2e6415 100644
--- a/db/db_impl/db_impl_secondary.cc
+++ b/db/db_impl/db_impl_secondary.cc
@@ -167,11 +167,21 @@ Status DBImplSecondary::MaybeInitLogReader(
           io_tracer_));
     }
 
+    bool wal_memtable_format = immutable_db_options_.memtable_as_log_index;
+    if (immutable_db_options_.check_wal_format) {
+      if (IOStatus ios = log::Reader::IsMemTableAsLogIndexFile
+                   (*fs_, fname, &wal_memtable_format); !ios.ok()) {
+        auto info_log = immutable_db_options_.info_log.get();
+        ROCKS_LOG_WARN(info_log, "%s: %s", fname.c_str(), *ios.ToSSO());
+        return Status(ios);
+      }
+    }
+
     // Create the log reader.
     LogReaderContainer* log_reader_container = new LogReaderContainer(
         env_, immutable_db_options_.info_log, fname,
         std::move(file_reader), log_number);
-    if (immutable_db_options_.memtable_as_log_index) {
+    if (wal_memtable_format) {
       // will tailing log Reader, so must preserve mmap size
       auto mmap_size = GetMaxTotalWalSize() + 8*1024*1024;
       if (mmap_size > (1ull << 40)) {
@@ -424,7 +434,7 @@ Status DBImplSecondary::GetImpl(const ReadOptions& read_options,
 #if defined(TOPLINGDB_WITH_TIMESTAMP)
   LookupKey lkey(key, snapshot, read_options.timestamp);
 #else
-  LookupKey lkey(key, snapshot);
+  ParsedInternalKey lkey(key, snapshot, kValueTypeForSeek);
 #endif
   PERF_TIMER_STOP(get_snapshot_time);
   bool done = false;
@@ -801,6 +811,10 @@ Status DB::OpenAsSecondary(
   *dbptr = nullptr;
 
   DBOptions tmp_opts(db_options);
+  MaybeOptionsUpdateFrom(&tmp_opts,
+      const_cast<std::vector<ColumnFamilyDescriptor>*>(&column_families),
+      dbname);
+  ROCKSDB_SCOPE_EXIT(MaybeRetainDB(*dbptr, *handles));
   Status s;
   if (nullptr == tmp_opts.info_log) {
     s = CreateLoggerFromOptions(secondary_path, tmp_opts, &tmp_opts.info_log);
diff --git a/db/db_iter.cc b/db/db_iter.cc
index 969c8df2d6..2df4c83487 100644
--- a/db/db_iter.cc
+++ b/db/db_iter.cc
@@ -550,11 +550,12 @@ struct BytewiseCmpNoTS {
     // return x < y;
     ROCKSDB_ASSERT_EQ(x.size(), y.size());
     ROCKSDB_ASSERT_LE(x.size(), 64);
+    ROCKSDB_ASSERT_GT(x.size(), 0);
     __mmask64 msk = _bzhi_u64(-1, x.size());
     __m512i   xxx = _mm512_maskz_loadu_epi8(msk, x.data());
     __m512i   yyy = _mm512_maskz_loadu_epi8(msk, y.data());
     __mmask64 neq = _mm512_cmpneq_epi8_mask(xxx, yyy);
-    __mmask64 lt  = _mm512_cmplt_epi8_mask (xxx, yyy);
+    __mmask64 lt  = _mm512_cmplt_epu8_mask (xxx, yyy);
     return (lt & -neq) != 0;
   }
  #endif
@@ -595,7 +596,7 @@ struct VirtualCmpNoTS {
 template<size_t UserKeyLen>
 __always_inline
 void DBIter::FastIterKey::SetUK(const Slice& uk_slice) {
-  static_assert(UserKeyLen < sizeof(key));
+  static_assert(UserKeyLen + 8 < sizeof(key));
   auto uk_ptr = uk_slice.data();
   auto uk_len = uk_slice.size();
   if constexpr (UserKeyLen == 0) {
@@ -612,8 +613,9 @@ void DBIter::FastIterKey::SetUK(const Slice& uk_slice) {
       _mm512_mask_storeu_epi8(buf, mask, r512);
       // do not write last 8 bytes(seq + value_type)
     });
-   #elif defined(__clang__) || !defined(__GNUC__) || __GNUC__ >= 13
-    static_assert(false, "UserKeyLen == 64 should not on non-avx512");
+   #else
+    // (UserKeyLen != 64) == false here, for workardound
+    static_assert(UserKeyLen != 64, "UserKeyLen == 64 should not on non-avx512");
    #endif
   } else {
     ROCKSDB_ASSERT_EQ(uk_len, UserKeyLen);
@@ -2007,9 +2009,9 @@ void DBIter::Seek(const Slice& target) {
   if (statistics_ != nullptr) {
     // Decrement since we don't want to count this key as skipped
     RecordTick(statistics_, NUMBER_DB_SEEK_FOUND);
-    RecordTick(statistics_, ITER_BYTES_READ, key().size() + value().size());
+    RecordTick(statistics_, ITER_BYTES_READ, key().size());
   }
-  PERF_COUNTER_ADD(iter_read_bytes, key().size() + value().size());
+  PERF_COUNTER_ADD(iter_read_bytes, key().size());
   //local_stats_.BumpGlobalStatistics(statistics_);
 }
 
diff --git a/db/db_iter.h b/db/db_iter.h
index caea275161..9cc825f1c0 100644
--- a/db/db_iter.h
+++ b/db/db_iter.h
@@ -463,10 +463,10 @@ class DBIter final : public Iterator {
       if constexpr (FixLen == 64)
         // avx512 FixLen==64 means max is 64(without seqvt 8)
         return key.risk_to_str_local<Slice>().notail(8);
-      if constexpr (FixLen != 0)
+      if constexpr (FixLen != 0) // FixLen != 0 means fixed len
         return key.risk_to_str_local_known_len<Slice, FixLen + 8>().notail(8);
       else
-        return GetUserKey();
+        return GetUserKey(); // not fixed len, a bit slower
     }
     Slice GetUserKey() const { return key.notail<Slice>(8); }
     Slice GetInternalKey() const { return key.to<Slice>(); }
diff --git a/db/db_memtable_test.cc b/db/db_memtable_test.cc
index 2942379729..bd17b7c047 100644
--- a/db/db_memtable_test.cc
+++ b/db/db_memtable_test.cc
@@ -302,7 +302,7 @@ TEST_F(DBMemTableTest, ConcurrentMergeWrite) {
   Status status;
   ReadOptions roptions;
   SequenceNumber max_covering_tombstone_seq = 0;
-  LookupKey lkey("key", kMaxSequenceNumber);
+  ParsedInternalKey lkey("key", kMaxSequenceNumber, kValueTypeForSeek);
   PinnableSlice pin;
   bool res = mem->Get(lkey, &pin, /*columns=*/nullptr, /*timestamp=*/nullptr,
                       &status, &merge_context, &max_covering_tombstone_seq,
diff --git a/db/dbformat.h b/db/dbformat.h
index 9158cb9b7f..c90b1b2cec 100644
--- a/db/dbformat.h
+++ b/db/dbformat.h
@@ -22,6 +22,9 @@
 #include "rocksdb/types.h"
 #include "util/coding.h"
 #include "util/user_comparator_wrapper.h"
+#include <terark/sso.hpp>
+
+#define TOPLINGDB_OMIT_LOOKUP_KEY 1
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -161,6 +164,18 @@ struct ParsedInternalKey {
     const char* addr = user_key.data() + user_key.size() - ts_sz;
     return Slice(const_cast<char*>(addr), ts_sz);
   }
+
+  struct InternalKeyBuf : private terark::minimal_sso<64> {
+    explicit InternalKeyBuf(const ParsedInternalKey& pik) :
+      terark::minimal_sso<64>(pik.user_key.size() + 8,
+      [&](char* buf, size_t len) {
+        EncodeFixed64(buf + (len - 8), pik.GetTag());
+        memcpy(buf, pik.user_key.data(), len - 8);
+      })
+    {}
+    operator Slice() const { return this->to<Slice>(); }
+  };
+  InternalKeyBuf MakeInternalKeyBuf() const { return InternalKeyBuf(*this); }
 };
 static_assert(sizeof(ParsedInternalKey) == 32);
 
@@ -1247,6 +1262,78 @@ struct BytewiseCompareInternalKey {
     return GetUnalignedU64(px + n) > GetUnalignedU64(py + n);
   #endif
   }
+  __always_inline bool operator()(const ParsedInternalKey& x, Slice y) const noexcept {
+    ROCKSDB_ASSERT_GE(y.size_, 8);
+  #if !TOPLINGDB_USE_MANUAL_MEMCMP
+    size_t n = std::min(x.user_key.size_, y.size_ - 8);
+    int cmp = memcmp(x.user_key.data_, y.data_, n);
+    if (0 != cmp) return cmp < 0;
+    if (x.user_key.size_ != y.size_ - 8) return x.user_key.size_ < y.size_ - 8;
+    return x.GetTag() > GetUnalignedU64(y.data_ + n);
+  #else
+    auto px = (const unsigned char*)x.user_key.data(); size_t nx = x.user_key.size();
+    auto py = (const unsigned char*)y.data(); size_t ny = y.size() - 8;
+    size_t i = 0, n = std::min(nx, ny);
+    for (; i + 8 <= n; i += 8) {
+      auto ux = NativeOfBigEndian64(*(const uint64_t*)(px + i));
+      auto uy = NativeOfBigEndian64(*(const uint64_t*)(py + i));
+      if (ux != uy)
+        return ux < uy;
+    }
+    if (n % sizeof(uint64_t) >= 4) {
+      auto ux = NativeOfBigEndian32(*(const uint32_t*)(px + i));
+      auto uy = NativeOfBigEndian32(*(const uint32_t*)(py + i));
+      if (ux != uy)
+        return ux < uy;
+      else
+        i += 4;
+    }
+    for (; i < n; i++) {
+      int ux = px[i], uy = py[i];
+      if (ux != uy)
+        return ux < uy;
+    }
+    if (nx != ny)
+      return nx < ny;
+    return x.GetTag() > GetUnalignedU64(py + n);
+  #endif
+  }
+  __always_inline bool operator()(Slice x, const ParsedInternalKey& y) const noexcept {
+    ROCKSDB_ASSERT_GE(x.size_, 8);
+  #if !TOPLINGDB_USE_MANUAL_MEMCMP
+    size_t n = std::min(x.size_ - 8, y.user_key.size_);
+    int cmp = memcmp(x.data_, y.user_key.data_, n);
+    if (0 != cmp) return cmp < 0;
+    if (x.size_ - 8 != y.user_key.size_) return x.size_ - 8 < y.user_key.size_;
+    return GetUnalignedU64(x.data_ + n) > y.GetTag();
+  #else
+    auto px = (const unsigned char*)x.data(); size_t nx = x.size() - 8;
+    auto py = (const unsigned char*)y.user_key.data(); size_t ny = y.user_key.size();
+    size_t i = 0, n = std::min(nx, ny);
+    for (; i + 8 <= n; i += 8) {
+      auto ux = NativeOfBigEndian64(*(const uint64_t*)(px + i));
+      auto uy = NativeOfBigEndian64(*(const uint64_t*)(py + i));
+      if (ux != uy)
+        return ux < uy;
+    }
+    if (n % sizeof(uint64_t) >= 4) {
+      auto ux = NativeOfBigEndian32(*(const uint32_t*)(px + i));
+      auto uy = NativeOfBigEndian32(*(const uint32_t*)(py + i));
+      if (ux != uy)
+        return ux < uy;
+      else
+        i += 4;
+    }
+    for (; i < n; i++) {
+      int ux = px[i], uy = py[i];
+      if (ux != uy)
+        return ux < uy;
+    }
+    if (nx != ny)
+      return nx < ny;
+    return GetUnalignedU64(px + n) > y.GetTag();
+  #endif
+  }
   __always_inline bool operator()(uint64_t x, uint64_t y) const noexcept {
     return x < y;
   }
@@ -1254,19 +1341,38 @@ struct BytewiseCompareInternalKey {
 };
 struct RevBytewiseCompareInternalKey {
   __always_inline bool operator()(Slice x, Slice y) const noexcept {
+    ROCKSDB_ASSERT_GE(x.size_, 8);
+    ROCKSDB_ASSERT_GE(y.size_, 8);
     size_t n = std::min(x.size_, y.size_) - 8;
     int cmp = memcmp(x.data_, y.data_, n);
     if (0 != cmp) return cmp > 0;
     if (x.size_ != y.size_) return x.size_ > y.size_;
     return GetUnalignedU64(x.data_ + n) > GetUnalignedU64(y.data_ + n);
   }
+  __always_inline bool operator()(const ParsedInternalKey& x, Slice y) const noexcept {
+    ROCKSDB_ASSERT_GE(y.size_, 8);
+    size_t n = std::min(x.user_key.size_, y.size_ - 8);
+    int cmp = memcmp(x.user_key.data_, y.data_, n);
+    if (0 != cmp) return cmp > 0;
+    if (x.user_key.size_ != y.size_ - 8) return x.user_key.size_ > y.size_ - 8;
+    return x.GetTag() > GetUnalignedU64(y.data_ + n);
+  }
+  __always_inline bool operator()(Slice x, const ParsedInternalKey& y) const noexcept {
+    ROCKSDB_ASSERT_GE(x.size_, 8);
+    size_t n = std::min(x.size_ - 8, y.user_key.size_);
+    int cmp = memcmp(x.data_, y.user_key.data_, n);
+    if (0 != cmp) return cmp > 0;
+    if (x.size_ - 8 != y.user_key.size_) return x.size_ - 8 > y.user_key.size_;
+    return GetUnalignedU64(x.data_ + n) > y.GetTag();
+  }
   __always_inline bool operator()(uint64_t x, uint64_t y) const noexcept {
     return x > y;
   }
   RevBytewiseCompareInternalKey(...) {}
 };
 struct FallbackVirtCmp {
-  __always_inline bool operator()(Slice x, Slice y) const {
+  template<class KeyX, class KeyY>
+  __always_inline bool operator()(const KeyX& x, const KeyY& y) const {
     return icmp->Compare(x, y) < 0;
   }
   const InternalKeyComparator* icmp;
diff --git a/db/flush_job.cc b/db/flush_job.cc
index 9da817ac56..1adb729d23 100644
--- a/db/flush_job.cc
+++ b/db/flush_job.cc
@@ -748,7 +748,7 @@ bool FlushJob::MemPurgeDecider(double threshold) {
       // Count entry bytes as payload.
       payload += entry_size;
 
-      LookupKey lkey(res.user_key, kMaxSequenceNumber);
+      ParsedInternalKey lkey(res.user_key, kMaxSequenceNumber, kValueTypeForSeek);
 
       // Paranoia: zero out these values just in case.
       max_covering_tombstone_seq = 0;
diff --git a/db/internal_stats.cc b/db/internal_stats.cc
index a953e5a8bb..940361e75f 100644
--- a/db/internal_stats.cc
+++ b/db/internal_stats.cc
@@ -1624,7 +1624,7 @@ void InternalStats::DumpDBStats(std::string* value) {
   // The format is the same for interval stats.
   snprintf(buf, sizeof(buf),
            "Cumulative writes: %s writes, %s keys, %s commit groups, "
-           "%.1f writes per commit group, ingest: %.2f GB, %.2f MB/s\n",
+           "%.1f writes per commit group, ingest: %7.2f GB, %7.2f MB/s\n",
            NumberToHumanString(write_other + write_self).c_str(),
            NumberToHumanString(num_keys_written).c_str(),
            NumberToHumanString(write_self).c_str(),
@@ -1635,20 +1635,13 @@ void InternalStats::DumpDBStats(std::string* value) {
   value->append(buf);
   // WAL
   snprintf(buf, sizeof(buf),
-           "Cumulative WAL: %s writes, %s syncs, "
-           "%.2f writes per sync, written: %.2f GB, %.2f MB/s\n",
+           "Cumulative WAL   : %s writes, %s sync, "
+           "%7.2f writes per sync, written: %7.2f GB, %7.2f MB/s\n",
            NumberToHumanString(write_with_wal).c_str(),
            NumberToHumanString(wal_synced).c_str(),
            write_with_wal / std::max(1.0, static_cast<double>(wal_synced)),
            wal_bytes / kGB, wal_bytes / kMB / std::max(seconds_up, 0.001));
   value->append(buf);
-  // Stall
-  AppendHumanMicros(write_stall_micros, human_micros, kHumanMicrosLen, true);
-  snprintf(buf, sizeof(buf), "Cumulative stall: %s, %.1f percent\n",
-           human_micros,
-           // 10000 = divide by 1M to get secs, then multiply by 100 for pct
-           write_stall_micros / 10000.0 / std::max(seconds_up, 0.001));
-  value->append(buf);
 
   // Interval
   uint64_t interval_write_other = write_other - db_stats_snapshot_.write_other;
@@ -1657,8 +1650,8 @@ void InternalStats::DumpDBStats(std::string* value) {
       num_keys_written - db_stats_snapshot_.num_keys_written;
   snprintf(
       buf, sizeof(buf),
-      "Interval writes: %s writes, %s keys, %s commit groups, "
-      "%.1f writes per commit group, ingest: %.2f MB, %.2f MB/s\n",
+      "Interval   writes: %s writes, %s keys, %s commit groups, "
+      "%.1f writes per commit group, ingest: %7.2f MB, %7.2f MB/s\n",
       NumberToHumanString(interval_write_other + interval_write_self).c_str(),
       NumberToHumanString(interval_num_keys_written).c_str(),
       NumberToHumanString(interval_write_self).c_str(),
@@ -1675,8 +1668,8 @@ void InternalStats::DumpDBStats(std::string* value) {
   uint64_t interval_wal_bytes = wal_bytes - db_stats_snapshot_.wal_bytes;
 
   snprintf(buf, sizeof(buf),
-           "Interval WAL: %s writes, %s syncs, "
-           "%.2f writes per sync, written: %.2f GB, %.2f MB/s\n",
+           "Interval   WAL   : %s writes, %s sync, "
+           "%7.2f writes per sync, written: %7.2f GB, %7.2f MB/s\n",
            NumberToHumanString(interval_write_with_wal).c_str(),
            NumberToHumanString(interval_wal_synced).c_str(),
            interval_write_with_wal /
@@ -1685,10 +1678,17 @@ void InternalStats::DumpDBStats(std::string* value) {
            interval_wal_bytes / kMB / std::max(interval_seconds_up, 0.001));
   value->append(buf);
 
+  // Stall
+  AppendHumanMicros(write_stall_micros, human_micros, kHumanMicrosLen, true);
+  snprintf(buf, sizeof(buf), "Cumulative stall : %s, %.1f percent\n",
+           human_micros,
+           // 10000 = divide by 1M to get secs, then multiply by 100 for pct
+           write_stall_micros / 10000.0 / std::max(seconds_up, 0.001));
+  value->append(buf);
   // Stall
   AppendHumanMicros(write_stall_micros - db_stats_snapshot_.write_stall_micros,
                     human_micros, kHumanMicrosLen, true);
-  snprintf(buf, sizeof(buf), "Interval stall: %s, %.1f percent\n", human_micros,
+  snprintf(buf, sizeof(buf), "Interval   stall : %s, %.1f percent\n", human_micros,
            // 10000 = divide by 1M to get secs, then multiply by 100 for pct
            (write_stall_micros - db_stats_snapshot_.write_stall_micros) /
                10000.0 / std::max(interval_seconds_up, 0.001));
diff --git a/db/log_reader.cc b/db/log_reader.cc
index 15a145d999..309720b3eb 100644
--- a/db/log_reader.cc
+++ b/db/log_reader.cc
@@ -84,6 +84,11 @@ IOStatus Reader::IsMemTableAsLogIndexFile
   if (!ios.ok()) {
     return ios;
   }
+  // Short/empty file: do not CRC uninitialized stack bytes.
+  if (data.size() != sizeof(header)) {
+    *result = false;
+    return IOStatus::OK();
+  }
   auto computed = crc32c::Value(header.hbytes, sizeof(header.hbytes));
   *result = computed == header.header_checksum;
   return ios;
@@ -128,8 +133,8 @@ Reader::ReadRawRec(Slice* record, WALRecoveryMode wal_recovery_mode) {
   auto computed = crc32c::Value(header.hbytes, sizeof(header.hbytes));
   if (computed != header.header_checksum) {
     static const char zeros[sizeof(RawRecHeader)] = {};
-    if (memcmp(&header, zeros, sizeof(sizeof(RawRecHeader))) == 0) {
-      auto pos = size_t(end_of_buffer_offset_ - buffer_.size_);
+    if (memcmp(&header, zeros, sizeof(RawRecHeader)) == 0) {
+      auto pos = end_of_buffer_offset_ - buffer_.size_;
       fprintf(stderr, "ERR: %s:%d: Reader::ReadRawRec(%s) ZeroEOF at %zd\n",
               __FILE__, __LINE__, file_->file_name().c_str(), pos);
     } else {
diff --git a/db/lookup_key.h b/db/lookup_key.h
index ee9c889c37..133f150778 100644
--- a/db/lookup_key.h
+++ b/db/lookup_key.h
@@ -14,6 +14,7 @@
 #include "rocksdb/slice.h"
 #include "rocksdb/types.h"
 #include "port/likely.h"
+#include "dbformat.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -62,6 +63,10 @@ class LookupKey {
       return Slice(longstart_, klength_ - 8);
   }
 
+  operator ParsedInternalKey() const {
+    return ParsedInternalKey(internal_key());
+  }
+
  private:
   // We construct a char array of the form:
   // short keys: klength_ <= sizeof(space_)
diff --git a/db/memtable.cc b/db/memtable.cc
index 1abb6ec0bb..6c8bbfab61 100644
--- a/db/memtable.cc
+++ b/db/memtable.cc
@@ -170,6 +170,10 @@ MemTable::~MemTable() {
   assert(refs_ == 0);
 }
 
+// for ApproximateMemoryUsage(insert_hints_)
+static size_t ApproximateMemoryUsage(const terark::hash_strmap<void*>& map) {
+  return map.capacity() * 16 + map.strpool_capacity() + map.bucket_size() * 4;
+}
 size_t MemTable::ApproximateMemoryUsage() {
   size_t usages[] = {
       arena_.ApproximateMemoryUsage(), table_->ApproximateMemoryUsage(),
@@ -298,6 +302,26 @@ int MemTable::KeyComparator::operator()(
   return comparator.CompareKeySeq(a, key);
 }
 
+int MemTable::KeyComparator::operator()(const char* prefix_len_key,
+                                        const ParsedInternalKey& b) const {
+  Slice a = GetLengthPrefixedSlice(prefix_len_key);
+  return comparator.Compare(a, b);
+}
+
+int MemTable::KeyComparator::operator()(const ParsedInternalKey& a,
+                                        const char* prefix_len_key) const {
+  Slice b = GetLengthPrefixedSlice(prefix_len_key);
+  return comparator.Compare(a, b);
+}
+
+void MemTableRep::GetPIK(const struct ReadOptions& ro,
+                         const ParsedInternalKey& pik, void* callback_args,
+                         bool (*callback_func)(void* arg, const KeyValuePair&))
+{
+  LookupKey lk(pik.user_key, pik.sequence);
+  Get(ro, lk, callback_args, callback_func);
+}
+
 void MemTableRep::InsertConcurrently(KeyHandle /*handle*/) {
   throw std::runtime_error("concurrent insert not supported");
 }
@@ -924,7 +948,12 @@ namespace {
 
 struct Saver {
   Status* status;
-  const LookupKey* key;
+  struct LikeLookupKey : private Slice {
+    using Slice::operator=;
+    const Slice& user_key() const { return *this; }
+    const LikeLookupKey* operator->() const { return this; }
+  };
+  LikeLookupKey key;
   PinnableSlice* value;
   PinnableWideColumns* columns;
   SequenceNumber seq;
@@ -1308,7 +1337,7 @@ static bool SaveValue(void* arg, const MemTableRep::KeyValuePair& pair) {
 }
 
 ROCKSDB_FLATTEN
-bool MemTable::Get(const LookupKey& key, PinnableSlice* value,
+bool MemTable::Get(const ParsedInternalKey& key, PinnableSlice* value,
                    PinnableWideColumns* columns, std::string* timestamp,
                    Status* s, MergeContext* merge_context,
                    SequenceNumber* max_covering_tombstone_seq,
@@ -1325,11 +1354,11 @@ bool MemTable::Get(const LookupKey& key, PinnableSlice* value,
 
   std::unique_ptr<FragmentedRangeTombstoneIterator> range_del_iter(
       NewRangeTombstoneIterator(read_opts,
-                                GetInternalKeySeqno(key.internal_key()),
+                                key.sequence,
                                 immutable_memtable));
   if (range_del_iter != nullptr) {
     SequenceNumber covering_seq =
-        range_del_iter->MaxCoveringTombstoneSeqnum(key.user_key());
+        range_del_iter->MaxCoveringTombstoneSeqnum(key.user_key);
     if (covering_seq > *max_covering_tombstone_seq) {
       *max_covering_tombstone_seq = covering_seq;
       if (timestamp) {
@@ -1345,9 +1374,9 @@ bool MemTable::Get(const LookupKey& key, PinnableSlice* value,
     bool may_contain = true;
   #if defined(TOPLINGDB_WITH_TIMESTAMP)
     size_t ts_sz = GetInternalKeyComparator().user_comparator()->timestamp_size();
-    Slice user_key_without_ts = StripTimestampFromUserKey(key.user_key(), ts_sz);
+    Slice user_key_without_ts = StripTimestampFromUserKey(key.user_key, ts_sz);
   #else
-    Slice user_key_without_ts = key.user_key();
+    Slice user_key_without_ts = key.user_key;
   #endif
     bool bloom_checked = false;
     // when both memtable_whole_key_filtering and prefix_extractor_ are set,
@@ -1380,7 +1409,7 @@ bool MemTable::Get(const LookupKey& key, PinnableSlice* value,
   saver.status = s;
   saver.found_final_value = false;
   saver.merge_in_progress = s->IsMergeInProgress();
-  saver.key = &key;
+  saver.key = key.user_key;
   saver.value = value;
   saver.columns = columns;
   saver.timestamp = timestamp;
@@ -1402,7 +1431,7 @@ bool MemTable::Get(const LookupKey& key, PinnableSlice* value,
   if (LIKELY(value != nullptr)) {
     value->Reset();
   }
-  table_->Get(read_opts, key, &saver, SaveValue);
+  table_->GetPIK(read_opts, key, &saver, SaveValue);
   *seq = saver.seq;
 
   // No change to value, since we have not yet found a Put/Delete
@@ -1460,10 +1489,10 @@ void MemTable::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
     if (!no_range_del) {
       std::unique_ptr<FragmentedRangeTombstoneIterator> range_del_iter(
           NewRangeTombstoneIteratorInternal(
-              read_options, GetInternalKeySeqno(iter->lkey->internal_key()),
+              read_options, iter->ikey.sequence,
               immutable_memtable));
       SequenceNumber covering_seq =
-          range_del_iter->MaxCoveringTombstoneSeqnum(iter->lkey->user_key());
+          range_del_iter->MaxCoveringTombstoneSeqnum(iter->ikey.user_key);
       if (covering_seq > iter->max_covering_tombstone_seq) {
         iter->max_covering_tombstone_seq = covering_seq;
         if (iter->timestamp) {
@@ -1478,7 +1507,7 @@ void MemTable::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
     saver.status = iter->s;
     saver.found_final_value = false;
     saver.merge_in_progress = iter->s->IsMergeInProgress();
-    saver.key = iter->lkey;
+    saver.key = iter->ikey.user_key;
     saver.value = iter->value; // not null
     if (saver.value)
       saver.value->Reset();
@@ -1499,7 +1528,7 @@ void MemTable::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
     saver.allow_data_in_errors = moptions_.allow_data_in_errors;
     saver.is_zero_copy = read_options.internal_is_in_pinning_section;
     saver.needs_user_key_cmp_in_get = needs_user_key_cmp_in_get_;
-    table_->Get(read_options, *(iter->lkey), &saver, SaveValue);
+    table_->GetPIK(read_options, iter->ikey, &saver, SaveValue);
 
     if (!saver.found_final_value && saver.merge_in_progress) {
       *(iter->s) = Status::MergeInProgress();
diff --git a/db/memtable.h b/db/memtable.h
index e04a456d4c..04549a3187 100644
--- a/db/memtable.h
+++ b/db/memtable.h
@@ -9,8 +9,6 @@
 
 #pragma once
 #include <atomic>
-#include <deque>
-#include <functional>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -23,15 +21,12 @@
 #include "db/version_edit.h"
 #include "memory/allocator.h"
 #include "memory/concurrent_arena.h"
-#include "monitoring/instrumented_mutex.h"
 #include "options/cf_options.h"
 #include "rocksdb/db.h"
 #include "rocksdb/memtablerep.h"
 #include "table/internal_iterator.h"
 #include "table/multiget_context.h"
 #include "util/dynamic_bloom.h"
-#include "util/hash.h"
-#include "util/hash_containers.h"
 
 #if defined(TOPLINGDB_WITH_TIMESTAMP)
 #include <terark/sso.hpp>
@@ -139,6 +134,10 @@ class MemTable : public CacheAlignedNewDelete {
                            const char* prefix_len_key2) const override;
     virtual int operator()(const char* prefix_len_key,
                            const DecodedType& key) const override;
+    virtual int operator()(const char* prefix_len_key,
+                           const ParsedInternalKey&) const override;
+    virtual int operator()(const ParsedInternalKey&,
+                           const char* prefix_len_key) const override;
     virtual const InternalKeyComparator* icomparator() const override;
   };
 
@@ -306,7 +305,7 @@ class MemTable : public CacheAlignedNewDelete {
   // @param immutable_memtable Whether this memtable is immutable. Used
   // internally by NewRangeTombstoneIterator(). See comment above
   // NewRangeTombstoneIterator() for more detail.
-  bool Get(const LookupKey& key, PinnableSlice* value,
+  bool Get(const ParsedInternalKey& key, PinnableSlice* value,
            PinnableWideColumns* columns, std::string* timestamp, Status* s,
            MergeContext* merge_context,
            SequenceNumber* max_covering_tombstone_seq, SequenceNumber* seq,
@@ -314,7 +313,7 @@ class MemTable : public CacheAlignedNewDelete {
            ReadCallback* callback = nullptr, bool* is_blob_index = nullptr,
            bool do_merge = true);
 
-  bool Get(const LookupKey& key, PinnableSlice* value,
+  bool Get(const ParsedInternalKey& key, PinnableSlice* value,
            PinnableWideColumns* columns, std::string* timestamp, Status* s,
            MergeContext* merge_context,
            SequenceNumber* max_covering_tombstone_seq,
@@ -698,7 +697,8 @@ class MemTable : public CacheAlignedNewDelete {
   const SliceTransform* insert_with_hint_prefix_extractor_;
 
   // Insert hints for each prefix.
-  UnorderedMapH<Slice, void*, SliceHasher32> insert_hints_;
+  // UnorderedMapH<Slice, void*, SliceHasher32> insert_hints_;
+  terark::hash_strmap<void*> insert_hints_;
 
   // Timestamp of oldest key
   std::atomic<uint64_t> oldest_key_time_;
diff --git a/db/memtable_list.cc b/db/memtable_list.cc
index deeccae575..9eacca84e9 100644
--- a/db/memtable_list.cc
+++ b/db/memtable_list.cc
@@ -110,7 +110,7 @@ int MemTableList::NumFlushed() const {
 // Search all the memtables starting from the most recent one.
 // Return the most recent value found, if any.
 // Operands stores the list of merge operations to apply, so far.
-bool MemTableListVersion::Get(const LookupKey& key, PinnableSlice* value,
+bool MemTableListVersion::Get(const ParsedInternalKey& key, PinnableSlice* value,
                               PinnableWideColumns* columns,
                               std::string* timestamp, Status* s,
                               MergeContext* merge_context,
@@ -135,7 +135,7 @@ void MemTableListVersion::MultiGet(const ReadOptions& read_options,
 }
 
 bool MemTableListVersion::GetMergeOperands(
-    const LookupKey& key, Status* s, MergeContext* merge_context,
+    const ParsedInternalKey& key, Status* s, MergeContext* merge_context,
     SequenceNumber* max_covering_tombstone_seq, const ReadOptions& read_opts) {
   for (MemTable* memtable : memlist_) {
     bool done = memtable->Get(
@@ -150,7 +150,7 @@ bool MemTableListVersion::GetMergeOperands(
 }
 
 bool MemTableListVersion::GetFromHistory(
-    const LookupKey& key, PinnableSlice* value, PinnableWideColumns* columns,
+    const ParsedInternalKey& key, PinnableSlice* value, PinnableWideColumns* columns,
     std::string* timestamp, Status* s, MergeContext* merge_context,
     SequenceNumber* max_covering_tombstone_seq, SequenceNumber* seq,
     const ReadOptions& read_opts, bool* is_blob_index) {
@@ -160,7 +160,7 @@ bool MemTableListVersion::GetFromHistory(
 }
 
 bool MemTableListVersion::GetFromList(
-    std::list<MemTable*>* list, const LookupKey& key, PinnableSlice* value,
+    std::list<MemTable*>* list, const ParsedInternalKey& key, PinnableSlice* value,
     PinnableWideColumns* columns, std::string* timestamp, Status* s,
     MergeContext* merge_context, SequenceNumber* max_covering_tombstone_seq,
     SequenceNumber* seq, const ReadOptions& read_opts, ReadCallback* callback,
diff --git a/db/memtable_list.h b/db/memtable_list.h
index 328d160e83..6630046b68 100644
--- a/db/memtable_list.h
+++ b/db/memtable_list.h
@@ -57,14 +57,14 @@ class MemTableListVersion {
   // If any operation was found for this key, its most recent sequence number
   // will be stored in *seq on success (regardless of whether true/false is
   // returned).  Otherwise, *seq will be set to kMaxSequenceNumber.
-  bool Get(const LookupKey& key, PinnableSlice* value,
+  bool Get(const ParsedInternalKey&, PinnableSlice* value,
            PinnableWideColumns* columns, std::string* timestamp, Status* s,
            MergeContext* merge_context,
            SequenceNumber* max_covering_tombstone_seq, SequenceNumber* seq,
            const ReadOptions& read_opts, ReadCallback* callback = nullptr,
            bool* is_blob_index = nullptr);
 
-  bool Get(const LookupKey& key, PinnableSlice* value,
+  bool Get(const ParsedInternalKey& key, PinnableSlice* value,
            PinnableWideColumns* columns, std::string* timestamp, Status* s,
            MergeContext* merge_context,
            SequenceNumber* max_covering_tombstone_seq,
@@ -83,7 +83,7 @@ class MemTableListVersion {
 
   // Returns all the merge operands corresponding to the key by searching all
   // memtables starting from the most recent one.
-  bool GetMergeOperands(const LookupKey& key, Status* s,
+  bool GetMergeOperands(const ParsedInternalKey&, Status* s,
                         MergeContext* merge_context,
                         SequenceNumber* max_covering_tombstone_seq,
                         const ReadOptions& read_opts);
@@ -92,13 +92,13 @@ class MemTableListVersion {
   // have already been flushed.  Should only be used from in-memory only
   // queries (such as Transaction validation) as the history may contain
   // writes that are also present in the SST files.
-  bool GetFromHistory(const LookupKey& key, PinnableSlice* value,
+  bool GetFromHistory(const ParsedInternalKey&, PinnableSlice* value,
                       PinnableWideColumns* columns, std::string* timestamp,
                       Status* s, MergeContext* merge_context,
                       SequenceNumber* max_covering_tombstone_seq,
                       SequenceNumber* seq, const ReadOptions& read_opts,
                       bool* is_blob_index = nullptr);
-  bool GetFromHistory(const LookupKey& key, PinnableSlice* value,
+  bool GetFromHistory(const ParsedInternalKey& key, PinnableSlice* value,
                       PinnableWideColumns* columns, std::string* timestamp,
                       Status* s, MergeContext* merge_context,
                       SequenceNumber* max_covering_tombstone_seq,
@@ -162,7 +162,7 @@ class MemTableListVersion {
   // Return true if memtable is trimmed
   bool TrimHistory(autovector<MemTable*>* to_delete, size_t usage);
 
-  bool GetFromList(std::list<MemTable*>* list, const LookupKey& key,
+  bool GetFromList(std::list<MemTable*>* list, const ParsedInternalKey& key,
                    PinnableSlice* value, PinnableWideColumns* columns,
                    std::string* timestamp, Status* s,
                    MergeContext* merge_context,
diff --git a/db/memtable_list_test.cc b/db/memtable_list_test.cc
index 1766456791..1314a7557c 100644
--- a/db/memtable_list_test.cc
+++ b/db/memtable_list_test.cc
@@ -34,6 +34,12 @@ static auto g_cspp_fac = []()-> std::shared_ptr<MemTableRepFactory> {
   return nullptr;
 }();
 
+struct HideLookupKey : ParsedInternalKey {
+  HideLookupKey(Slice uk, uint64_t seq) :
+    ParsedInternalKey(uk, seq, kValueTypeForSeek) {}
+};
+#define LookupKey HideLookupKey
+
 class MemTableListTest : public testing::Test {
  public:
   std::string dbname;
diff --git a/db/repair.cc b/db/repair.cc
index 69c662d22c..2fd9992b28 100644
--- a/db/repair.cc
+++ b/db/repair.cc
@@ -401,7 +401,16 @@ class Repairer {
     std::string scratch;
     Slice record;
     WriteBatch batch;
-    if (db_options_.memtable_as_log_index) {
+    bool wal_memtable_format = db_options_.memtable_as_log_index;
+    if (db_options_.check_wal_format) {
+      if (IOStatus ios = log::Reader::IsMemTableAsLogIndexFile
+                         (*fs, logname, &wal_memtable_format); !ios.ok()) {
+        ROCKS_LOG_WARN(db_options_.info_log, "%s: %s",
+                       logname.c_str(), *ios.ToSSO());
+        return Status(ios);
+      }
+    }
+    if (wal_memtable_format) {
       reader.InitSetMemTableAsLogIndex(*fs);
       auto [fmap, ios] = ReadonlyFileMmap::New(*fs, log, logname);
       if (!ios.ok() && ios.ToString() != "Invalid argument: Empty File")
diff --git a/db/table_cache.cc b/db/table_cache.cc
index 0dd427049e..3544cb0d61 100644
--- a/db/table_cache.cc
+++ b/db/table_cache.cc
@@ -439,7 +439,8 @@ bool TableCache::GetFromRowCache(const Slice& user_key, IterKey& row_cache_key,
 Status TableCache::GetWithRowCache(
     const ReadOptions& options,
     const InternalKeyComparator& internal_comparator,
-    const FileMetaData& file_meta, const Slice& k, GetContext* get_context,
+    const FileMetaData& file_meta, const ParsedInternalKey& pik,
+    GetContext* get_context,
     uint8_t block_protection_bytes_per_key,
     const std::shared_ptr<const SliceTransform>& prefix_extractor,
     HistogramImpl* file_read_hist, bool skip_filters, int level,
@@ -453,6 +454,8 @@ Status TableCache::GetWithRowCache(
   // Check row cache if enabled.
   // Reuse row_cache_key sequence number when row cache hits.
   if (ioptions_.row_cache && !get_context->NeedToReadSequence()) {
+    const auto ikbuf = pik.MakeInternalKeyBuf();
+    const Slice k = ikbuf;
     auto user_key = ExtractUserKey(k);
     uint64_t cache_entry_seq_no =
         CreateRowCacheKeyPrefix(options, fd, k, get_context, row_cache_key);
@@ -486,7 +489,7 @@ Status TableCache::GetWithRowCache(
           t->NewRangeTombstoneIterator(options));
       if (range_del_iter != nullptr) {
         SequenceNumber seq =
-            range_del_iter->MaxCoveringTombstoneSeqnum(ExtractUserKey(k));
+            range_del_iter->MaxCoveringTombstoneSeqnum(pik.user_key);
         if (seq > *max_covering_tombstone_seq) {
           *max_covering_tombstone_seq = seq;
           if (get_context->NeedTimestamp()) {
@@ -498,7 +501,7 @@ Status TableCache::GetWithRowCache(
     }
     if (s.ok()) {
       get_context->SetReplayLog(row_cache_entry);  // nullptr if no cache.
-      s = t->Get(options, k, get_context, prefix_extractor.get(), skip_filters);
+      s = t->GetPIK(options, pik, get_context, prefix_extractor.get(), skip_filters);
       get_context->SetReplayLog(nullptr);
     } else if (options.read_tier == kBlockCacheTier && s.IsIncomplete()) {
       // Couldn't find Table in cache but treat as kFound if no_io set
diff --git a/db/table_cache.h b/db/table_cache.h
index ee85f7ba4e..fc97e10ff3 100644
--- a/db/table_cache.h
+++ b/db/table_cache.h
@@ -116,7 +116,7 @@ class TableCache {
   Status Get(
       const ReadOptions& options,
       const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, const Slice& k, GetContext* get_context,
+      const FileMetaData& file_meta, const ParsedInternalKey& k, GetContext* get_context,
       uint8_t block_protection_bytes_per_key,
       const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr,
       HistogramImpl* file_read_hist = nullptr, bool skip_filters = false,
@@ -136,7 +136,7 @@ class TableCache {
   Status GetWithRowCache(
       const ReadOptions& options,
       const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, const Slice& k, GetContext* get_context,
+      const FileMetaData& file_meta, const ParsedInternalKey&, GetContext*,
       uint8_t block_protection_bytes_per_key,
       const std::shared_ptr<const SliceTransform>& prefix_extractor,
       HistogramImpl* file_read_hist, bool skip_filters,
@@ -144,7 +144,7 @@ class TableCache {
   Status GetNoneRowCache(
       const ReadOptions& options,
       const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, const Slice& k, GetContext* get_context,
+      const FileMetaData& file_meta, const ParsedInternalKey&, GetContext*,
       uint8_t block_protection_bytes_per_key,
       const std::shared_ptr<const SliceTransform>& prefix_extractor,
       HistogramImpl* file_read_hist, bool skip_filters,
@@ -329,7 +329,8 @@ __always_inline
 Status TableCache::GetNoneRowCache(
     const ReadOptions& options,
     const InternalKeyComparator& internal_comparator,
-    const FileMetaData& file_meta, const Slice& k, GetContext* get_context,
+    const FileMetaData& file_meta, const ParsedInternalKey& pik,
+    GetContext* get_context,
     uint8_t block_protection_bytes_per_key,
     const std::shared_ptr<const SliceTransform>& prefix_extractor,
     HistogramImpl* file_read_hist, bool skip_filters, int level,
@@ -355,19 +356,21 @@ Status TableCache::GetNoneRowCache(
     std::unique_ptr<FragmentedRangeTombstoneIterator> range_del_iter(
         t->NewRangeTombstoneIterator(options));
     if (range_del_iter != nullptr) {
-      auto seq = range_del_iter->MaxCoveringTombstoneSeqnum(ExtractUserKey(k));
+      auto seq = range_del_iter->MaxCoveringTombstoneSeqnum(pik.user_key);
       if (seq > *max_covering_tombstone_seq) {
         *max_covering_tombstone_seq = seq;
+       #if defined(TOPLINGDB_WITH_TIMESTAMP)
         if (get_context->NeedTimestamp()) {
           get_context->SetTimestampFromRangeTombstone(range_del_iter->timestamp());
         }
+       #endif
       }
     }
   }
   if (LIKELY(handle == nullptr)) { // optimize for compiler tail call
-    return t->Get(options, k, get_context, prefix_extractor.get(), skip_filters);
+    return t->GetPIK(options, pik, get_context, prefix_extractor.get(), skip_filters);
   } else {
-    Status s = t->Get(options, k, get_context, prefix_extractor.get(), skip_filters);
+    Status s = t->GetPIK(options, pik, get_context, prefix_extractor.get(), skip_filters);
     cache_.Release(handle);
     return s;
   }
diff --git a/db/table_cache_sync_and_async.h b/db/table_cache_sync_and_async.h
index 8ff03ec501..16b11094c0 100644
--- a/db/table_cache_sync_and_async.h
+++ b/db/table_cache_sync_and_async.h
@@ -40,7 +40,8 @@ DEFINE_SYNC_AND_ASYNC(Status, TableCache::MultiGet)
   // sequence numbers, we cannot use it if we need to fetch the sequence.
   if (lookup_row_cache) {
     GetContext* first_context = first_key.get_context;
-    CreateRowCacheKeyPrefix(options, fd, first_key.ikey, first_context,
+    const auto first_ik = first_key.InternalKeyBuf();
+    CreateRowCacheKeyPrefix(options, fd, first_ik, first_context,
                             row_cache_key);
     row_cache_key_prefix_size = row_cache_key.Size();
 
diff --git a/db/transaction_log_impl.cc b/db/transaction_log_impl.cc
index 729420a8ec..7683c4b357 100644
--- a/db/transaction_log_impl.cc
+++ b/db/transaction_log_impl.cc
@@ -288,10 +288,20 @@ Status TransactionLogIteratorImpl::OpenLogReader(const LogFile* log_file) {
     return s;
   }
   assert(file);
+  const std::string& fname = file->file_name();
+  bool wal_memtable_format = options_->memtable_as_log_index;
+  if (options_->check_wal_format) {
+    if (IOStatus ios = log::Reader::IsMemTableAsLogIndexFile
+                 (*options_->fs, fname, &wal_memtable_format); !ios.ok()) {
+      ROCKS_LOG_WARN(options_->info_log, "%s: %s",
+                     fname.c_str(), *ios.ToSSO());
+      return Status(ios);
+    }
+  }
   current_log_reader_.reset(
       new log::Reader(options_->info_log, std::move(file), &reporter_,
                       read_options_.verify_checksums_, log_file->LogNumber()));
-  if (options_->memtable_as_log_index) {
+  if (wal_memtable_format) {
     current_log_reader_->InitSetMemTableAsLogIndex(*options_->fs);
   }
   return Status::OK();
diff --git a/db/version_set.cc b/db/version_set.cc
index 38a7fcfe79..573c57e970 100644
--- a/db/version_set.cc
+++ b/db/version_set.cc
@@ -109,9 +109,28 @@ namespace {
 #define __builtin_prefetch(ptr)
 #endif
 
+inline uint64_t HostPrefixCache(const ParsedInternalKey& ikey) {
+  if (LIKELY(ikey.user_key.size_ >= 8)) {
+    uint64_t data = GetUnalignedU64(ikey.user_key.data_);
+    return NativeOfBigEndian64(data);
+  } else {
+   #if defined(__AVX512VL__) && defined(__AVX512BW__)
+    //#pragma message "__AVX512VL__ && __AVX512BW__, use _mm_maskz_loadu_epi8"
+    // load 128 bits, keep low 64 bits, discard high 64 bits
+    auto mask = _bzhi_u32(-1, uint32_t(ikey.user_key.size_));
+    auto m128 = _mm_maskz_loadu_epi8(mask, ikey.user_key.data_);
+    uint64_t data = (uint64_t)_mm_extract_epi64(m128, 0);
+   #else
+    uint64_t data = 0;
+    memcpy(&data, ikey.user_key.data_, ikey.user_key.size_);
+   #endif
+    return NativeOfBigEndian64(data);
+  }
+}
+
 template<class Cmp>
 size_t FindFileInRangeTmpl(Cmp cmp, const LevelFilesBrief& brief,
-                           Slice key, size_t lo, size_t hi) {
+                           const ParsedInternalKey& key, size_t lo, size_t hi) {
   const uint64_t* pxcache = brief.prefix_cache;
   const uint64_t  key_prefix = HostPrefixCache(key);
   const FdWithKeyRange* a = brief.files;
@@ -141,7 +160,7 @@ size_t FindFileInRangeTmpl(Cmp cmp, const LevelFilesBrief& brief,
 
 static
 size_t FindFileInRangeTmpl(FallbackVirtCmp cmp, const LevelFilesBrief& brief,
-                           Slice key, size_t lo, size_t hi) {
+                           const ParsedInternalKey& key, size_t lo, size_t hi) {
   const FdWithKeyRange* a = brief.files;
   while (lo < hi) {
     size_t mid = (lo + hi) / 2;
@@ -157,7 +176,7 @@ template<class Cmp>
 static ROCKSDB_FLATTEN
 int FindFileInRangeInst(const InternalKeyComparator* icmp,
                         const LevelFilesBrief& brief,
-                        Slice key, size_t lo, size_t hi) {
+                        const ParsedInternalKey& key, size_t lo, size_t hi) {
   return (int)FindFileInRangeTmpl(Cmp{icmp}, brief, key, lo, hi);
 }
 
@@ -167,7 +186,7 @@ int FindFileInRangeInst(const InternalKeyComparator* icmp,
 __attribute_noinline__
 #endif
 int FindFileInRange(const InternalKeyComparator& icmp,
-                    const LevelFilesBrief& file_level, const Slice& key,
+                    const LevelFilesBrief& file_level, const ParsedInternalKey& key,
                     uint32_t left, uint32_t right) {
 #ifdef TOPLINGDB_NO_OPT_FindFileInRange
   #pragma message "TOPLINGDB_NO_OPT_FindFileInRange is defined, intended for benchmark baseline"
@@ -236,217 +255,6 @@ Status OverlapWithIterator(const Comparator* ucmp,
 // levels. Therefore we are guaranteed that if we find data
 // in a smaller level, later levels are irrelevant (unless we
 // are MergeInProgress).
-template<class UKCmp, class IKCmp>
-class FilePicker {
-  __always_inline
-  int FindFileInRange(const InternalKeyComparator& icmp,
-                      const LevelFilesBrief& file_level, const Slice& key,
-                      size_t left, size_t right) {
-    return (int)FindFileInRangeTmpl(IKCmp{&icmp}, file_level, key, left, right);
-  }
- public:
-  FilePicker(const Slice& user_key, const Slice& ikey,
-             autovector<LevelFilesBrief>* file_levels, unsigned int num_levels,
-             FileIndexer* file_indexer, const Comparator* user_comparator,
-             const InternalKeyComparator* internal_comparator)
-      : num_levels_(num_levels),
-        curr_level_(static_cast<unsigned int>(-1)),
-        returned_file_level_(static_cast<unsigned int>(-1)),
-        hit_file_level_(static_cast<unsigned int>(-1)),
-        search_left_bound_(0),
-        search_right_bound_(FileIndexer::kLevelMaxIndex),
-        level_files_brief_(file_levels),
-        is_hit_file_last_in_level_(false),
-        curr_file_level_(nullptr),
-        user_key_(user_key),
-        ikey_(ikey),
-        file_indexer_(file_indexer),
-        user_comparator_(user_comparator),
-        internal_comparator_(internal_comparator) {
-    // Setup member variables to search first level.
-    search_ended_ = !PrepareNextLevel();
-    if (!search_ended_) {
-      // Prefetch Level 0 table data to avoid cache miss if possible.
-      for (unsigned int i = 0; i < (*level_files_brief_)[0].num_files; ++i) {
-        auto* r = (*level_files_brief_)[0].files[i].fd.table_reader;
-        if (r) {
-          r->Prepare(ikey);
-        }
-      }
-    }
-  }
-
-  int GetCurrentLevel() const { return curr_level_; }
-
-  FdWithKeyRange* GetNextFile() {
-    UKCmp cmp{user_comparator_};
-    while (!search_ended_) {  // Loops over different levels.
-      while (curr_index_in_curr_level_ < curr_file_level_->num_files) {
-        // Loops over all files in current level.
-        FdWithKeyRange* f = &curr_file_level_->files[curr_index_in_curr_level_];
-        hit_file_level_ = curr_level_;
-        is_hit_file_last_in_level_ =
-            curr_index_in_curr_level_ == curr_file_level_->num_files - 1;
-        int cmp_largest = -1;
-
-        // Do key range filtering of files or/and fractional cascading if:
-        // (1) not all the files are in level 0, or
-        // (2) there are more than 3 current level files
-        // If there are only 3 or less current level files in the system, we
-        // skip the key range filtering. In this case, more likely, the system
-        // is highly tuned to minimize number of tables queried by each query,
-        // so it is unlikely that key range filtering is more efficient than
-        // querying the files.
-        if (num_levels_ > 1 || curr_file_level_->num_files > 3) {
-          // Check if key is within a file's range. If search left bound and
-          // right bound point to the same find, we are sure key falls in
-          // range.
-          assert(curr_level_ == 0 ||
-                 curr_index_in_curr_level_ == start_index_in_curr_level_ ||
-                 cmp(user_key_, ExtractUserKey(f->smallest_key)) <= 0);
-
-          int cmp_smallest = cmp(user_key_, ExtractUserKey(f->smallest_key));
-          if (cmp_smallest >= 0) {
-            cmp_largest = cmp(user_key_, ExtractUserKey(f->largest_key));
-          }
-
-          // Setup file search bound for the next level based on the
-          // comparison results
-          if (curr_level_ > 0) {
-            file_indexer_->GetNextLevelIndex(
-                curr_level_, curr_index_in_curr_level_, cmp_smallest,
-                cmp_largest, &search_left_bound_, &search_right_bound_);
-          }
-          // Key falls out of current file's range
-          if (cmp_smallest < 0 || cmp_largest > 0) {
-            if (curr_level_ == 0) {
-              ++curr_index_in_curr_level_;
-              continue;
-            } else {
-              // Search next level.
-              break;
-            }
-          }
-        }
-
-        returned_file_level_ = curr_level_;
-        if (curr_level_ > 0 && cmp_largest < 0) {
-          // No more files to search in this level.
-          search_ended_ = !PrepareNextLevel();
-        } else {
-          ++curr_index_in_curr_level_;
-        }
-        return f;
-      }
-      // Start searching next level.
-      search_ended_ = !PrepareNextLevel();
-    }
-    // Search ended.
-    return nullptr;
-  }
-
-  // getter for current file level
-  // for GET_HIT_L0, GET_HIT_L1 & GET_HIT_L2_AND_UP counts
-  unsigned int GetHitFileLevel() { return hit_file_level_; }
-
-  // Returns true if the most recent "hit file" (i.e., one returned by
-  // GetNextFile()) is at the last index in its level.
-  bool IsHitFileLastInLevel() { return is_hit_file_last_in_level_; }
-
- private:
-  unsigned int num_levels_;
-  unsigned int curr_level_;
-  unsigned int returned_file_level_;
-  unsigned int hit_file_level_;
-  int32_t search_left_bound_;
-  int32_t search_right_bound_;
-  autovector<LevelFilesBrief>* level_files_brief_;
-  bool search_ended_;
-  bool is_hit_file_last_in_level_;
-  LevelFilesBrief* curr_file_level_;
-  unsigned int curr_index_in_curr_level_;
-  unsigned int start_index_in_curr_level_;
-  Slice user_key_;
-  Slice ikey_;
-  FileIndexer* file_indexer_;
-  const Comparator* user_comparator_;
-  const InternalKeyComparator* internal_comparator_;
-
-  // Setup local variables to search next level.
-  // Returns false if there are no more levels to search.
-  bool PrepareNextLevel() {
-    curr_level_++;
-    while (curr_level_ < num_levels_) {
-      curr_file_level_ = &(*level_files_brief_)[curr_level_];
-      if (curr_file_level_->num_files == 0) {
-        // When current level is empty, the search bound generated from upper
-        // level must be [0, -1] or [0, FileIndexer::kLevelMaxIndex] if it is
-        // also empty.
-        assert(search_left_bound_ == 0);
-        assert(search_right_bound_ == -1 ||
-               search_right_bound_ == FileIndexer::kLevelMaxIndex);
-        // Since current level is empty, it will need to search all files in
-        // the next level
-        search_left_bound_ = 0;
-        search_right_bound_ = FileIndexer::kLevelMaxIndex;
-        curr_level_++;
-        continue;
-      }
-
-      // Some files may overlap each other. We find
-      // all files that overlap user_key and process them in order from
-      // newest to oldest. In the context of merge-operator, this can occur at
-      // any level. Otherwise, it only occurs at Level-0 (since Put/Deletes
-      // are always compacted into a single entry).
-      int32_t start_index;
-      if (curr_level_ == 0) {
-        // On Level-0, we read through all files to check for overlap.
-        start_index = 0;
-      } else {
-        // On Level-n (n>=1), files are sorted. Binary search to find the
-        // earliest file whose largest key >= ikey. Search left bound and
-        // right bound are used to narrow the range.
-        if (search_left_bound_ <= search_right_bound_) {
-          if (search_right_bound_ == FileIndexer::kLevelMaxIndex) {
-            search_right_bound_ =
-                static_cast<int32_t>(curr_file_level_->num_files) - 1;
-          }
-          // `search_right_bound_` is an inclusive upper-bound, but since it was
-          // determined based on user key, it is still possible the lookup key
-          // falls to the right of `search_right_bound_`'s corresponding file.
-          // So, pass a limit one higher, which allows us to detect this case.
-          start_index =
-              FindFileInRange(*internal_comparator_, *curr_file_level_, ikey_,
-                              static_cast<uint32_t>(search_left_bound_),
-                              static_cast<uint32_t>(search_right_bound_) + 1);
-          if (start_index == search_right_bound_ + 1) {
-            // `ikey_` comes after `search_right_bound_`. The lookup key does
-            // not exist on this level, so let's skip this level and do a full
-            // binary search on the next level.
-            search_left_bound_ = 0;
-            search_right_bound_ = FileIndexer::kLevelMaxIndex;
-            curr_level_++;
-            continue;
-          }
-        } else {
-          // search_left_bound > search_right_bound, key does not exist in
-          // this level. Since no comparison is done in this level, it will
-          // need to search all files in the next level.
-          search_left_bound_ = 0;
-          search_right_bound_ = FileIndexer::kLevelMaxIndex;
-          curr_level_++;
-          continue;
-        }
-      }
-      start_index_in_curr_level_ = start_index;
-      curr_index_in_curr_level_ = start_index;
-
-      return true;
-    }
-    // curr_level_ = num_levels_. So, no more levels to search.
-    return false;
-  }
-};
 }  // anonymous namespace
 
 class FilePickerMultiGet {
@@ -494,7 +302,7 @@ class FilePickerMultiGet {
         auto* r = (*level_files_brief_)[0].files[i].fd.table_reader;
         if (r) {
           for (auto iter = range_.begin(); iter != range_.end(); ++iter) {
-            r->Prepare(iter->ikey);
+            r->PreparePIK(iter->ikey);
           }
         }
       }
@@ -877,7 +685,7 @@ class FilePickerMultiGet {
             // key falls to the right of `search_right_bound_`'s corresponding
             // file. So, pass a limit one higher, which allows us to detect this
             // case.
-            Slice& ikey = mget_iter->ikey;
+            auto& ikey = mget_iter->ikey;
             start_index = FindFileInRange(
                 *internal_comparator_, *curr_file_level_, ikey,
                 static_cast<uint32_t>(fp_ctx.search_left_bound),
@@ -947,6 +755,12 @@ Version::~Version() {
 
 int FindFile(const InternalKeyComparator& icmp,
              const LevelFilesBrief& file_level, const Slice& key) {
+  return FindFileInRange(icmp, file_level, ParsedInternalKey(key), 0,
+                         static_cast<uint32_t>(file_level.num_files));
+}
+
+int FindFile(const InternalKeyComparator& icmp,
+             const LevelFilesBrief& file_level, const ParsedInternalKey& key) {
   return FindFileInRange(icmp, file_level, key, 0,
                          static_cast<uint32_t>(file_level.num_files));
 }
@@ -1209,12 +1023,11 @@ class LevelIterator final : public InternalIterator {
       iw->prepare_and_get_value_ = ForgeFuncPtr(this,
                                      &LevelIterator::PrepareAndGetValue);
     } else {
-      iw->work_iter_ = file_iter_.iter();
-      iw->value_iter_ = file_iter_.iter();
-      iw->next_and_get_result_ = ForgeFuncPtr(file_iter_.iter(),
-                                  &InternalIterator::NextAndGetResult);
-      iw->prepare_and_get_value_ = ForgeFuncPtr(file_iter_.iter(),
-                                  &InternalIterator::PrepareAndGetValue);
+      auto fi = file_iter_.iter();
+      iw->work_iter_ = fi;
+      iw->value_iter_ = fi;
+      iw->next_and_get_result_ = ForgeFuncPtr(fi, &InternalIterator::NextAndGetResult);
+      iw->prepare_and_get_value_ = ForgeFuncPtr(fi, &InternalIterator::PrepareAndGetValue);
     }
     retry_already_goes_invalid_ = false;
   }
@@ -2518,14 +2331,19 @@ Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
     if (IsForwardBytewiseComparator(user_comparator())) {
       m_get = ExtractFuncPtr<GetFP>(this, &Version::GetInst
         <ForwardBytewiseCompareUserKeyNoTS, BytewiseCompareInternalKey>);
+      m_get_no_watch = ExtractFuncPtr<GetFP>(this, &Version::GetInst
+        <ForwardBytewiseCompareUserKeyNoTS, BytewiseCompareInternalKey, FakePerfStepTimer, FakeStopWatch>);
     }
     else if (IsReverseBytewiseComparator(user_comparator())) {
       m_get = ExtractFuncPtr<GetFP>(this, &Version::GetInst
         <ReverseBytewiseCompareUserKeyNoTS, RevBytewiseCompareInternalKey>);
+      m_get_no_watch = ExtractFuncPtr<GetFP>(this, &Version::GetInst
+        <ReverseBytewiseCompareUserKeyNoTS, RevBytewiseCompareInternalKey, FakePerfStepTimer, FakeStopWatch>);
     }
     else {
       m_get = ExtractFuncPtr<GetFP>(this, &Version::GetInst
         <VirtualFunctionCompareUserKeyNoTS, FallbackVirtCmp>);
+      m_get_no_watch = m_get; // do not instantiate more
     }
   }
 }
@@ -2659,9 +2477,9 @@ void Version::MultiGetBlob(
   }
 }
 
-template<class UKCmp, class IKCmp>
+template<class UKCmp, class IKCmp, class PerfStepTimer, class StopWatchNano>
 ROCKSDB_FLATTEN
-void Version::GetInst(const ReadOptions& read_options, const LookupKey& k,
+void Version::GetInst(const ReadOptions& read_options, const ParsedInternalKey& ikey,
                   PinnableSlice* value, PinnableWideColumns* columns,
                   std::string* timestamp, Status* status,
                   MergeContext* merge_context,
@@ -2669,8 +2487,7 @@ void Version::GetInst(const ReadOptions& read_options, const LookupKey& k,
                   PinnedIteratorsManager* pinned_iters_mgr, bool* value_found,
                   bool* key_exists, SequenceNumber* seq, ReadCallback* callback,
                   bool* is_blob, bool do_merge) {
-  Slice ikey = k.internal_key();
-  Slice user_key = k.user_key();
+  const Slice& user_key = ikey.user_key;
 
   assert(status->ok() || status->IsMergeInProgress());
 
@@ -2680,10 +2497,18 @@ void Version::GetInst(const ReadOptions& read_options, const LookupKey& k,
   }
 
   uint64_t tracing_get_id = BlockCacheTraceHelper::kReservedGetId;
+#if defined(TOPLINGDB_WITH_FABRICATED_COMPLEXITY)
   if (vset_ && vset_->block_cache_tracer_ &&
       vset_->block_cache_tracer_->is_tracing_enabled()) {
     tracing_get_id = vset_->block_cache_tracer_->NextGetId();
   }
+#endif
+#if !defined(TOPLINGDB_WITH_TIMESTAMP)
+  timestamp = nullptr; // tell compiler it is always null
+#endif
+#if !defined(TOPLINGDB_WITH_WIDE_COLUMNS)
+  columns = nullptr; // tell compiler it is always null
+#endif
 
   // Note: the old StackableDB-based BlobDB passes in
   // GetImplOptions::is_blob_index; for the integrated BlobDB implementation, we
@@ -2707,45 +2532,172 @@ void Version::GetInst(const ReadOptions& read_options, const LookupKey& k,
     pinned_iters_mgr->StartPinning();
   }
 
-  FilePicker<UKCmp, IKCmp> fp(user_key, ikey, &storage_info_.level_files_brief_,
-                storage_info_.num_non_empty_levels_,
-                &storage_info_.file_indexer_, user_comparator(),
-                internal_comparator());
-  FdWithKeyRange* f = fp.GetNextFile();
+// FilePicker is a negative optimization, revert it!
 
-  while (f != nullptr) {
+#if defined(ROCKSDB_UNIT_TEST)
+// Prefetch Level 0 table data to avoid cache miss if possible.
+if (storage_info_.num_non_empty_levels_ > 0 &&
+    storage_info_.level_files_brief_[0].num_files > 0) {
+  for (size_t i = 0; i < storage_info_.level_files_brief_[0].num_files; ++i) {
+    if (auto r = storage_info_.level_files_brief_[0].files[i].fd.table_reader) {
+      r->PreparePIK(ikey);
+    }
+  }
+}
+#endif
+int32_t search_left_bound = 0;
+int32_t search_right_bound = FileIndexer::kLevelMaxIndex;
+for (int curr_level = 0; curr_level < storage_info_.num_non_empty_levels_; curr_level++) {
+  LevelFilesBrief* curr_file_level = &storage_info_.level_files_brief_[curr_level];
+  if (curr_file_level->num_files == 0) {
+    // When current level is empty, the search bound generated from upper
+    // level must be [0, -1] or [0, FileIndexer::kLevelMaxIndex] if it is
+    // also empty.
+    assert(search_left_bound == 0);
+    assert(search_right_bound == -1 ||
+           search_right_bound == FileIndexer::kLevelMaxIndex);
+    // Since current level is empty, it will need to search all files in
+    // the next level
+    search_left_bound = 0;
+    search_right_bound = FileIndexer::kLevelMaxIndex;
+    continue;
+  }
+
+  // Some files may overlap each other. We find
+  // all files that overlap user_key and process them in order from
+  // newest to oldest. In the context of merge-operator, this can occur at
+  // any level. Otherwise, it only occurs at Level-0 (since Put/Deletes
+  // are always compacted into a single entry).
+  int32_t start_index;
+  if (curr_level == 0) {
+    // On Level-0, we read through all files to check for overlap.
+      start_index = 0;
+  } else {
+    // On Level-n (n>=1), files are sorted. Binary search to find the
+    // earliest file whose largest key >= ikey. Search left bound and
+    // right bound are used to narrow the range.
+    if (search_left_bound <= search_right_bound) {
+      if (search_right_bound == FileIndexer::kLevelMaxIndex) {
+        search_right_bound =
+            static_cast<int32_t>(curr_file_level->num_files) - 1;
+      }
+      // `search_right_bound` is an inclusive upper-bound, but since it was
+      // determined based on user key, it is still possible the lookup key
+      // falls to the right of `search_right_bound`'s corresponding file.
+      // So, pass a limit one higher, which allows us to detect this case.
+      start_index = static_cast<int32_t>(FindFileInRangeTmpl(
+            IKCmp{internal_comparator()}, *curr_file_level, ikey,
+            static_cast<uint32_t>(search_left_bound),
+            static_cast<uint32_t>(search_right_bound) + 1));
+      if (start_index == search_right_bound + 1) {
+        // `ikey` comes after `search_right_bound`. The lookup key does
+        // not exist on this level, so let's skip this level and do a full
+        // binary search on the next level.
+        search_left_bound = 0;
+        search_right_bound = FileIndexer::kLevelMaxIndex;
+        continue;
+      }
+    } else {
+      // search_left_bound > search_right_bound, key does not exist in
+      // this level. Since no comparison is done in this level, it will
+      // need to search all files in the next level.
+      search_left_bound = 0;
+      search_right_bound = FileIndexer::kLevelMaxIndex;
+      continue;
+    }
+  }
+  unsigned int start_index_in_curr_level __attribute__((unused)) = start_index;
+  unsigned int curr_index_in_curr_level = start_index;
+  while (curr_index_in_curr_level < curr_file_level->num_files) {
+    FdWithKeyRange* f = &curr_file_level->files[curr_index_in_curr_level];
+    int hit_file_level = curr_level;
+    bool is_hit_file_last_in_level =
+        curr_index_in_curr_level == curr_file_level->num_files - 1;
+    (void)is_hit_file_last_in_level;
+    int cmp_largest = -1;
+
+    // Do key range filtering of files or/and fractional cascading if:
+    // (1) not all the files are in level 0, or
+    // (2) there are more than 3 current level files
+    // If there are only 3 or less current level files in the system, we
+    // skip the key range filtering. In this case, more likely, the system
+    // is highly tuned to minimize number of tables queried by each query,
+    // so it is unlikely that key range filtering is more efficient than
+    // querying the files.
+    if (storage_info_.num_non_empty_levels_ > 1 || curr_file_level->num_files > 3) {
+      // Check if key is within a file's range. If search left bound and
+      // right bound point to the same find, we are sure key falls in
+      // range.
+      UKCmp ucmp{user_comparator()};
+      assert(curr_level == 0 ||
+              curr_index_in_curr_level == start_index_in_curr_level ||
+              ucmp(ikey.user_key, ExtractUserKey(f->smallest_key)) <= 0);
+
+      int cmp_smallest = ucmp(ikey.user_key, ExtractUserKey(f->smallest_key));
+      if (cmp_smallest >= 0) {
+        cmp_largest = ucmp(ikey.user_key, ExtractUserKey(f->largest_key));
+      }
+
+      // Setup file search bound for the next level based on the
+      // comparison results
+      if (curr_level > 0) {
+        storage_info_.file_indexer_.GetNextLevelIndex(
+            curr_level, curr_index_in_curr_level, cmp_smallest,
+            cmp_largest, &search_left_bound, &search_right_bound);
+      }
+      // Key falls out of current file's range
+      if (cmp_smallest < 0 || cmp_largest > 0) {
+        if (curr_level == 0) {
+          ++curr_index_in_curr_level;
+          continue;
+        } else {
+          // Search next level.
+          break;
+        }
+      }
+    }
+
+    // File passed filtering, process it
     if (*max_covering_tombstone_seq > 0) {
       // The remaining files we look at will only contain covered keys, so we
       // stop here.
-      break;
+      goto search_complete;
     }
     if (get_context.sample()) {
       sample_file_read_inc(f->file_metadata);
     }
 
     bool timer_enabled =
+        !std::is_same_v<PerfStepTimer, FakePerfStepTimer> &&
         perf_level >= PerfLevel::kEnableTimeExceptForMutex &&
         get_perf_context()->per_level_perf_context_enabled;
     StopWatchNano timer(clock_, timer_enabled /* auto_start */);
-    *status = table_cache_->Get(
+    Status s2 = table_cache_->Get(
         read_options, *internal_comparator(), *f->file_metadata, ikey,
         &get_context, mutable_cf_options_.block_protection_bytes_per_key,
         mutable_cf_options_.prefix_extractor,
-        cfd_->internal_stats()->GetFileReadHist(fp.GetHitFileLevel()),
-        IsFilterSkipped(static_cast<int>(fp.GetHitFileLevel()),
-                        fp.IsHitFileLastInLevel()),
-        fp.GetHitFileLevel(), max_file_size_for_l0_meta_pin_);
+      #if defined(TOPLINGDB_WITH_FABRICATED_COMPLEXITY)
+        cfd_->internal_stats()->GetFileReadHist(hit_file_level),
+        IsFilterSkipped(static_cast<int>(hit_file_level),
+                        is_hit_file_last_in_level),
+      #else
+        nullptr,
+        false,
+      #endif
+        hit_file_level, max_file_size_for_l0_meta_pin_);
     // TODO: examine the behavior for corrupted key
     if (timer_enabled) {
       PERF_COUNTER_BY_LEVEL_ADD(get_from_table_nanos, timer.ElapsedNanos(),
-                                fp.GetHitFileLevel());
+                                hit_file_level);
     }
-    if (!status->ok()) {
+    if (UNLIKELY(!s2.ok())) {
+      *status = std::move(s2);
       if (db_statistics_ != nullptr) {
         get_context.ReportCounters();
       }
       return;
     }
+    status->SetAsOK();
 
     // report the counters before returning
     if (get_context.State() != GetContext::kNotFound &&
@@ -2761,16 +2713,16 @@ void Version::GetInst(const ReadOptions& read_options, const LookupKey& k,
         // TODO: update per-level perfcontext user_key_return_count for kMerge
         break;
       case GetContext::kFound:
-        if (fp.GetHitFileLevel() == 0) {
+        if (hit_file_level == 0) {
           RecordTick(db_statistics_, GET_HIT_L0);
-        } else if (fp.GetHitFileLevel() == 1) {
+        } else if (hit_file_level == 1) {
           RecordTick(db_statistics_, GET_HIT_L1);
-        } else if (fp.GetHitFileLevel() >= 2) {
+        } else if (hit_file_level >= 2) {
           RecordTick(db_statistics_, GET_HIT_L2_AND_UP);
         }
 
         PERF_COUNTER_BY_LEVEL_ADD(user_key_return_count, 1,
-                                  fp.GetHitFileLevel());
+                                  hit_file_level);
 
         if (is_blob_index && do_merge && (value || columns)) {
           Slice blob_index =
@@ -2821,8 +2773,16 @@ void Version::GetInst(const ReadOptions& read_options, const LookupKey& k,
         *status = Status::Corruption(Status::SubCode::kMergeOperatorFailed);
         return;
     }
-    f = fp.GetNextFile();
+
+    // Move to next file or level
+    if (curr_level > 0 && cmp_largest < 0) {
+      // No more files to search in this level.
+      break;
+    }
+    ++curr_index_in_curr_level;
   }
+}
+search_complete:
   if (db_statistics_ != nullptr) {
     get_context.ReportCounters();
   }
@@ -3071,7 +3031,7 @@ void Version::MultiGet(const ReadOptions& read_options, MultiGetRange* range,
   for (auto iter = range->begin(); s.ok() && iter != range->end(); ++iter) {
     GetContext& get_context = *iter->get_context;
     Status* status = iter->s;
-    Slice user_key = iter->lkey->user_key();
+    const Slice& user_key = iter->ikey.user_key;
 
     if (db_statistics_ != nullptr) {
       get_context.ReportCounters();
@@ -4901,7 +4861,7 @@ uint64_t VersionStorageInfo::NumLevelRawKV(int level) const {
 int VersionStorageInfo::FindFileInRange(int level, const Slice& key,
                                         uint32_t left, uint32_t right) const {
   return ROCKSDB_NAMESPACE::FindFileInRange(*internal_comparator_,
-            level_files_brief_[level], key, left, right);
+            level_files_brief_[level], ParsedInternalKey(key), left, right);
 }
 
 const char* VersionStorageInfo::LevelSummary(
@@ -7125,7 +7085,7 @@ VersionSet::ApproximateSizeTmpl(const SizeApproximationOptions& options,
 
     // identify the file position for start key
     const int idx_start =
-        (int)FindFileInRangeTmpl(cmp, files_brief, start, 0,
+        (int)FindFileInRangeTmpl(cmp, files_brief, ParsedInternalKey(start), 0,
                             static_cast<uint32_t>(files_brief.num_files - 1));
     assert(static_cast<size_t>(idx_start) < files_brief.num_files);
 
@@ -7133,7 +7093,7 @@ VersionSet::ApproximateSizeTmpl(const SizeApproximationOptions& options,
     int idx_end = idx_start;
     if (cmp(files_brief.files[idx_end].largest_key, end)) {
       idx_end =
-          (int)FindFileInRangeTmpl(cmp, files_brief, end, idx_start,
+          (int)FindFileInRangeTmpl(cmp, files_brief, ParsedInternalKey(end), idx_start,
                               static_cast<uint32_t>(files_brief.num_files - 1));
     }
     assert(idx_end >= idx_start &&
diff --git a/db/version_set.h b/db/version_set.h
index 647ae00fbf..2c4b3bf7e5 100644
--- a/db/version_set.h
+++ b/db/version_set.h
@@ -101,6 +101,9 @@ using VersionEditParams = VersionEdit;
 extern int FindFile(const InternalKeyComparator& icmp,
                     const LevelFilesBrief& file_level, const Slice& key);
 
+extern int FindFile(const InternalKeyComparator& icmp,
+                    const LevelFilesBrief& file_level, const ParsedInternalKey&);
+
 // Returns true iff some file in "files" overlaps the user key range
 // [*smallest,*largest].
 // smallest==nullptr represents a key smaller than all keys in the DB.
@@ -894,7 +897,9 @@ class Version {
   //    merge_context.operands_list and don't merge the operands
   // REQUIRES: lock is not held
   // REQUIRES: pinned_iters_mgr != nullptr
-  void Get(const ReadOptions& ro, const LookupKey& key, PinnableSlice* value,
+  template<class PerfStepTimer = ROCKSDB_NAMESPACE::PerfStepTimer,
+           class StopWatchNano = ROCKSDB_NAMESPACE::StopWatchNano>
+  void Get(const ReadOptions& ro, const ParsedInternalKey& key, PinnableSlice* value,
            PinnableWideColumns* columns, std::string* timestamp, Status* status,
            MergeContext* merge_context,
            SequenceNumber* max_covering_tombstone_seq,
@@ -903,14 +908,18 @@ class Version {
            SequenceNumber* seq = nullptr, ReadCallback* callback = nullptr,
            bool* is_blob = nullptr, bool do_merge = true)
   {
-    return m_get(this, ro, key, value, columns, timestamp, status,
+    auto f_get = std::is_same_v<StopWatchNano, FakeStopWatch>
+               ? m_get_no_watch : m_get;
+    return f_get(this, ro, key, value, columns, timestamp, status,
                  merge_context, max_covering_tombstone_seq, pinned_iters_mgr,
                  value_found, key_exists, seq, callback, is_blob, do_merge);
   }
 
 private:
-  template<class UKCmp, class IKCmp>
-  void GetInst(const ReadOptions&, const LookupKey& key, PinnableSlice* value,
+  template<class UKCmp, class IKCmp,
+           class PerfStepTimer = ROCKSDB_NAMESPACE::PerfStepTimer,
+           class StopWatchNano = ROCKSDB_NAMESPACE::StopWatchNano>
+  void GetInst(const ReadOptions&, const ParsedInternalKey&, PinnableSlice* value,
            PinnableWideColumns* columns, std::string* timestamp, Status* status,
            MergeContext* merge_context,
            SequenceNumber* max_covering_tombstone_seq,
@@ -920,7 +929,7 @@ class Version {
            bool* is_blob, bool do_merge);
 
   void (*m_get)(Version*,
-           const ReadOptions&, const LookupKey& key, PinnableSlice* value,
+           const ReadOptions&, const ParsedInternalKey&, PinnableSlice* value,
            PinnableWideColumns* columns, std::string* timestamp, Status* status,
            MergeContext* merge_context,
            SequenceNumber* max_covering_tombstone_seq,
@@ -928,6 +937,7 @@ class Version {
            bool* value_found, bool* key_exists,
            SequenceNumber* seq, ReadCallback* callback,
            bool* is_blob, bool do_merge);
+  decltype(m_get) m_get_no_watch;
 
 public:
 
diff --git a/db/version_set_sync_and_async.h b/db/version_set_sync_and_async.h
index 75776b620c..ec107252c3 100644
--- a/db/version_set_sync_and_async.h
+++ b/db/version_set_sync_and_async.h
@@ -145,7 +145,7 @@ DEFINE_SYNC_AND_ASYNC(Status, Version::MultiGetFromSST)
         continue;
       case GetContext::kCorrupt:
         *status =
-            Status::Corruption("corrupted key for ", iter->lkey->user_key());
+            Status::Corruption("corrupted key for ", iter->ikey.user_key);
         file_range.MarkKeyDone(iter);
         continue;
       case GetContext::kUnexpectedBlobIndex:
diff --git a/db/wal_manager.cc b/db/wal_manager.cc
index f3ff882325..66e1fc7cde 100644
--- a/db/wal_manager.cc
+++ b/db/wal_manager.cc
@@ -485,9 +485,18 @@ Status WalManager::ReadFirstLine(const std::string& fname,
   reporter.fname = fname.c_str();
   reporter.status = &status;
   reporter.ignore_error = !db_options_.paranoid_checks;
+  bool wal_memtable_format = db_options_.memtable_as_log_index;
+  if (db_options_.check_wal_format) {
+    if (IOStatus ios = log::Reader::IsMemTableAsLogIndexFile
+              (*db_options_.fs, fname, &wal_memtable_format); !ios.ok()) {
+      ROCKS_LOG_WARN(db_options_.info_log, "%s: %s",
+                     fname.c_str(), *ios.ToSSO());
+      return Status(ios);
+    }
+  }
   log::Reader reader(db_options_.info_log, std::move(file_reader), &reporter,
                      true /*checksum*/, number);
-  if (db_options_.memtable_as_log_index) {
+  if (wal_memtable_format) {
     reader.InitSetMemTableAsLogIndex(*db_options_.fs);
   }
   std::string scratch;
diff --git a/db_bench.sh b/db_bench.sh
index 3f0c11b30a..4e0fbc5244 100644
--- a/db_bench.sh
+++ b/db_bench.sh
@@ -12,20 +12,23 @@ export ROCKSDB_KICK_OUT_OPTIONS_FILE=1
 ulimit -n 100000
 args=(
     -json sideplugin/rockside/sample-conf/db_bench_enterprise.yaml
-    -num=10000000 -key_size=8
-    -value_size=2000
+   #-num=10000000
+    -key_size=8
+   #-value_size=2000
     -batch_size=100
    #-benchmarks=fillseq,compact,nextwithkey,nextwithkey,nextwithkey,nextwithkey,nextwithkey,readseq,readseq,readseq,readseq,readseq
     -benchmarks=fillrandom,readrandom
-   #-benchmarks=fillseq,compact
-   #-benchmarks=compact -use_existing_db
+   #-benchmarks=fillseq,compact,readrandom # rand DB::Get < 100 nanosec
+   #-benchmarks=compact
    #-benchmarks=readrandom
    #-benchmarks=readseq
    #-benchmarks=nextwithkey
    #-wkey_file=${HOME}/wikipedia-title-seq.txt
    #-rkey_file=${HOME}/wikipedia-title-seq.txt
    #-threads=8
-    -scan_omit_key -scan_omit_value
+   #-use_existing_db
+    -scan_omit_key
+    -scan_omit_value
     -enable_zero_copy # ToplingDB specific, for point search by Get/MultiGet
 )
 ./db_bench ${args[@]} "$@"
diff --git a/easy_db_bench.sh b/easy_db_bench.sh
new file mode 100644
index 0000000000..e24cbfe743
--- /dev/null
+++ b/easy_db_bench.sh
@@ -0,0 +1,34 @@
+#!/bin/bash -ex
+
+#rm -rf /dev/shm/db_bench_enterprise
+#rm -rf /tmp/db_bench_enterprise
+mkdir -p /dev/shm/db_bench_enterprise
+#mkdir -p /tmp/db_bench_enterprise
+cp sideplugin/rockside/src/topling/web/{index.html,style.css} /dev/shm/db_bench_enterprise/
+
+export TOPLINGDB_GetContext_sampling=kNone
+export ROCKSDB_KICK_OUT_OPTIONS_FILE=1
+export TOPLINGDB_EASY_MIGRATE_CONF=sideplugin/rockside/sample-conf/db_bench_enterprise.yaml
+#export PRINT_NOT_FOUND=true
+ulimit -n 100000
+args=(
+   #-num=10000000
+    -key_size=8
+   #-value_size=2000
+    -batch_size=100
+   #-benchmarks=fillseq,compact,nextwithkey,nextwithkey,nextwithkey,nextwithkey,nextwithkey,readseq,readseq,readseq,readseq,readseq
+    -benchmarks=fillrandom,readrandom
+   #-benchmarks=fillseq,compact,readrandom # rand DB::Get < 100 nanosec
+   #-benchmarks=compact
+   #-benchmarks=readrandom
+   #-benchmarks=readseq
+   #-benchmarks=nextwithkey
+   #-wkey_file=${HOME}/wikipedia-title-seq.txt
+   #-rkey_file=${HOME}/wikipedia-title-seq.txt
+   #-threads=8
+   #-use_existing_db
+    -scan_omit_key
+    -scan_omit_value
+    -enable_zero_copy # ToplingDB specific, for point search by Get/MultiGet
+)
+./db_bench ${args[@]} "$@"
diff --git a/include/rocksdb/c.h b/include/rocksdb/c.h
index 263b40491a..2ed5667240 100644
--- a/include/rocksdb/c.h
+++ b/include/rocksdb/c.h
@@ -67,6 +67,7 @@ extern "C" {
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <stdio.h>
 
 /* Exported types */
 
@@ -143,6 +144,7 @@ typedef struct rocksdb_statistics_histogram_data_t
     rocksdb_statistics_histogram_data_t;
 typedef struct rocksdb_wait_for_compact_options_t
     rocksdb_wait_for_compact_options_t;
+typedef struct rocksdb_stdstr_t rocksdb_stdstr_t;
 
 #if !defined(ROCKSDB_C_API_IMPLEMENTATION)
 struct rocksdb_slice_t {
@@ -1941,6 +1943,8 @@ extern ROCKSDB_LIBRARY_API_WEAK void rocksdb_readoptions_start_pin(
     rocksdb_readoptions_t*);
 extern ROCKSDB_LIBRARY_API_WEAK void rocksdb_readoptions_finish_pin(
     rocksdb_readoptions_t*);
+extern ROCKSDB_LIBRARY_API_WEAK unsigned char
+rocksdb_readoptions_is_in_pinning_section(rocksdb_readoptions_t*);
 extern ROCKSDB_LIBRARY_API_WEAK void rocksdb_readoptions_set_async_queue_depth(
     rocksdb_readoptions_t*, size_t);
 extern ROCKSDB_LIBRARY_API_WEAK size_t rocksdb_readoptions_get_async_queue_depth(
@@ -2970,6 +2974,9 @@ extern ROCKSDB_LIBRARY_API void rocksdb_pinnableslice_destroy(
 extern ROCKSDB_LIBRARY_API const char* rocksdb_pinnableslice_value(
     const rocksdb_pinnableslice_t* t, size_t* vlen);
 
+extern ROCKSDB_LIBRARY_API rocksdb_stdstr_t* rocksdb_stdstr_create(const char* str, size_t len);
+extern ROCKSDB_LIBRARY_API void rocksdb_stdstr_destroy(rocksdb_stdstr_t* v);
+
 extern ROCKSDB_LIBRARY_API rocksdb_memory_consumers_t*
 rocksdb_memory_consumers_create(void);
 extern ROCKSDB_LIBRARY_API void rocksdb_memory_consumers_add_db(
@@ -3083,6 +3090,9 @@ extern ROCKSDB_LIBRARY_API_WEAK side_plugin_repo_t* side_plugin_repo_create(void
 extern ROCKSDB_LIBRARY_API_WEAK void side_plugin_repo_import_auto_file
 (side_plugin_repo_t*, const char* fname, char** errptr);
 
+extern ROCKSDB_LIBRARY_API_WEAK void
+side_plugin_repo_import(side_plugin_repo_t*, const char* json_str, char** errptr);
+
 extern ROCKSDB_LIBRARY_API_WEAK rocksdb_t*
 side_plugin_repo_open(side_plugin_repo_t*, rocksdb_column_family_handle_t***,
                       size_t* num_cf, char** errptr);
@@ -3102,10 +3112,120 @@ side_plugin_repo_get_cf_options(side_plugin_repo_t*, const char* name, char** er
 extern ROCKSDB_LIBRARY_API_WEAK void
 side_plugin_repo_put_cf_options(side_plugin_repo_t*, const char* name, rocksdb_options_t*);
 
+extern ROCKSDB_LIBRARY_API_WEAK bool
+side_plugin_db_options_update_from(rocksdb_options_t*, const side_plugin_repo_t*, const char* name);
+
+extern ROCKSDB_LIBRARY_API_WEAK bool
+side_plugin_cf_options_update_from(rocksdb_options_t*, const side_plugin_repo_t*, const char* name);
+
 extern ROCKSDB_LIBRARY_API_WEAK void side_plugin_repo_close_all(side_plugin_repo_t*);
 
+extern ROCKSDB_LIBRARY_API_WEAK void side_plugin_repo_forget_db(side_plugin_repo_t*, rocksdb_t*);
+
 extern ROCKSDB_LIBRARY_API_WEAK const char* rocksdb_get_name(rocksdb_t*);
 
+struct side_plugin_ex_vtab_t {
+    // serialize_request == NULL means serde(all the 4) are not supported
+    void (*  serialize_request )(FILE*, const void* obj);
+    void (*deserialize_request )(FILE*,       void* obj);
+    void (*  serialize_response)(FILE*, const void* obj);
+    void (*deserialize_response)(FILE*,       void* obj);
+
+    // web_view   == NULL means web view and update are not supported
+    // web_update == NULL means web only     update is  not supported
+    rocksdb_stdstr_t* (*web_view)(const void* obj, const char* dump_options_json, const side_plugin_repo_t*);
+    void (*web_update)(void* obj, const char* dump_options_json, const char* body_json, const side_plugin_repo_t*);
+};
+#if !defined(__cplusplus)
+typedef struct side_plugin_ex_vtab_t side_plugin_ex_vtab_t;
+#endif
+
+typedef const rocksdb_comparator_t*
+(*rocksdb_comparator_creator_t)
+(const char* strjson, const side_plugin_repo_t* repo);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_register_comparator
+(const char* name, rocksdb_comparator_creator_t, const side_plugin_ex_vtab_t*);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_unregister_comparator(const char* name);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void* side_plugin_comparator_get_state(const rocksdb_comparator_t*);
+
+typedef rocksdb_mergeoperator_t*
+(*rocksdb_mergeoperator_creator_t)
+(const char* strjson, const side_plugin_repo_t* repo);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_register_merge_operator
+(const char* name, rocksdb_mergeoperator_creator_t, const side_plugin_ex_vtab_t*);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_unregister_merge_operator(const char* name);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void* side_plugin_mergeoperator_get_state(const rocksdb_mergeoperator_t*);
+
+typedef rocksdb_compactionfilterfactory_t*
+(*rocksdb_compactionfilterfactory_creator_t)
+(const char* strjson, const side_plugin_repo_t* repo);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_register_compaction_filter_factory
+(const char* name, rocksdb_compactionfilterfactory_creator_t, const side_plugin_ex_vtab_t*);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_unregister_compaction_filter_factory(const char* name);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void* side_plugin_compactionfilterfactory_get_state(const rocksdb_compactionfilterfactory_t*);
+
+typedef rocksdb_slicetransform_t*
+(*rocksdb_slicetransform_creator_t)
+(const char* strjson, const side_plugin_repo_t* repo);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_register_slicetransform
+(const char* name, rocksdb_slicetransform_creator_t, const side_plugin_ex_vtab_t*);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_unregister_slicetransform(const char* name);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void* side_plugin_slicetransform_get_state(const rocksdb_slicetransform_t*);
+
+typedef rocksdb_filterpolicy_t*
+(*rocksdb_filterpolicy_creator_t)
+(const char* strjson, const side_plugin_repo_t* repo);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_register_filterpolicy
+(const char* name, rocksdb_filterpolicy_creator_t, const side_plugin_ex_vtab_t*);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_unregister_filterpolicy(const char* name);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void* side_plugin_filterpolicy_get_state(const rocksdb_filterpolicy_t*);
+
+#if 0 // rocksdb c api does not support custom rate limiter
+typedef rocksdb_ratelimiter_t*
+(*rocksdb_ratelimiter_creator_t)
+(const char* strjson, const side_plugin_repo_t* repo);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_register_ratelimiter
+(const char* name, rocksdb_ratelimiter_creator_t, const side_plugin_ex_vtab_t*);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void side_plugin_unregister_ratelimiter(const char* name);
+
+extern ROCKSDB_LIBRARY_API_WEAK
+void* side_plugin_ratelimiter_get_state(const rocksdb_ratelimiter_t*);
+#endif
+
 #ifdef __cplusplus
 } /* end extern "C" */
 #endif
diff --git a/include/rocksdb/memtablerep.h b/include/rocksdb/memtablerep.h
index 36888a9bd8..5ddfc6d76a 100644
--- a/include/rocksdb/memtablerep.h
+++ b/include/rocksdb/memtablerep.h
@@ -83,6 +83,14 @@ class MemTableRep : public CacheAlignedNewDelete {
     virtual int operator()(const char* prefix_len_key,
                            const Slice& key) const = 0;
 
+    // Compare prefix_len_key (encoded internal key) with user_key + tag
+    virtual int operator()(const char* prefix_len_key,
+                           const struct ParsedInternalKey&) const = 0;
+
+    // Compare user_key + tag with prefix_len_key (encoded internal key)
+    virtual int operator()(const struct ParsedInternalKey&,
+                           const char* prefix_len_key) const = 0;
+
     virtual const InternalKeyComparator* icomparator() const = 0;
 
     virtual ~KeyComparator() {}
@@ -242,6 +250,10 @@ class MemTableRep : public CacheAlignedNewDelete {
                    const LookupKey&, void* callback_args,
                    bool (*callback_func)(void* arg, const KeyValuePair&)) = 0;
 
+  virtual void GetPIK(const struct ReadOptions&,
+                      const struct ParsedInternalKey&, void* callback_args,
+                      bool (*callback_func)(void* arg, const KeyValuePair&));
+
   virtual uint64_t ApproximateNumEntries(const Slice& /*start_ikey*/,
                                          const Slice& /*end_key*/) {
     return 0;
diff --git a/include/rocksdb/options.h b/include/rocksdb/options.h
index 739724d8ba..eb3f17909c 100644
--- a/include/rocksdb/options.h
+++ b/include/rocksdb/options.h
@@ -925,6 +925,18 @@ struct DBOptions {
 
   bool memtable_as_log_index = false;
 
+  // If true, each WAL file is probed on DB open to auto-detect its on-disk
+  // format, so recovery works even when memtable_as_log_index was changed
+  // between runs.
+  //
+  // Defaults to false because the probe relies on CRC32 self-consistency
+  // rather than a magic number to distinguish the two formats, which carries
+  // a 1/2^32 false-positive risk per file. Always probing would expose this
+  // risk on every open; turning this on only when needed reduces the
+  // exposure by orders of magnitude (only when a format switch actually
+  // occurred).
+  bool check_wal_format = false;
+
   // if not zero, periodically take stats snapshots and store in memory, the
   // memory size for stats snapshots is capped at stats_history_buffer_size
   // Default: 1MB
@@ -1875,7 +1887,7 @@ struct ReadOptions {
     ~ScopePinIfNotPinned() { if (ro_) ro_->FinishPin(); }
   };
 
-  ReadOptions() {}
+  ReadOptions();
   ReadOptions(bool _verify_checksums, bool _fill_cache);
   explicit ReadOptions(Env::IOActivity _io_activity);
   ReadOptions(const ReadOptions&, BooleanDontCopyTrue/*dispatch_tag*/);
diff --git a/include/rocksdb/slice.h b/include/rocksdb/slice.h
index 01f892f81c..5395e66697 100644
--- a/include/rocksdb/slice.h
+++ b/include/rocksdb/slice.h
@@ -33,6 +33,10 @@ namespace ROCKSDB_NAMESPACE {
 
 class Slice {
  public:
+  typedef char value_type;
+  typedef const char &const_reference, &reference;
+  typedef const char *const_iterator, *iterator;
+
   // Create an empty slice.
   Slice() : data_(""), size_(0) {}
 
diff --git a/include/rocksdb/status.h b/include/rocksdb/status.h
index e6afa6fa09..02d6fa49c4 100644
--- a/include/rocksdb/status.h
+++ b/include/rocksdb/status.h
@@ -29,6 +29,7 @@
 #endif
 
 #include "rocksdb/slice.h"
+#include <terark/sso.hpp>
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -495,6 +496,7 @@ class Status {
   // Return a string representation of this status suitable for printing.
   // Returns the string "OK" for success.
   std::string ToString() const;
+  terark::minimal_sso<32> ToSSO() const;
 
   void swap(Status& y) {
     static_assert(sizeof(Status) == 2*sizeof(uint64_t));
diff --git a/java/rocksjni/rocksjni.cc b/java/rocksjni/rocksjni.cc
index 9dceb1997c..0e4e1c73b1 100644
--- a/java/rocksjni/rocksjni.cc
+++ b/java/rocksjni/rocksjni.cc
@@ -127,6 +127,7 @@ jlongArray rocksdb_open_helper(
       [](const char* str_data, const size_t str_len) {
         return std::string(str_data, str_len);
       },
+      terark::_rvref *
       [&jco, &column_families](size_t idx, std::string cf_name) {
         ROCKSDB_NAMESPACE::ColumnFamilyOptions* cf_options =
             reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jco[idx]);
diff --git a/java/rocksjni/transaction.cc b/java/rocksjni/transaction.cc
index 8a8438671b..3b408d315d 100644
--- a/java/rocksjni/transaction.cc
+++ b/java/rocksjni/transaction.cc
@@ -154,11 +154,6 @@ void Java_org_rocksdb_Transaction_rollbackToSavePoint(JNIEnv* env,
   }
 }
 
-typedef std::function<ROCKSDB_NAMESPACE::Status(
-    const ROCKSDB_NAMESPACE::ReadOptions&, const ROCKSDB_NAMESPACE::Slice&,
-    std::string*)>
-    FnGet;
-
 /*
  * Class:     org_rocksdb_Transaction
  * Method:    get
diff --git a/java/rocksjni/ttl.cc b/java/rocksjni/ttl.cc
index 1fe2083d99..178ca0203f 100644
--- a/java/rocksjni/ttl.cc
+++ b/java/rocksjni/ttl.cc
@@ -81,6 +81,7 @@ jlongArray Java_org_rocksdb_TtlDB_openCF(JNIEnv* env, jclass, jlong jopt_handle,
       [](const char* str_data, const size_t str_len) {
         return std::string(str_data, str_len);
       },
+      terark::_rvref *
       [&jco, &column_families](size_t idx, std::string cf_name) {
         ROCKSDB_NAMESPACE::ColumnFamilyOptions* cf_options =
             reinterpret_cast<ROCKSDB_NAMESPACE::ColumnFamilyOptions*>(jco[idx]);
diff --git a/options/db_options.cc b/options/db_options.cc
index 4a1663e4eb..dc17320e4e 100644
--- a/options/db_options.cc
+++ b/options/db_options.cc
@@ -328,6 +328,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct ImmutableDBOptions, memtable_as_log_index),
           OptionType::kBoolean, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
+        {"check_wal_format",
+         {offsetof(struct ImmutableDBOptions, check_wal_format),
+          OptionType::kBoolean, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
         {"fail_if_options_file_error",
          {offsetof(struct ImmutableDBOptions, fail_if_options_file_error),
           OptionType::kBoolean, OptionVerificationType::kNormal,
@@ -764,6 +768,7 @@ ImmutableDBOptions::ImmutableDBOptions(const DBOptions& options)
       avoid_unnecessary_blocking_io(options.avoid_unnecessary_blocking_io),
       persist_stats_to_disk(options.persist_stats_to_disk),
       memtable_as_log_index(options.memtable_as_log_index),
+      check_wal_format(options.check_wal_format),
       write_dbid_to_manifest(options.write_dbid_to_manifest),
       log_readahead_size(options.log_readahead_size),
       file_checksum_gen_factory(options.file_checksum_gen_factory),
@@ -933,6 +938,8 @@ void ImmutableDBOptions::Dump(Logger* log) const {
                    persist_stats_to_disk);
   ROCKS_LOG_HEADER(log, "                Options.memtable_as_log_index: %u",
                    memtable_as_log_index);
+  ROCKS_LOG_HEADER(log, "                     Options.check_wal_format: %u",
+                   check_wal_format);
   ROCKS_LOG_HEADER(log, "                Options.write_dbid_to_manifest: %d",
                    write_dbid_to_manifest);
   ROCKS_LOG_HEADER(
diff --git a/options/db_options.h b/options/db_options.h
index 024af355a7..e0c618d637 100644
--- a/options/db_options.h
+++ b/options/db_options.h
@@ -90,6 +90,7 @@ struct ImmutableDBOptions {
   bool avoid_unnecessary_blocking_io;
   bool persist_stats_to_disk;
   bool memtable_as_log_index;
+  bool check_wal_format;
   bool write_dbid_to_manifest;
   size_t log_readahead_size;
   std::shared_ptr<FileChecksumGenFactory> file_checksum_gen_factory;
diff --git a/options/options.cc b/options/options.cc
index 05e800e5d8..ee7199e11d 100644
--- a/options/options.cc
+++ b/options/options.cc
@@ -718,6 +718,9 @@ DBOptions* DBOptions::IncreaseParallelism(int total_threads) {
 static const bool g_cache_sst_file_iter =
     terark::getEnvBool("TOPLINGDB_CACHE_SST_FILE_ITER", false);
 
+ReadOptions::ReadOptions() {
+  cache_sst_file_iter = g_cache_sst_file_iter;
+}
 ReadOptions::ReadOptions(bool _verify_checksums, bool _fill_cache)
     : verify_checksums(_verify_checksums), fill_cache(_fill_cache) {
   cache_sst_file_iter = g_cache_sst_file_iter;
diff --git a/options/options_settable_test.cc b/options/options_settable_test.cc
index 42340073f9..2cd675a16a 100644
--- a/options/options_settable_test.cc
+++ b/options/options_settable_test.cc
@@ -338,6 +338,7 @@ TEST_F(OptionsSettableTest, DBOptionsAllFieldsSettable) {
                              "stats_persist_period_sec=54321;"
                              "persist_stats_to_disk=true;"
                              "memtable_as_log_index=true;"
+                             "check_wal_format=true;"
                              "stats_history_buffer_size=14159;"
                              "allow_fallocate=true;"
                              "allow_mmap_reads=false;"
diff --git a/options/options_test.cc b/options/options_test.cc
index a92d8f844c..450f38c400 100644
--- a/options/options_test.cc
+++ b/options/options_test.cc
@@ -170,6 +170,7 @@ TEST_F(OptionsTest, GetOptionsFromMapTest) {
       {"stats_persist_period_sec", "57"},
       {"persist_stats_to_disk", "false"},
       {"memtable_as_log_index", "false"},
+      {"check_wal_format", "false"},
       {"stats_history_buffer_size", "69"},
       {"advise_random_on_open", "true"},
       {"use_adaptive_mutex", "false"},
@@ -354,6 +355,7 @@ TEST_F(OptionsTest, GetOptionsFromMapTest) {
   ASSERT_EQ(new_db_opt.stats_persist_period_sec, 57U);
   ASSERT_EQ(new_db_opt.persist_stats_to_disk, false);
   ASSERT_EQ(new_db_opt.memtable_as_log_index, false);
+  ASSERT_EQ(new_db_opt.check_wal_format, false);
   ASSERT_EQ(new_db_opt.stats_history_buffer_size, 69U);
   ASSERT_EQ(new_db_opt.advise_random_on_open, true);
   ASSERT_EQ(new_db_opt.use_adaptive_mutex, false);
@@ -2392,6 +2394,7 @@ TEST_F(OptionsOldApiTest, GetOptionsFromMapTest) {
       {"stats_persist_period_sec", "57"},
       {"persist_stats_to_disk", "false"},
       {"memtable_as_log_index", "false"},
+      {"check_wal_format", "false"},
       {"stats_history_buffer_size", "69"},
       {"advise_random_on_open", "true"},
       {"use_adaptive_mutex", "false"},
@@ -2578,6 +2581,7 @@ TEST_F(OptionsOldApiTest, GetOptionsFromMapTest) {
   ASSERT_EQ(new_db_opt.stats_persist_period_sec, 57U);
   ASSERT_EQ(new_db_opt.persist_stats_to_disk, false);
   ASSERT_EQ(new_db_opt.memtable_as_log_index, false);
+  ASSERT_EQ(new_db_opt.check_wal_format, false);
   ASSERT_EQ(new_db_opt.stats_history_buffer_size, 69U);
   ASSERT_EQ(new_db_opt.advise_random_on_open, true);
   ASSERT_EQ(new_db_opt.use_adaptive_mutex, false);
diff --git a/sideplugin/rockside b/sideplugin/rockside
index 07d3333f80..345c8cf538 160000
--- a/sideplugin/rockside
+++ b/sideplugin/rockside
@@ -1 +1 @@
-Subproject commit 07d3333f80e154f14299a4877a13ed1801ff93b5
+Subproject commit 345c8cf5382ccfe7be0665f8478aa1f96f36ed67
diff --git a/table/block_based/block_based_table_reader_sync_and_async.h b/table/block_based/block_based_table_reader_sync_and_async.h
index e7621909cc..0cbe31b7e4 100644
--- a/table/block_based/block_based_table_reader_sync_and_async.h
+++ b/table/block_based/block_based_table_reader_sync_and_async.h
@@ -408,8 +408,9 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::MultiGet)
 
         for (auto miter = data_block_range.begin();
              miter != data_block_range.end(); ++miter) {
-          const Slice& key = miter->ikey;
-          iiter->Seek(miter->ikey);
+          const auto ikbuf = miter->InternalKeyBuf();
+          const Slice key = ikbuf;
+          iiter->Seek(key);
 
           IndexValue v;
           if (iiter->Valid()) {
@@ -580,7 +581,8 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::MultiGet)
          ++miter) {
       Status s;
       GetContext* get_context = miter->get_context;
-      const Slice& key = miter->ikey;
+      const auto ikbuf = miter->InternalKeyBuf();
+      const Slice key = ikbuf;
       bool matched = false;  // if such user key matched a key in SST
       bool done = false;
       bool first_block = true;
diff --git a/table/block_based/block_based_table_reader_test.cc b/table/block_based/block_based_table_reader_test.cc
index 254546893f..86bb7b780c 100644
--- a/table/block_based/block_based_table_reader_test.cc
+++ b/table/block_based/block_based_table_reader_test.cc
@@ -417,6 +417,7 @@ TEST_P(BlockBasedTableReaderTest, MultiGet) {
   autovector<GetContext, MultiGetContext::MAX_BATCH_SIZE> get_context;
   autovector<KeyContext, MultiGetContext::MAX_BATCH_SIZE> key_context;
   autovector<KeyContext*, MultiGetContext::MAX_BATCH_SIZE> sorted_keys;
+  get_context.reserve(keys.size());
   for (size_t i = 0; i < keys.size(); ++i) {
     get_context.emplace_back(options.comparator, nullptr, nullptr, nullptr,
                              GetContext::kNotFound, ExtractUserKey(keys[i]),
diff --git a/table/block_based/filter_block.h b/table/block_based/filter_block.h
index b14858c020..6e400f25a4 100644
--- a/table/block_based/filter_block.h
+++ b/table/block_based/filter_block.h
@@ -120,7 +120,8 @@ class FilterBlockReader {
                             const ReadOptions& read_options) {
     for (auto iter = range->begin(); iter != range->end(); ++iter) {
       const Slice ukey_without_ts = iter->ukey_without_ts;
-      const Slice ikey = iter->ikey;
+      const auto ikbuf = iter->InternalKeyBuf();
+      const Slice ikey = ikbuf; // convert from named ikbuf
       GetContext* const get_context = iter->get_context;
       if (!KeyMayMatch(ukey_without_ts, no_io, &ikey, get_context,
                        lookup_context, read_options)) {
@@ -145,7 +146,8 @@ class FilterBlockReader {
                                 const ReadOptions& read_options) {
     for (auto iter = range->begin(); iter != range->end(); ++iter) {
       const Slice ukey_without_ts = iter->ukey_without_ts;
-      const Slice ikey = iter->ikey;
+      const auto ikbuf = iter->InternalKeyBuf();
+      const Slice ikey = ikbuf; // convert from named ikbuf
       GetContext* const get_context = iter->get_context;
       if (prefix_extractor->InDomain(ukey_without_ts) &&
           !PrefixMayMatch(prefix_extractor->Transform(ukey_without_ts), no_io,
diff --git a/table/block_based/partitioned_filter_block.h b/table/block_based/partitioned_filter_block.h
index 817fe94245..565ca6da82 100644
--- a/table/block_based/partitioned_filter_block.h
+++ b/table/block_based/partitioned_filter_block.h
@@ -138,6 +138,12 @@ class PartitionedFilterBlockReader
   BlockHandle GetFilterPartitionHandle(
       const CachableEntry<Block_kFilterPartitionIndex>& filter_block,
       const Slice& entry) const;
+  BlockHandle GetFilterPartitionHandle(
+      const CachableEntry<Block_kFilterPartitionIndex>& filter_block,
+      const ParsedInternalKey& entry) const {
+    // overload this function can minimize diff, the caller need not change
+    return GetFilterPartitionHandle(filter_block, entry.MakeInternalKeyBuf());
+  }
   Status GetFilterPartitionBlock(
       FilePrefetchBuffer* prefetch_buffer, const BlockHandle& handle,
       bool no_io, GetContext* get_context,
diff --git a/table/get_context.cc b/table/get_context.cc
index c2a4dc887b..9b1dd47026 100644
--- a/table/get_context.cc
+++ b/table/get_context.cc
@@ -61,6 +61,9 @@ GetContext::GetContext(
   if (seq) {
     *seq = kMaxSequenceNumber;
   }
+  if (statistics) {
+    new(&get_context_stats_)GetContextStats();
+  }
   switch (g_how_sampling) {
   case GetContextSampleRead::kAlways: sample_ = true;  break;
   case GetContextSampleRead::kNone  : sample_ = false; break;
@@ -133,6 +136,9 @@ void GetContext::SaveValue(const Slice& value, SequenceNumber /*seq*/) {
 }
 
 void GetContext::ReportCounters() {
+  if (!statistics_) {
+    return;
+  }
   if (get_context_stats_.num_cache_hit > 0) {
     RecordTick(statistics_, BLOCK_CACHE_HIT, get_context_stats_.num_cache_hit);
   }
diff --git a/table/get_context.h b/table/get_context.h
index 8579d08982..dbea262d6f 100644
--- a/table/get_context.h
+++ b/table/get_context.h
@@ -77,7 +77,9 @@ class GetContext {
     kUnexpectedBlobIndex,
     kMergeOperatorFailed,
   };
+  union {
   GetContextStats get_context_stats_;
+  };
 
   // Constructor
   // @param value Holds the value corresponding to user_key. If its nullptr
diff --git a/table/iterator_wrapper.h b/table/iterator_wrapper.h
index cde6320eb0..f9ccc4a57e 100644
--- a/table/iterator_wrapper.h
+++ b/table/iterator_wrapper.h
@@ -56,10 +56,8 @@ class IteratorWrapperBase {
       result_.is_valid = false;
     } else {
      #if TOPLING_USE_BOUND_PMF
-      next_and_get_result_ = ExtractFuncPtr<NextAndGetResultFN>
-          (_iter, &InternalIteratorBase<TValue>::NextAndGetResult);
-      prepare_and_get_value_ = ExtractFuncPtr<PrepareAndGetValueFN>
-          (_iter, &InternalIteratorBase<TValue>::PrepareAndGetValue);
+      next_and_get_result_ = ForgeFuncPtr(_iter, &InternalIteratorBase<TValue>::NextAndGetResult);
+      prepare_and_get_value_ = ForgeFuncPtr(_iter, &InternalIteratorBase<TValue>::PrepareAndGetValue);
      #endif
       Update();
     }
@@ -289,10 +287,8 @@ class ThinIteratorWrapperBase {
     iter_ = i;
     if (i) {
      #if TOPLING_USE_BOUND_PMF
-      next_and_get_result_ = ExtractFuncPtr<NextAndGetResultFN>
-          (i, &InternalIteratorBase<TValue>::NextAndGetResult);
-      prepare_and_get_value_ = ExtractFuncPtr<PrepareAndGetValueFN>
-          (i, &InternalIteratorBase<TValue>::PrepareAndGetValue);
+      next_and_get_result_ = ForgeFuncPtr(i, &InternalIteratorBase<TValue>::NextAndGetResult);
+      prepare_and_get_value_ = ForgeFuncPtr(i, &InternalIteratorBase<TValue>::PrepareAndGetValue);
      #endif
     }
     return old_iter;
diff --git a/table/merging_iterator.cc b/table/merging_iterator.cc
index f2a7f8995a..9ee6b83109 100644
--- a/table/merging_iterator.cc
+++ b/table/merging_iterator.cc
@@ -150,14 +150,7 @@ class MaxHeapItemComparator {
   const InternalKeyComparator* comparator_;
 };
 
-#if defined(_MSC_VER) /* Visual Studio */
-#define FORCE_INLINE __forceinline
-#define __bswap_64 _byteswap_uint64
-#elif defined(__GNUC__)
-#define FORCE_INLINE inline __attribute__((always_inline))
-#else
-#define FORCE_INLINE inline
-#endif
+#define FORCE_INLINE terark_forceinline
 
 #if defined(__AVX512VL__) && defined(__AVX512BW__)
   // can be defined as 23 or 16
@@ -272,6 +265,7 @@ struct UintPrefix {
   unsigned char data[MERGE_ITER_PREFIX_LEN] = {0};
   UintPrefix(int=0) {}
 };
+static_assert(sizeof(UintPrefix) == MERGE_ITER_PREFIX_LEN);
 
 #endif // MERGE_ITER_PREFIX_LEN
 
@@ -437,7 +431,7 @@ class MinHeapBytewiseComp {
     __m256i   b256 = _mm256_maskz_loadu_epi8(mask, &b.key_prefix); \
     __mmask32 cneq = _mm256_cmpneq_epi8_mask(a256, b256);          \
     if (LIKELY(cneq != 0)) {                                       \
-      __mmask32 cmp = _mm256_cmp##cmp##_epi8_mask(a256, b256);     \
+      __mmask32 cmp = _mm256_cmp##cmp##_epu8_mask(a256, b256);     \
       return (cmp & -cneq) != 0;                                   \
     }
 //-------------------------------------------------------------------
@@ -1617,7 +1611,7 @@ MergingIterMethod(void)SeekForPrevImpl(const Slice& target,
     PERF_TIMER_GUARD(seek_max_heap_time);
     AddToMaxHeapOrCheckStatus(&children_[level]);
   }
-  if (!range_tombstone_iters_.empty()) {
+  if (!RangeTombstoneStaticEmpty && !range_tombstone_iters_.empty()) {
     // Add range tombstones before starting_level.
     for (size_t level = 0; level < starting_level; ++level) {
       if (range_tombstone_iters_[level] &&
@@ -1878,7 +1872,7 @@ MergingIterMethod(void)SwitchToForward() {
   // Previous direction is backward, so range tombstone iter may point to a
   // tombstone before current_. If there is no such tombstone, then the range
   // tombstone iter is !Valid(). Need to reseek here to make it valid again.
-  if (!range_tombstone_iters_.empty()) {
+  if (!RangeTombstoneStaticEmpty && !range_tombstone_iters_.empty()) {
     ParsedInternalKey pik(target);
     for (size_t i = 0; i < range_tombstone_iters_.size(); ++i) {
       auto iter = range_tombstone_iters_[i];
diff --git a/table/multiget_context.h b/table/multiget_context.h
index 8c7beb2c11..0aafd460b3 100644
--- a/table/multiget_context.h
+++ b/table/multiget_context.h
@@ -25,11 +25,25 @@ class GetContext;
 class PinnableWideColumns;
 
 struct KeyContext {
+#if defined(TOPLINGDB_WITH_TIMESTAMP)
   const Slice* key;
   LookupKey* lkey;
-  Slice ukey_with_ts;
+  union {
+    ParsedInternalKey ikey;
+    Slice ukey_with_ts; // at ikey.user_key
+  };
   Slice ukey_without_ts;
-  Slice ikey;
+  // long live & fast
+  auto InternalKeyBuf() const { return lkey->internal_key(); }
+#else
+  union {
+    ParsedInternalKey ikey;
+    Slice ukey_with_ts;    // at ikey.user_key
+    Slice ukey_without_ts; // at ikey.user_key
+  };
+  // temporary & slow
+  auto InternalKeyBuf() const { return ikey.MakeInternalKeyBuf(); }
+#endif
   ColumnFamilyHandle* column_family;
   Status* s;
   MergeContext merge_context;
@@ -45,8 +59,13 @@ struct KeyContext {
   KeyContext(ColumnFamilyHandle* col_family, const Slice& user_key,
              PinnableSlice* val, PinnableWideColumns* cols, std::string* ts,
              Status* stat)
+#if defined(TOPLINGDB_WITH_TIMESTAMP)
       : key(&user_key),
         lkey(nullptr),
+        ukey_without_ts(user_key), // must init
+#else
+      : ukey_without_ts(user_key), // keep ikey.tag raw mem
+#endif
         column_family(col_family),
         s(stat),
         max_covering_tombstone_seq(0),
@@ -113,8 +132,11 @@ class MultiGetContext {
                   Statistics* stats)
       : num_keys_(num_keys),
         value_mask_(0),
-        value_size_(0),
+        value_size_(0)
+#if defined(TOPLINGDB_WITH_TIMESTAMP)
+        ,
         lookup_key_ptr_(reinterpret_cast<LookupKey*>(lookup_key_stack_buf))
+#endif
 #if USE_COROUTINES
         ,
         reader_(fs, stats),
@@ -124,41 +146,44 @@ class MultiGetContext {
     (void)fs;
     (void)stats;
     assert(num_keys <= MAX_BATCH_SIZE);
+#if defined(TOPLINGDB_WITH_TIMESTAMP)
     if (num_keys > MAX_LOOKUP_KEYS_ON_STACK) {
       lookup_key_heap_buf.reset(new char[sizeof(LookupKey) * num_keys]);
       lookup_key_ptr_ = reinterpret_cast<LookupKey*>(lookup_key_heap_buf.get());
     }
+#endif
 
+    ROCKSDB_ASSERT_LE(begin + num_keys, sorted_keys->size());
     for (size_t iter = 0; iter != num_keys_; ++iter) {
       // autovector may not be contiguous storage, so make a copy
       sorted_keys_[iter] = (*sorted_keys)[begin + iter];
+     #if defined(TOPLINGDB_WITH_TIMESTAMP)
       sorted_keys_[iter]->lkey = new (&lookup_key_ptr_[iter])
           LookupKey(*sorted_keys_[iter]->key, snapshot, read_opts.timestamp);
       sorted_keys_[iter]->ukey_with_ts = sorted_keys_[iter]->lkey->user_key();
 
-     #if defined(TOPLINGDB_WITH_TIMESTAMP)
       sorted_keys_[iter]->ukey_without_ts = StripTimestampFromUserKey(
           sorted_keys_[iter]->lkey->user_key(),
           read_opts.timestamp == nullptr ? 0 : read_opts.timestamp->size());
-     #else
-      sorted_keys_[iter]->ukey_without_ts = sorted_keys_[iter]->lkey->user_key();
-     #endif
-
-      sorted_keys_[iter]->ikey = sorted_keys_[iter]->lkey->internal_key();
-
-     #if defined(TOPLINGDB_WITH_TIMESTAMP)
       sorted_keys_[iter]->timestamp = (*sorted_keys)[begin + iter]->timestamp;
+     #else
+      static_assert(offsetof(KeyContext, ikey.user_key) == offsetof(KeyContext, ukey_without_ts));
      #endif
+      static_assert(offsetof(KeyContext, ikey.user_key) == offsetof(KeyContext, ukey_with_ts));
+      sorted_keys_[iter]->ikey.sequence = snapshot;
+      sorted_keys_[iter]->ikey.type = kValueTypeForSeek;
       sorted_keys_[iter]->get_context =
           (*sorted_keys)[begin + iter]->get_context;
     }
   }
 
+#if defined(TOPLINGDB_WITH_TIMESTAMP)
   ~MultiGetContext() {
     for (size_t i = 0; i < num_keys_; ++i) {
       lookup_key_ptr_[i].~LookupKey();
     }
   }
+#endif
 
 #if USE_COROUTINES
   SingleThreadExecutor& executor() { return executor_; }
@@ -168,15 +193,19 @@ class MultiGetContext {
 
  private:
   static const int MAX_LOOKUP_KEYS_ON_STACK = 16;
+#if defined(TOPLINGDB_WITH_TIMESTAMP)
   alignas(
       alignof(LookupKey)) char lookup_key_stack_buf[sizeof(LookupKey) *
                                                     MAX_LOOKUP_KEYS_ON_STACK];
+#endif
   std::array<KeyContext*, MAX_BATCH_SIZE> sorted_keys_;
   size_t num_keys_;
   Mask value_mask_;
   uint64_t value_size_;
+#if defined(TOPLINGDB_WITH_TIMESTAMP)
   std::unique_ptr<char[]> lookup_key_heap_buf;
   LookupKey* lookup_key_ptr_;
+#endif
 #if USE_COROUTINES
   AsyncFileReader reader_;
   SingleThreadExecutor executor_;
diff --git a/table/table_reader.h b/table/table_reader.h
index 3a2c46c62e..8db7ade1d9 100644
--- a/table/table_reader.h
+++ b/table/table_reader.h
@@ -113,6 +113,9 @@ class TableReader : public CacheAlignedNewDelete {
 
   // Prepare work that can be done before the real Get()
   virtual void Prepare(const Slice& /*target*/) {}
+  virtual void PreparePIK(const ParsedInternalKey& pik) {
+    Prepare(pik.MakeInternalKeyBuf());
+  }
 
   // Report an approximation of how much memory has been used.
   virtual size_t ApproximateMemoryUsage() const = 0;
@@ -133,6 +136,14 @@ class TableReader : public CacheAlignedNewDelete {
                      const SliceTransform* prefix_extractor,
                      bool skip_filters = false) = 0;
 
+  virtual Status GetPIK(const ReadOptions& ro, const ParsedInternalKey& pik,
+                     GetContext* get_context,
+                     const SliceTransform* prefix_extractor,
+                     bool skip_filters = false) {
+    auto ikbuf = pik.MakeInternalKeyBuf();
+    return Get(ro, ikbuf, get_context, prefix_extractor, skip_filters);
+  }
+
   // Use bloom filters in the table file, if present, to filter out keys. The
   // mget_range will be updated to skip keys that get a negative result from
   // the filter lookup.
@@ -147,7 +158,7 @@ class TableReader : public CacheAlignedNewDelete {
                         const SliceTransform* prefix_extractor,
                         bool skip_filters = false) {
     for (auto iter = mget_range->begin(); iter != mget_range->end(); ++iter) {
-      *iter->s = Get(readOptions, iter->ikey, iter->get_context,
+      *iter->s = GetPIK(readOptions, iter->ikey, iter->get_context,
                      prefix_extractor, skip_filters);
     }
   }
diff --git a/table/table_test.cc b/table/table_test.cc
index 33d823920d..56f60f94d2 100644
--- a/table/table_test.cc
+++ b/table/table_test.cc
@@ -3751,14 +3751,14 @@ TEST_P(BlockBasedTableTest, TracingMultiGetTest) {
                              /*PinnableWideColumns omitted*/ nullptr,
                              /*timestamp omitted*/ nullptr, statuses.data());
     key_context[0].ukey_without_ts = ukeys[0];
-    key_context[0].ikey = encoded_keys[0];
+    key_context[0].ikey = ParsedInternalKey(encoded_keys[0]);
     key_context[0].get_context = get_contexts.data();
     key_context.emplace_back(/*ColumnFamilyHandle omitted*/ nullptr, ukeys[1],
                              &values[1],
                              /*PinnableWideColumns omitted*/ nullptr,
                              /*timestamp omitted*/ nullptr, &statuses[1]);
     key_context[1].ukey_without_ts = ukeys[1];
-    key_context[1].ikey = encoded_keys[1];
+    key_context[1].ikey = ParsedInternalKey(encoded_keys[1]);
     key_context[1].get_context = &get_contexts[1];
     autovector<KeyContext*, MultiGetContext::MAX_BATCH_SIZE> sorted_keys;
     sorted_keys.push_back(&key_context[0]);
diff --git a/tools/ldb_cmd.cc b/tools/ldb_cmd.cc
index 5fe196c7dc..33752d8b75 100644
--- a/tools/ldb_cmd.cc
+++ b/tools/ldb_cmd.cc
@@ -2749,9 +2749,23 @@ void DumpWalFile(Options options, std::string wal_file, bool print_header,
       // bogus input, carry on as best we can
       log_number = 0;
     }
+    bool wal_memtable_format = options.memtable_as_log_index;
+    if (options.check_wal_format) {
+      if (IOStatus ios = log::Reader::IsMemTableAsLogIndexFile
+                   (*fs, wal_file, &wal_memtable_format); !ios.ok()) {
+        if (exec_state) {
+          *exec_state = LDBCommandExecuteResult::Failed(
+              "Failed to detect WAL format " + ios.ToString());
+        } else {
+          std::cerr << "Error: Failed to detect WAL format "
+                    << ios.ToString() << std::endl;
+        }
+        return;
+      }
+    }
     log::Reader reader(options.info_log, std::move(wal_file_reader), &reporter,
                        true /* checksum */, log_number);
-    if (options.memtable_as_log_index) {
+    if (wal_memtable_format) {
       reader.InitSetMemTableAsLogIndex(*fs);
     }
     std::string scratch;
diff --git a/util/status.cc b/util/status.cc
index 160755d54d..978f315b13 100644
--- a/util/status.cc
+++ b/util/status.cc
@@ -160,4 +160,8 @@ std::string Status::ToString() const {
   return result;
 }
 
+terark::minimal_sso<32> Status::ToSSO() const {
+  return terark::minimal_sso<32>{ToString()};
+}
+
 }  // namespace ROCKSDB_NAMESPACE
diff --git a/util/stop_watch.h b/util/stop_watch.h
index 105a99c1fa..8d2ea93e14 100644
--- a/util/stop_watch.h
+++ b/util/stop_watch.h
@@ -15,6 +15,9 @@
 #endif
 
 namespace ROCKSDB_NAMESPACE {
+
+class StopWatchNano;
+
 // Auto-scoped.
 // When statistics is not nullptr, records the measured time into any enabled
 // histograms supplied to the constructor. A histogram argument may be omitted
@@ -23,6 +26,7 @@ namespace ROCKSDB_NAMESPACE {
 // added to *elapsed if overwrite is false.
 class StopWatch {
  public:
+  typedef StopWatchNano WatchNano;
   inline
   StopWatch(SystemClock* clock, Statistics* statistics, const uint32_t hist_type)
   noexcept :
@@ -223,6 +227,7 @@ class StopWatchNano {
 };
 
 struct FakeStopWatch {
+  typedef FakeStopWatch WatchNano;
   FakeStopWatch(...) {}
   void DelayStart() {}
   void DelayStop() {}
diff --git a/util/string_util.cc b/util/string_util.cc
index b47140cbdc..02213c8ef0 100644
--- a/util/string_util.cc
+++ b/util/string_util.cc
@@ -118,13 +118,13 @@ std::string NumberToHumanString(int64_t num) {
   char buf[19];
   int64_t absnum = num < 0 ? -num : num;
   if (absnum < 10000) {
-    snprintf(buf, sizeof(buf), "%" PRIi64, num);
+    snprintf(buf, sizeof(buf), "%4" PRIi64 " ", num);
   } else if (absnum < 10000000) {
-    snprintf(buf, sizeof(buf), "%" PRIi64 "K", num / 1000);
+    snprintf(buf, sizeof(buf), "%4" PRIi64 "K", num / 1000);
   } else if (absnum < 10000000000LL) {
-    snprintf(buf, sizeof(buf), "%" PRIi64 "M", num / 1000000);
+    snprintf(buf, sizeof(buf), "%4" PRIi64 "M", num / 1000000);
   } else {
-    snprintf(buf, sizeof(buf), "%" PRIi64 "G", num / 1000000000);
+    snprintf(buf, sizeof(buf), "%4" PRIi64 "G", num / 1000000000);
   }
   return std::string(buf);
 }
@@ -144,7 +144,7 @@ std::string BytesToHumanString(uint64_t bytes) {
   }
 
   char buf[20];
-  snprintf(buf, sizeof(buf), "%.2f %s", final_size, size_name[size_idx]);
+  snprintf(buf, sizeof(buf), "%7.2f %s", final_size, size_name[size_idx]);
   return std::string(buf);
 }
 
diff --git a/utilities/blob_db/blob_db.cc b/utilities/blob_db/blob_db.cc
index b6fe039036..1bcf605884 100644
--- a/utilities/blob_db/blob_db.cc
+++ b/utilities/blob_db/blob_db.cc
@@ -46,6 +46,9 @@ Status BlobDB::Open(const DBOptions& db_options,
     return Status::NotSupported(
         "Blob DB doesn't support non-default column family.");
   }
+  MaybeOptionsUpdateFrom(const_cast<DBOptions*>(&db_options),
+      const_cast<std::vector<ColumnFamilyDescriptor>*>(&column_families),
+      dbname);
 
   BlobDBImpl* blob_db_impl = new BlobDBImpl(dbname, bdb_options, db_options,
                                             column_families[0].options);
diff --git a/utilities/transactions/pessimistic_transaction.cc b/utilities/transactions/pessimistic_transaction.cc
index 4a370fcb53..ca71ac2763 100644
--- a/utilities/transactions/pessimistic_transaction.cc
+++ b/utilities/transactions/pessimistic_transaction.cc
@@ -28,6 +28,8 @@
 
 namespace ROCKSDB_NAMESPACE {
 
+using terark::_rvref;
+
 struct WriteOptions;
 
 std::atomic<TransactionID> PessimisticTransaction::txn_id_counter_(1);
@@ -692,7 +694,7 @@ Status WriteCommittedTxn::CommitWithoutPrepareInternal() {
     Slice commit_ts(commit_ts_buf, sizeof(commit_ts_buf));
 
     Status s =
-        wb->UpdateTimestamps(commit_ts, [wbwi, this](uint32_t cf) -> size_t {
+        wb->UpdateTimestamps(commit_ts, _rvref*[wbwi, this](uint32_t cf) -> size_t {
           auto cf_iter = cfs_with_ts_tracked_when_indexing_disabled_.find(cf);
           if (cf_iter != cfs_with_ts_tracked_when_indexing_disabled_.end()) {
             return sizeof(kMaxTxnTimestamp);
@@ -776,7 +778,7 @@ Status WriteCommittedTxn::CommitInternal() {
     s = WriteBatchInternal::MarkCommitWithTimestamp(working_batch, name_,
                                                     commit_ts);
     if (s.ok()) {
-      s = wb->UpdateTimestamps(commit_ts, [wbwi, this](uint32_t cf) -> size_t {
+      s = wb->UpdateTimestamps(commit_ts, _rvref*[wbwi, this](uint32_t cf) -> size_t {
         if (cfs_with_ts_tracked_when_indexing_disabled_.find(cf) !=
             cfs_with_ts_tracked_when_indexing_disabled_.end()) {
           return sizeof(kMaxTxnTimestamp);