chadtmiller.com/monolith
An atproto PDS
0
0
//! Reads of what accounts hold (`stores`): a record by its path, a listing
//! of 50 records, the first read of an account not yet open, and what the
//! open accounts keep resident. Each store is measured in processes of its
//! own, started after the files are written: nothing of them is in the
//! process, and all of them are in the system's cache.
use crate::check::Check;
use crate::data::{self, SEED};
use crate::fj;
use crate::rocks::{self, Pack, Setup};
use crate::stores::{self, block_bytes, key, path_cid};
use crate::tables::{self, Reader};
use crate::util::{Rng, at, cores, dir_bytes, mib, par, rss_kib, scratch, share, us};
use pds_store::table::{BLOCK, BlockCache, Table, Version};
use rocksdb::DB;
use rusqlite::{Connection, params};
use std::collections::HashMap;
use std::hint::black_box;
use std::path::{Path, PathBuf};
use std::sync::{Mutex, OnceLock};
use std::time::{Duration, Instant};
/// The bytes the tables' block cache may hold, each connection's page
/// cache of the one database for all, and RocksDB's block cache: more
/// than the data, so that nothing read is let go.
const CACHE: u64 = 1 << 30;
/// The records looked up one after another, on each of the threads, and
/// the listings.
const LOOKUPS: usize = 20_000;
const THREADS: usize = 16;
const EACH: usize = 5_000;
const LISTINGS: usize = 2_000;
const LISTED: usize = 50;
const GET: &str = "SELECT b.bytes FROM record r JOIN block b ON b.account = r.account AND b.cid = r.cid WHERE r.account = ?1 AND r.path = ?2";
const LIST: &str = "SELECT r.path, b.bytes FROM record r JOIN block b ON b.account = r.account AND b.cid = r.cid WHERE r.account = ?1 AND r.path >= ?2 ORDER BY r.path LIMIT ?3";
/// A way of reading one of the stores, each account's file opened when it
/// is first read.
enum Store {
/// A table for each account read as the server reads one
/// (`pds_store::table::Table`), through one block cache, which keeps
/// the tables' files open: at most the server's share of them
/// (`util::share`), or every one.
Tables {
dir: PathBuf,
tables: Vec<OnceLock<Table>>,
cache: BlockCache,
},
/// Tables read by this benchmark's reader (`tables::Reader`), which
/// keeps every block it reads, has no bloom filter, and computes the
/// check it is given: each file held open, or opened for each block
/// read.
Own {
dir: PathBuf,
readers: Vec<OnceLock<Reader>>,
check: Check,
each: bool,
},
/// A database for each account, one connection each, its page cache
/// SQLite's own 2 MiB: more than the database.
Dbs {
dir: PathBuf,
dbs: Vec<OnceLock<Mutex<Connection>>>,
},
/// One database for all, a connection for each thread that reads.
Db {
dir: PathBuf,
conns: Vec<OnceLock<Mutex<Connection>>>,
},
/// One RocksDB for all, opened when it is first read, its files held
/// open, read from every thread through one block cache.
Rocks {
dir: PathBuf,
db: OnceLock<DB>,
pack: Pack,
},
/// One fjall database for all, opened when it is first read, read
/// from every thread through one block cache.
Fjall {
dir: PathBuf,
store: OnceLock<fj::Store>,
pack: fj::Pack,
},
}
/// The directory a way of reading reads: `tables`, `tables16` (the same
/// entries in the layout before), `dbs` or `db`. A way is named for it;
/// then, for this benchmark's reader, `:` and a check; then `+open` for
/// tables whose files the block cache holds open every one, or `+each`
/// for a reader that opens its file for each block.
fn files(way: &str) -> &str {
way.split(['+', ':']).next().unwrap_or(way)
}
impl Store {
fn open(way: &str, dir: &Path, accounts: usize, threads: usize) -> Store {
let dir = dir.join(files(way));
fn cells<T>(n: usize) -> Vec<OnceLock<T>> {
(0..n).map(|_| OnceLock::new()).collect()
}
let (named, flag) = way.split_once('+').unwrap_or((way, ""));
match (files(way), named.split_once(':')) {
("tables" | "tables16", Some((_, check))) => Store::Own {
dir,
readers: cells(accounts),
check: Check::named(check).expect("a check"),
each: flag == "each",
},
("tables", None) => Store::Tables {
dir,
tables: cells(accounts),
cache: match flag {
"open" => BlockCache::with_open(CACHE, accounts),
_ => BlockCache::with_open(CACHE, share()),
},
},
("dbs", _) => Store::Dbs {
dir,
dbs: cells(accounts),
},
("db", _) => Store::Db {
dir,
conns: cells(threads),
},
("rocks", _) | ("rocks-plain", _) => Store::Rocks {
pack: if files(way) == "rocks" {
Pack::Snappy
} else {
Pack::None
},
dir,
db: OnceLock::new(),
},
("fjall", _) | ("fjall-plain", _) => Store::Fjall {
pack: if files(way) == "fjall" {
fj::Pack::Lz4
} else {
fj::Pack::None
},
dir,
store: OnceLock::new(),
},
_ => panic!("no way of reading named {way}"),
}
}
/// The account's table, opened if it is not: its index and bloom
/// filter read, and its file one of those the cache holds open.
fn table(&self, account: usize) -> (&Table, &BlockCache) {
let Store::Tables { dir, tables, cache } = self else {
unreachable!("no table")
};
let table = tables[account].get_or_init(|| {
Table::open(&dir.join(format!("{account}.table")), cache).expect("the account's table")
});
(table, cache)
}
/// The account's table in this benchmark's reader, opened if it is not.
fn reader(&self, account: usize) -> &Reader {
let Store::Own {
dir,
readers,
check,
each,
} = self
else {
unreachable!("no reader")
};
readers[account].get_or_init(|| {
let path = dir.join(format!("{account}.table"));
let reader = Reader::open(&path, Some(*check), true);
if *each { reader.opening_each() } else { reader }
})
}
/// The one RocksDB, opened if it is not.
fn rocks(&self) -> &DB {
let Store::Rocks { dir, db, pack } = self else {
unreachable!("no RocksDB")
};
db.get_or_init(|| {
let cache = rocksdb::Cache::new_lru_cache(CACHE as usize);
Setup::new(&cache, *pack, "", false).open(dir)
})
}
/// The one fjall database, opened if it is not.
fn fjall(&self) -> &fj::Store {
let Store::Fjall { dir, store, pack } = self else {
unreachable!("no fjall")
};
store.get_or_init(|| fj::Store::open(dir, CACHE, *pack, false))
}
/// The connection the read goes through, opened if it is not.
fn conn(&self, thread: usize, account: usize) -> &Mutex<Connection> {
match self {
Store::Dbs { dir, dbs } => dbs[account].get_or_init(|| {
let path = dir.join(format!("{account}.sqlite"));
Mutex::new(Connection::open(path).expect("a database"))
}),
Store::Db { dir, conns } => conns[thread].get_or_init(|| {
let db = Connection::open(dir.join("store.sqlite")).expect("the database");
db.execute_batch(&format!("PRAGMA cache_size=-{};", CACHE >> 10))
.expect("a cache");
Mutex::new(db)
}),
_ => unreachable!("no connection"),
}
}
/// Open what a read of `account` on `thread` goes through.
fn touch(&self, thread: usize, account: usize) {
match self {
Store::Tables { .. } => {
self.table(account);
}
Store::Own { .. } => {
self.reader(account);
}
Store::Rocks { .. } => {
self.rocks();
}
Store::Fjall { .. } => {
self.fjall();
}
_ => {
self.conn(thread, account);
}
}
}
/// The record at `path` of `account`: its bytes.
fn get(&self, thread: usize, account: usize, path: &str) -> Vec<u8> {
let path_key = key(b'P', path.as_bytes());
match self {
Store::Tables { .. } => {
let (t, cache) = self.table(account);
let at = t
.get(&path_key, cache)
.expect("the table read")
.expect("the path");
let block = t
.get(&key(b'B', path_cid(&at)), cache)
.expect("the table read")
.expect("the record's block");
block_bytes(&block).to_vec()
}
Store::Own { .. } => {
let r = self.reader(account);
let at = r.get(&path_key, &mut None);
block_bytes(&r.get(&key(b'B', path_cid(&at)), &mut None)).to_vec()
}
Store::Rocks { .. } => {
let db = self.rocks();
let at = db
.get_pinned_cf(
rocks::family(db, rocks::RECORD),
rocks::key(account, path.as_bytes()),
)
.expect("the database read")
.expect("the path");
let block = db
.get_pinned_cf(
rocks::family(db, rocks::BLOCK),
rocks::key(account, path_cid(&at)),
)
.expect("the database read")
.expect("the record's block");
block_bytes(&block).to_vec()
}
Store::Fjall { .. } => {
let s = self.fjall();
let at = s
.record
.get(rocks::key(account, path.as_bytes()))
.expect("the database read")
.expect("the path");
let block = s
.block
.get(rocks::key(account, path_cid(&at)))
.expect("the database read")
.expect("the record's block");
block_bytes(&block).to_vec()
}
_ => {
let db = self.conn(thread, account).lock().expect("the database");
db.prepare_cached(GET)
.expect("a statement")
.query_row(params![account as i64, path], |row| row.get(0))
.expect("the record")
}
}
}
/// The `LISTED` records of `account` from `path` on, in order: how
/// many, and their bytes.
fn list(&self, thread: usize, account: usize, path: &str) -> (usize, usize) {
let (mut n, mut bytes) = (0, 0);
let from = key(b'P', path.as_bytes());
match self {
Store::Tables { .. } => {
let (t, cache) = self.table(account);
for e in t.iter(&from, None, cache).take(LISTED) {
let (k, at) = e.expect("the table read");
if k[0] != b'P' {
break;
}
let block = t
.get(&key(b'B', path_cid(&at)), cache)
.expect("the table read")
.expect("the record's block");
n += 1;
bytes += black_box(block_bytes(&block).to_vec()).len() + k.len();
}
}
Store::Own { .. } => {
let r = self.reader(account);
for (k, at) in r.list(&from, LISTED) {
let block = r.get(&key(b'B', path_cid(&at)), &mut None);
n += 1;
bytes += black_box(block_bytes(&block).to_vec()).len() + k.len();
}
}
// The paths with an iterator, then their blocks asked for
// together (`MultiGet`), as RocksDB is meant to be asked for
// many keys.
Store::Rocks { .. } => {
let db = self.rocks();
let mut paths = db.raw_iterator_cf(rocks::family(db, rocks::RECORD));
paths.seek(rocks::key(account, path.as_bytes()));
let mut blocks = Vec::with_capacity(LISTED);
while blocks.len() < LISTED {
let (Some(k), Some(at)) = (paths.key(), paths.value()) else {
break;
};
if k[..4] != (account as u32).to_be_bytes() {
break;
}
bytes += k.len() - 3;
blocks.push(rocks::key(account, path_cid(at)));
paths.next();
}
paths.status().expect("the paths read");
for b in db.batched_multi_get_cf(rocks::family(db, rocks::BLOCK), &blocks, false) {
let b = b.expect("the database read").expect("the record's block");
n += 1;
bytes += black_box(block_bytes(&b).to_vec()).len();
}
}
// The paths with an iterator, and each one's block with a
// read of its own: fjall has no read of many keys at once.
Store::Fjall { .. } => {
let s = self.fjall();
let paths = s.record.range(rocks::key(account, path.as_bytes())..);
for path in paths.take(LISTED) {
let (k, at) = path.into_inner().expect("the paths read");
if k[..4] != (account as u32).to_be_bytes() {
break;
}
let b = s
.block
.get(rocks::key(account, path_cid(&at)))
.expect("the database read")
.expect("the record's block");
n += 1;
bytes += black_box(block_bytes(&b).to_vec()).len() + k.len() - 3;
}
}
_ => {
let db = self.conn(thread, account).lock().expect("the database");
let mut st = db.prepare_cached(LIST).expect("a statement");
let mut rows = st
.query(params![account as i64, path, LISTED as i64])
.expect("a query");
while let Some(row) = rows.next().expect("a row") {
let path: String = row.get(0).expect("a path");
let block: Vec<u8> = row.get(1).expect("a block");
n += 1;
bytes += black_box(block).len() + path.len();
}
}
}
(n, bytes)
}
}
/// A record to read: its account and its path.
type Want = (usize, String);
/// `n` records drawn from all of them, the same for the same `which`; the
/// last `LISTED` of an account left out when `listing`, so that every
/// listing is whole.
fn wants(which: u64, n: usize, accounts: usize, records: usize, listing: bool) -> Vec<Want> {
let mut r = Rng::of(&[SEED, 7, which]);
let among = if listing { records - LISTED } else { records } as u64;
(0..n)
.map(|_| {
let (a, i) = (r.below(accounts as u64), r.below(among));
(a as usize, data::path(SEED, i * accounts as u64 + a + 1, a))
})
.collect()
}
/// Time `f` of each of `wants`, in an order of its own.
fn each(wants: &[Want], order: u64, mut f: impl FnMut(&Want)) -> Vec<Duration> {
let mut order_of: Vec<usize> = (0..wants.len()).collect();
Rng::of(&[SEED, 8, order]).shuffle(&mut order_of);
let mut times: Vec<Duration> = order_of
.into_iter()
.map(|i| {
let at = Instant::now();
f(&wants[i]);
at.elapsed()
})
.collect();
times.sort();
times
}
fn say(name: &str, value: f64) {
println!("{name} {value}");
}
fn say_times(name: &str, times: &[Duration]) {
say(&format!("{name}_p50"), us(times[times.len() / 2]));
say(&format!("{name}_p99"), us(at(times, 99)));
}
/// One store measured one way, in a process of its own: figures by name,
/// a line each.
pub fn child(dir: &Path, store: &str, test: &str, accounts: usize, records: usize) {
let before = rss_kib();
match test {
// The first read of each account, then records by path one after another.
"get" => {
let s = Store::open(store, dir, accounts, 1);
let firsts: Vec<Want> = (0..accounts)
.map(|a| {
let i = Rng::of(&[SEED, 6, a as u64]).below(records as u64);
(
a,
data::path(SEED, i * accounts as u64 + a as u64 + 1, a as u64),
)
})
.collect();
say_times(
"first",
&each(&firsts, 0, |(a, path)| {
black_box(s.get(0, *a, path));
}),
);
let open = rss_kib();
say("rss_before", before as f64);
say("rss_open", open as f64);
let wants = wants(1, LOOKUPS, accounts, records, false);
for (name, order) in [("cold", 1), ("warm", 2)] {
say_times(
name,
&each(&wants, order, |(a, path)| {
black_box(s.get(0, *a, path));
}),
);
}
say("rss_after", rss_kib() as f64);
}
// Records by path from 16 threads, each its own.
"threads" => {
let s = Store::open(store, dir, accounts, THREADS);
let wants: Vec<Vec<Want>> = (0..THREADS)
.map(|t| wants(100 + t as u64, EACH, accounts, records, false))
.collect();
// The accounts opened first, so that both passes time reads alone.
match &s {
Store::Db { .. } => (0..THREADS).for_each(|t| s.touch(t, 0)),
_ => (0..accounts).for_each(|a| s.touch(0, a)),
}
for name in ["cold", "warm"] {
let started = Instant::now();
std::thread::scope(|scope| {
for (t, mine) in wants.iter().enumerate() {
let s = &s;
scope.spawn(move || {
for (a, path) in mine {
black_box(s.get(t, *a, path));
}
});
}
});
say(
name,
(THREADS * EACH) as f64 / started.elapsed().as_secs_f64(),
);
}
}
// Listings of 50 records from a path.
"list" => {
let s = Store::open(store, dir, accounts, 1);
let wants = wants(2, LISTINGS, accounts, records, true);
for (name, order) in [("cold", 1), ("warm", 2)] {
say_times(
name,
&each(&wants, order, |(a, path)| {
assert_eq!(s.list(0, *a, path).0, LISTED, "a whole listing");
}),
);
}
}
_ => panic!("no test named {test}"),
}
}
/// Run a child and read its figures, the store's files read through first.
fn measure(
dir: &Path,
store: &str,
test: &str,
accounts: usize,
records: usize,
) -> HashMap<String, f64> {
crate::util::read_through(&dir.join(files(store)));
let out = std::process::Command::new(std::env::current_exe().expect("this program"))
.arg("reads-child")
.arg(dir)
.args([store, test, &accounts.to_string(), &records.to_string()])
.stderr(std::process::Stdio::inherit())
.output()
.expect("a child");
assert!(out.status.success(), "reading {store} ({test}) failed");
String::from_utf8_lossy(&out.stdout)
.lines()
.filter_map(|l| {
let (name, value) = l.split_once(' ')?;
Some((name.to_string(), value.parse().ok()?))
})
.collect()
}
/// See that the table at `before`, which this benchmark wrote in the
/// layout before, is one of the version before that `Table` reads, and
/// holds the entries of the table at `now`.
fn same_entries(now: &Path, before: &Path) {
let cache = BlockCache::new(CACHE);
let entries = |path: &Path, version: Version| {
let t = Table::open(path, &cache).expect("a table");
assert_eq!(t.version(), version, "{}", path.display());
t.iter(b"", None, &cache)
.map(|e| e.expect("the table read"))
.collect::<Vec<_>>()
};
assert!(
entries(now, Version::WRITTEN) == entries(before, Version::Sha256),
"the layout before holds other entries"
);
}
pub fn reads(accounts: usize, records: usize) {
assert!(records > LISTED, "more records than a listing");
let dir = scratch("reads");
std::thread::scope(|s| {
s.spawn(|| {
stores::build_trees(
&dir,
accounts,
records,
&[Pack::Snappy, Pack::None],
&[fj::Pack::Lz4, fj::Pack::None],
)
});
stores::build(&dir, accounts, records);
});
let share = share();
let as_the_server = format!(
"a table for each account, as the server reads one, at most {share} of their files open"
);
let stores = [
("tables", as_the_server.as_str(), ""),
(
"dbs",
"SQLite for each account",
"4 KiB pages | none | held open",
),
("db", "one SQLite for all", "4 KiB pages | none | held open"),
(
"rocks",
"one RocksDB for all, its blocks compressed (Snappy)",
"4 KiB before Snappy | XXH3 | held open",
),
(
"rocks-plain",
"one RocksDB for all, its blocks as they are",
"4 KiB | XXH3 | held open",
),
(
"fjall",
"one fjall for all, its blocks compressed below the second level (LZ4)",
"4 KiB before LZ4 | XXH3 | held open",
),
(
"fjall-plain",
"one fjall for all, its blocks as they are",
"4 KiB | XXH3 | held open",
),
];
let figures: Vec<[HashMap<String, f64>; 3]> = stores
.iter()
.map(|(store, _, _)| {
["get", "threads", "list"].map(|test| measure(&dir, store, test, accounts, records))
})
.collect();
println!(
"{accounts} accounts of {records} realistic records each. Cold is a process that has read nothing, its accounts open, the store's files read through just before, so in the system's cache if it has the memory to keep them; warm is the same reads again, everything they touch held by the process.\n"
);
println!(
"| store | a record by path, cold: p50 µs | p99 µs | warm: p50 µs | p99 µs | on {THREADS} threads, cold: per s | warm: per s |"
);
println!("|---|--:|--:|--:|--:|--:|--:|");
for ((_, name, _), [get, threads, _]) in stores.iter().zip(&figures) {
println!(
"| {name} | {:.1} | {:.1} | {:.1} | {:.1} | {:.0} | {:.0} |",
get["cold_p50"],
get["cold_p99"],
get["warm_p50"],
get["warm_p99"],
threads["cold"],
threads["warm"]
);
}
println!(
"\n| store | a listing of {LISTED} records, cold: p50 µs | p99 µs | warm: p50 µs | p99 µs | first read of an account not yet open: p50 µs | p99 µs |"
);
println!("|---|--:|--:|--:|--:|--:|--:|");
for ((_, name, _), [get, _, list]) in stores.iter().zip(&figures) {
println!(
"| {name} | {:.0} | {:.0} | {:.0} | {:.0} | {:.0} | {:.0} |",
list["cold_p50"],
list["cold_p99"],
list["warm_p50"],
list["warm_p99"],
get["first_p50"],
get["first_p99"]
);
}
println!(
"\n| store | resident before any is open, MiB | with {accounts} open, a record read from each, MiB | KiB an account | after {LOOKUPS} more records, twice, MiB | MiB on disk | KiB an account |"
);
println!("|---|--:|--:|--:|--:|--:|--:|");
for ((store, name, _), [get, _, _]) in stores.iter().zip(&figures) {
let disk = if store.starts_with("fjall") {
fj::disk(&dir.join(store))
} else {
dir_bytes(&dir.join(store))
};
println!(
"| {name} | {:.1} | {:.1} | {:.1} | {:.1} | {:.0} | {:.0} |",
get["rss_before"] / 1024.0,
get["rss_open"] / 1024.0,
(get["rss_open"] - get["rss_before"]) / accounts as f64,
get["rss_after"] / 1024.0,
mib(disk),
disk as f64 / 1024.0 / accounts as f64,
);
}
// The tables' entries again in the layout before, and each other way
// of reading a table.
std::fs::create_dir_all(dir.join("tables16")).expect("a directory");
par(accounts, cores(), |a| {
let table = std::fs::read(stores::table_path(&dir, a)).expect("a table");
std::fs::write(
dir.join(format!("tables16/{a}.table")),
tables::reblocked(&table, 16 << 10),
)
.expect("a table");
});
same_entries(&stores::table_path(&dir, 0), &dir.join("tables16/0.table"));
let blocks = format!("{} KiB", BLOCK >> 10);
// The check of the tables as they are written, and of the layout before.
let own = tables::held(Version::WRITTEN).name();
let before = tables::held(Version::Sha256).name();
println!(
"\nThe tables read other ways. By `pds_store::table::Table`: as the server reads one (as above), its block cache holding at most {share} of the tables' files open, the server's share of the file descriptors this process may have, the least recently read closed to make room and opened again when next read; and with every file held open, whatever the share. By this benchmark's reader, which holds every file open, keeps the blocks it reads in a map for each table where `Table` has one cache for all, has no bloom filter, and computes the check named over each block it reads: {own} is the one these files hold, and is compared with it; each other is compared with nothing. And by that reader from the layout before, a table of the version before: the same entries in blocks of 16 KiB, each block's last key whole in the index, its check {before}, which that file holds and is compared with, the file opened for each block read. The first read of an account is its table opened and a record read.\n"
);
println!(
"| read by | blocks | check | file | a record by path, cold: p50 µs | p99 µs | a listing of {LISTED}, cold: p50 µs | p99 µs | first read of an account: p50 µs | p99 µs | on {THREADS} threads, cold: per s | warm: per s |"
);
println!("|---|---|---|---|--:|--:|--:|--:|--:|--:|--:|--:|");
let way = |cells: &str, [get, threads, list]: &[HashMap<String, f64>; 3]| {
println!(
"| {cells} | {:.1} | {:.1} | {:.0} | {:.0} | {:.0} | {:.0} | {:.0} | {:.0} |",
get["cold_p50"],
get["cold_p99"],
list["cold_p50"],
list["cold_p99"],
get["first_p50"],
get["first_p99"],
threads["cold"],
threads["warm"]
);
};
way(
&format!("`Table`, as the server's | {blocks} | {own} | at most {share} held open"),
&figures[0],
);
let mut ways = vec![(
"tables+open".to_string(),
format!("`Table`, every file open | {blocks} | {own} | all held open"),
)];
ways.extend(Check::ALL.map(|c| {
(
format!("tables:{}", c.name()),
format!("this benchmark's | {blocks} | {} | all held open", c.name()),
)
}));
ways.push((
format!("tables16:{before}+each"),
format!("this benchmark's, the layout before | 16 KiB, last keys whole | {before} | opened for each block"),
));
for (name, cells) in ways {
way(
&cells,
&["get", "threads", "list"].map(|test| measure(&dir, &name, test, accounts, records)),
);
}
for ((_, name, cells), figures) in stores.iter().zip(&figures).skip(1) {
way(&format!("{name} | {cells}"), figures);
}
let _ = std::fs::remove_dir_all(&dir);
}