#![forbid(unsafe_code)]
use std::{
alloc::System,
cmp::Ordering as CmpOrdering,
env,
error::Error,
hint::black_box,
path::{Path, PathBuf},
sync::{
Arc, OnceLock,
atomic::{AtomicI64, AtomicU64, Ordering},
},
time::{Duration, Instant, SystemTime, UNIX_EPOCH},
};
use datum_persistence::{
AppendOutcome, AtomicWrite, Journal, PersistenceId, PostgresPersistence,
PostgresPersistenceConfig, RocksDbBackend, SequenceNr, SerializedPayload, SerializerId,
StoredEvent, Tag,
projection::{
BoundaryEvent, CassandraProjectionOffsetStore, CassandraProjectionOffsetStoreConfig,
CursorPosition, DeduplicationBoundary, ExactlyOncePostgresHandler, GroupConfig,
GroupedExactlyOncePostgresHandler, Handler, MemoryProjectionOffsetStore,
PostgresProjectionOffsetStore, PostgresProjectionOffsetStoreConfig, PostgresProjectionTx,
Projection, ProjectionCursor, ProjectionError, ProjectionGroup, ProjectionId,
ProjectionOffsetStore, ProjectionResult, ProjectionRuntime, ProjectionStatus,
ProviderManifest, RestartBackoff, SaveOffsetConfig, SourceProvider, TestSourceProvider,
},
query::{EventEnvelope, EventsByTagQuery, Offset, QueryMode},
};
use futures_util::{StreamExt, future::join_all};
use sqlx::PgPool;
use stats_alloc::{INSTRUMENTED_SYSTEM, Region, StatsAlloc};
use tokio::runtime::{Builder, Runtime};
#[global_allocator]
static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;
const WARMUP_SAMPLES: usize = 1;
const MEASUREMENT_SAMPLES: usize = 5;
const LATENCY_WARMUP_OPS: usize = 100;
const LATENCY_RECORDED_OPS: usize = 10_000;
const BACKLOG: u64 = 10_000;
const GROUP_SWEEP_BACKLOG: u64 = 12_800;
const PAYLOAD_BYTES: usize = 256;
const POOL_SIZE: u32 = 16;
const RESTART_COUNT: usize = 100;
const SWEEP_INSTANCES: [usize; 7] = [1, 2, 4, 8, 16, 32, 64];
const SAVE_AFTER_ENVELOPES: usize = 100;
const SAVE_AFTER_DURATION: Duration = Duration::from_millis(500);
const GROUP_AFTER_ENVELOPES: usize = 20;
const GROUP_AFTER_DURATION: Duration = Duration::from_millis(500);
static NEXT_ID: AtomicU64 = AtomicU64::new(1);
static NEXT_RUN_ID: AtomicI64 = AtomicI64::new(1);
type BenchError = Box<dyn Error + Send + Sync>;
type BenchResult<T> = Result<T, BenchError>;
#[derive(Clone)]
struct PostgresTagSourceProvider {
query: Arc<dyn EventsByTagQuery>,
tag: Tag,
manifest: ProviderManifest,
}
impl PostgresTagSourceProvider {
fn new(
query: Arc<dyn EventsByTagQuery>,
query_identity: &str,
tag: Tag,
) -> ProjectionResult<Self> {
let manifest = ProviderManifest::new(format!(
"datum-bench-postgres-events-by-tag-v1|query={query_identity}|tag={}",
tag.as_str()
))?;
Ok(Self {
query,
tag,
manifest,
})
}
}
#[async_trait::async_trait]
impl SourceProvider<EventEnvelope> for PostgresTagSourceProvider {
fn manifest(&self) -> &ProviderManifest {
&self.manifest
}
async fn source_from(
&self,
cursor: Option<&ProjectionCursor>,
mode: QueryMode,
) -> ProjectionResult<datum_persistence::projection::ProjectionSource<EventEnvelope>> {
let offset = cursor.map_or(Ok(Offset::NoOffset), |cursor| {
cursor.ensure_manifest(&self.manifest)?;
decode_tag_position(cursor.position())
})?;
let stream = self
.query
.events_by_tag(&self.tag, offset, mode)
.await
.map_err(|error| ProjectionError::Source(error.to_string()))?;
Ok(Box::pin(stream.map(|item| {
item.map_err(|error| ProjectionError::Source(error.to_string()))
})))
}
fn extract_cursor(&self, envelope: &EventEnvelope) -> ProjectionResult<ProjectionCursor> {
let Offset::Timestamp {
epoch_micros,
seq_nr,
} = envelope.offset
else {
return Err(ProjectionError::Source(format!(
"PostgreSQL tag query emitted non-timestamp offset {:?}",
envelope.offset
)));
};
Ok(ProjectionCursor::new(
self.manifest.clone(),
DeduplicationBoundary::with_consumed(
encode_tag_position(epoch_micros, seq_nr),
[BoundaryEvent::new(
envelope.persistence_id.clone(),
envelope.sequence_nr,
)],
),
))
}
fn compare_positions(
&self,
left: &CursorPosition,
right: &CursorPosition,
) -> ProjectionResult<CmpOrdering> {
Ok(decode_tag_position_value(left)?.cmp(&decode_tag_position_value(right)?))
}
}
fn encode_tag_position(epoch_micros: i64, sequence_nr: u64) -> CursorPosition {
CursorPosition::new(format!("bench-pg-tag-v1|{epoch_micros}|{sequence_nr}"))
}
fn decode_tag_position(position: &CursorPosition) -> ProjectionResult<Offset> {
let (epoch_micros, seq_nr) = decode_tag_position_value(position)?;
Ok(Offset::Timestamp {
epoch_micros,
seq_nr,
})
}
fn decode_tag_position_value(position: &CursorPosition) -> ProjectionResult<(i64, u64)> {
let mut fields = position.as_str().split('|');
let version = fields.next();
let micros = fields.next();
let sequence = fields.next();
if version != Some("bench-pg-tag-v1")
|| micros.is_none()
|| sequence.is_none()
|| fields.next().is_some()
{
return Err(ProjectionError::CursorCodec(format!(
"invalid benchmark PostgreSQL tag cursor {:?}",
position.as_str()
)));
}
let epoch_micros = micros
.expect("presence checked")
.parse()
.map_err(|_| ProjectionError::CursorCodec("invalid benchmark timestamp".into()))?;
let seq_nr = sequence
.expect("presence checked")
.parse()
.map_err(|_| ProjectionError::CursorCodec("invalid benchmark sequence".into()))?;
Ok((epoch_micros, seq_nr))
}
struct SqlHandler {
pool: PgPool,
runtime_label: &'static str,
run_id: i64,
processed: Arc<AtomicU64>,
}
#[async_trait::async_trait]
impl Handler<EventEnvelope> for SqlHandler {
async fn process(&mut self, envelope: &EventEnvelope) -> ProjectionResult<()> {
sqlx::query(
"INSERT INTO datum_projection_bench_result \
(runtime, run_id, event_id, payload) VALUES ($1, $2, $3, $4)",
)
.bind(self.runtime_label)
.bind(self.run_id)
.bind(event_id(envelope)?)
.bind(&envelope.payload.payload)
.execute(&self.pool)
.await
.map_err(|error| ProjectionError::Handler(format!("benchmark handler insert: {error}")))?;
self.processed.fetch_add(1, Ordering::Relaxed);
Ok(())
}
}
struct ExactlyOnceSqlHandler {
runtime_label: &'static str,
run_id: i64,
processed: Arc<AtomicU64>,
}
#[async_trait::async_trait]
impl ExactlyOncePostgresHandler<EventEnvelope> for ExactlyOnceSqlHandler {
async fn process(
&mut self,
transaction: &mut PostgresProjectionTx,
envelope: &EventEnvelope,
) -> ProjectionResult<()> {
transaction
.execute(
sqlx::query(
"INSERT INTO datum_projection_bench_result \
(runtime, run_id, event_id, payload) VALUES ($1, $2, $3, $4)",
)
.bind(self.runtime_label)
.bind(self.run_id)
.bind(event_id(envelope)?)
.bind(&envelope.payload.payload),
)
.await?;
self.processed.fetch_add(1, Ordering::Relaxed);
Ok(())
}
}
struct GroupedExactlyOnceSqlHandler {
runtime_label: &'static str,
run_id: i64,
processed: Arc<AtomicU64>,
}
#[async_trait::async_trait]
impl GroupedExactlyOncePostgresHandler<EventEnvelope> for GroupedExactlyOnceSqlHandler {
async fn process(
&mut self,
transaction: &mut PostgresProjectionTx,
envelopes: &[EventEnvelope],
) -> ProjectionResult<()> {
for envelope in envelopes {
transaction
.execute(
sqlx::query(
"INSERT INTO datum_projection_bench_result \
(runtime, run_id, event_id, payload) VALUES ($1, $2, $3, $4)",
)
.bind(self.runtime_label)
.bind(self.run_id)
.bind(event_id(envelope)?)
.bind(&envelope.payload.payload),
)
.await?;
}
self.processed
.fetch_add(envelopes.len() as u64, Ordering::Relaxed);
Ok(())
}
}
struct CountingHandler {
processed: Arc<AtomicU64>,
}
#[async_trait::async_trait]
impl Handler<EventEnvelope> for CountingHandler {
async fn process(&mut self, _envelope: &EventEnvelope) -> ProjectionResult<()> {
self.processed.fetch_add(1, Ordering::Relaxed);
Ok(())
}
}
struct EmptyHandler;
#[async_trait::async_trait]
impl Handler<datum_persistence::projection::TestEnvelope<u64>> for EmptyHandler {
async fn process(
&mut self,
_envelope: &datum_persistence::projection::TestEnvelope<u64>,
) -> ProjectionResult<()> {
Ok(())
}
}
fn main() -> BenchResult<()> {
let database_url =
env::var("DATABASE_URL").map_err(|_| "DATABASE_URL is required for projection_compare")?;
let runtime = Builder::new_multi_thread()
.worker_threads(16)
.enable_all()
.build()?;
println!(
"scenario\tkind\tbackend\twork_items\trecorded_ops\tmean_us\twall_p50_us\twall_p99_us\tcpu_us_per_op\talloc_count_per_op\talloc_bytes_per_op\tthread_count\tpeak_rss_kib\tnotes"
);
run(&runtime, &database_url)
}
fn run(runtime: &Runtime, database_url: &str) -> BenchResult<()> {
let run_token = format!(
"{}-{}",
std::process::id(),
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_nanos()
);
let mut journal_config = PostgresPersistenceConfig::new(database_url);
journal_config.schema = "datum_projection_bench_journal".into();
journal_config.max_connections = POOL_SIZE;
journal_config.replay_page_size = 2_048;
let journal = Arc::new(runtime.block_on(PostgresPersistence::connect(journal_config))?);
let mut offset_config = PostgresProjectionOffsetStoreConfig::new(database_url);
offset_config.schema = "datum_projection_bench_offset".into();
offset_config.max_connections = POOL_SIZE;
let postgres_offsets =
Arc::new(runtime.block_on(PostgresProjectionOffsetStore::connect(offset_config))?);
let handler_pool = postgres_offsets
.pool()
.expect("PostgreSQL offset store must expose its pool")
.clone();
runtime.block_on(
sqlx::query(
"CREATE TABLE IF NOT EXISTS datum_projection_bench_result (\
runtime TEXT NOT NULL, run_id BIGINT NOT NULL, event_id BIGINT NOT NULL, payload BYTEA NOT NULL)",
)
.execute(&handler_pool),
)?;
let steady_tag = Tag::new(format!("projection-steady-{run_token}"));
runtime.block_on(seed_events(
journal.as_ref(),
PersistenceId::new(format!("projection-steady-{run_token}"), "entity-0")?,
BACKLOG,
|_event| vec![steady_tag.clone()],
))?;
let group_tag_prefix = format!("projection-group-{run_token}");
runtime.block_on(seed_events(
journal.as_ref(),
PersistenceId::new(format!("projection-group-{run_token}"), "entity-0")?,
GROUP_SWEEP_BACKLOG,
|event| {
SWEEP_INSTANCES
.into_iter()
.map(|instances| {
Tag::new(format!(
"{group_tag_prefix}-n{instances}-{}",
event as usize % instances
))
})
.collect()
},
))?;
let query: Arc<dyn EventsByTagQuery> = journal.clone();
let provider = PostgresTagSourceProvider::new(
query.clone(),
"datum_projection_bench_journal",
steady_tag,
)?;
let memory_offsets = Arc::new(MemoryProjectionOffsetStore::new());
measure_throughput(
"alo_memory_offset_10k",
"memory",
BACKLOG,
"Datum-only · PostgreSQL journal · PostgreSQL handler SQL · memory cursor · 100/500ms",
|| {
runtime.block_on(run_alo_once(
provider.clone(),
memory_offsets.clone(),
handler_pool.clone(),
))
},
)?;
measure_throughput(
"alo_pg_offset_10k",
"postgres",
BACKLOG,
"PostgreSQL journal/offset/handler · synchronous commit · 100/500ms",
|| {
runtime.block_on(run_alo_once(
provider.clone(),
postgres_offsets.clone(),
handler_pool.clone(),
))
},
)?;
measure_throughput(
"exactly_once_pg_10k",
"postgres",
BACKLOG,
"PostgreSQL exactly-once · one handler row + cursor in each transaction",
|| {
runtime.block_on(run_exactly_once_once(
provider.clone(),
postgres_offsets.clone(),
))
},
)?;
measure_throughput(
"grouped_exactly_once_pg_10k",
"postgres",
BACKLOG,
"PostgreSQL grouped exactly-once · 20/500ms · one row per envelope",
|| runtime.block_on(run_grouped_once(provider.clone(), postgres_offsets.clone())),
)?;
measure_throughput(
"restart_machinery_pg_100",
"postgres",
RESTART_COUNT as u64,
"100 source materialization failures · zero delay/jitter · PostgreSQL cursor reload",
|| runtime.block_on(run_restart_once(postgres_offsets.clone())),
)?;
for instances in SWEEP_INSTANCES {
let scenario = format!("projection_group_tags_n_{instances}");
let note = "Datum-only · no Akka local ProjectionGroup equivalent · fixed 12,800-event tag backlog";
measure_throughput(&scenario, "memory", GROUP_SWEEP_BACKLOG, note, || {
runtime.block_on(run_group_sweep_once(
query.clone(),
&group_tag_prefix,
instances,
))
})?;
}
run_offset_store_benches(
runtime,
"memory",
Arc::new(MemoryProjectionOffsetStore::new()),
"Datum-only · in-memory fenced cursor store",
)?;
run_offset_store_benches(
runtime,
"postgres",
postgres_offsets,
"PostgreSQL · generation + expected-position CAS · synchronous commit",
)?;
{
let directory = TemporaryDatabasePath::new("projection-rocksdb");
let rocksdb = Arc::new(RocksDbBackend::open(directory.path())?);
run_offset_store_benches(
runtime,
"rocksdb",
rocksdb,
"Datum-only · RocksDB synchronous WAL",
)?;
}
if let Ok(node) = env::var("CASSANDRA_NODE")
&& !node.trim().is_empty()
{
let cassandra = Arc::new(runtime.block_on(CassandraProjectionOffsetStore::connect(
CassandraProjectionOffsetStoreConfig::new(node, "datum_projection_bench_cass"),
))?);
run_offset_store_benches(
runtime,
"cassandra",
cassandra,
"Cassandra 5 · AMO-priced per-envelope LWT save · LOCAL_QUORUM/LOCAL_SERIAL",
)?;
} else {
eprintln!("SKIP Cassandra projection offsets: CASSANDRA_NODE is not set");
}
Ok(())
}
async fn run_alo_once<S>(
provider: PostgresTagSourceProvider,
store: Arc<S>,
pool: PgPool,
) -> ProjectionResult<u64>
where
S: ProjectionOffsetStore + 'static,
{
let processed = Arc::new(AtomicU64::new(0));
let handler_counter = processed.clone();
let run_id = NEXT_RUN_ID.fetch_add(1, Ordering::Relaxed);
let projection =
Projection::at_least_once(next_projection_id("alo"), provider, move || SqlHandler {
pool: pool.clone(),
runtime_label: "datum",
run_id,
processed: handler_counter.clone(),
})
.with_query_mode(QueryMode::Current)
.with_save_offset(SaveOffsetConfig {
after_envelopes: SAVE_AFTER_ENVELOPES,
after_duration: SAVE_AFTER_DURATION,
});
let handle = projection
.spawn(ProjectionRuntime::new(
store as Arc<dyn ProjectionOffsetStore>,
))
.await?;
ensure_completed(handle.wait().await?)?;
let count = processed.load(Ordering::Relaxed);
ensure_count(count, BACKLOG)?;
Ok(count)
}
async fn run_exactly_once_once(
provider: PostgresTagSourceProvider,
store: Arc<PostgresProjectionOffsetStore>,
) -> ProjectionResult<u64> {
let processed = Arc::new(AtomicU64::new(0));
let handler_counter = processed.clone();
let run_id = NEXT_RUN_ID.fetch_add(1, Ordering::Relaxed);
let projection = Projection::exactly_once_postgres(
next_projection_id("exactly-once"),
provider,
move || ExactlyOnceSqlHandler {
runtime_label: "datum",
run_id,
processed: handler_counter.clone(),
},
)
.with_query_mode(QueryMode::Current);
let handle = projection
.spawn(ProjectionRuntime::new(
store as Arc<dyn ProjectionOffsetStore>,
))
.await?;
ensure_completed(handle.wait().await?)?;
let count = processed.load(Ordering::Relaxed);
ensure_count(count, BACKLOG)?;
Ok(count)
}
async fn run_grouped_once(
provider: PostgresTagSourceProvider,
store: Arc<PostgresProjectionOffsetStore>,
) -> ProjectionResult<u64> {
let processed = Arc::new(AtomicU64::new(0));
let handler_counter = processed.clone();
let run_id = NEXT_RUN_ID.fetch_add(1, Ordering::Relaxed);
let projection = Projection::grouped_exactly_once_postgres(
next_projection_id("grouped-exactly-once"),
provider,
move || GroupedExactlyOnceSqlHandler {
runtime_label: "datum",
run_id,
processed: handler_counter.clone(),
},
)
.with_query_mode(QueryMode::Current)
.with_group(GroupConfig {
group_after_envelopes: GROUP_AFTER_ENVELOPES,
group_after_duration: GROUP_AFTER_DURATION,
});
let handle = projection
.spawn(ProjectionRuntime::new(
store as Arc<dyn ProjectionOffsetStore>,
))
.await?;
ensure_completed(handle.wait().await?)?;
let count = processed.load(Ordering::Relaxed);
ensure_count(count, BACKLOG)?;
Ok(count)
}
async fn run_restart_once(store: Arc<PostgresProjectionOffsetStore>) -> ProjectionResult<u64> {
let provider = TestSourceProvider::<u64>::new(Vec::new());
provider.complete()?;
for attempt in 0..RESTART_COUNT {
provider.fail_next_materialization(ProjectionError::Source(format!(
"fixed benchmark failure {attempt}"
)))?;
}
let projection =
Projection::at_least_once(next_projection_id("restart"), provider.clone(), || {
EmptyHandler
})
.with_query_mode(QueryMode::Current)
.with_restart_backoff(RestartBackoff {
min_backoff: Duration::ZERO,
max_backoff: Duration::ZERO,
random_factor: 0.0,
max_restarts: None,
max_restarts_within: Duration::ZERO,
});
let handle = projection
.spawn(ProjectionRuntime::new(
store as Arc<dyn ProjectionOffsetStore>,
))
.await?;
ensure_completed(handle.wait().await?)?;
let materializations = provider.materializations()? as u64;
ensure_count(materializations, RESTART_COUNT as u64 + 1)?;
Ok(materializations - 1)
}
async fn run_group_sweep_once(
query: Arc<dyn EventsByTagQuery>,
tag_prefix: &str,
instances: usize,
) -> ProjectionResult<u64> {
let processed = Arc::new(AtomicU64::new(0));
let keys = (0..instances)
.map(|instance| format!("{tag_prefix}-n{instances}-{instance}"))
.collect::<Vec<_>>();
let name = format!(
"projection-group-bench-{}",
NEXT_ID.fetch_add(1, Ordering::Relaxed)
);
let template_query = query.clone();
let template_count = processed.clone();
let group = ProjectionGroup::for_keys(name, keys, move |projection_id| {
let tag = Tag::new(projection_id.key());
let provider = PostgresTagSourceProvider::new(
template_query.clone(),
"datum_projection_bench_journal",
tag,
)
.expect("fixed group tag provider is valid");
let handler_count = template_count.clone();
Projection::at_least_once(projection_id, provider, move || CountingHandler {
processed: handler_count.clone(),
})
.with_query_mode(QueryMode::Current)
.with_save_offset(SaveOffsetConfig {
after_envelopes: SAVE_AFTER_ENVELOPES,
after_duration: SAVE_AFTER_DURATION,
})
});
let handles = group
.spawn(ProjectionRuntime::new(Arc::new(
MemoryProjectionOffsetStore::new(),
)))
.await?;
let statuses = join_all(handles.instances().map(|handle| handle.wait())).await;
for status in statuses {
ensure_completed(status?)?;
}
let count = processed.load(Ordering::Relaxed);
ensure_count(count, GROUP_SWEEP_BACKLOG)?;
Ok(count)
}
fn run_offset_store_benches<S>(
runtime: &Runtime,
backend: &str,
store: Arc<S>,
note: &str,
) -> ProjectionResult<()>
where
S: ProjectionOffsetStore + 'static,
{
let save_id = next_projection_id(&format!("offset-save-{backend}"));
let generation = runtime.block_on(store.claim(&save_id))?;
let manifest = ProviderManifest::new(format!("datum-bench-offset-{backend}-v1"))?;
let mut expected: Option<CursorPosition> = None;
let mut next_position = 1_u64;
let save_scenario = if backend == "cassandra" {
"offset_save_cassandra_amo_lwt".to_owned()
} else {
format!("offset_save_{backend}")
};
measure_latency(&save_scenario, backend, note, || {
let position = CursorPosition::new(next_position.to_string());
let cursor = ProjectionCursor::from_position(manifest.clone(), position.clone());
runtime.block_on(store.save(&save_id, generation, expected.as_ref(), cursor))?;
expected = Some(position);
next_position += 1;
Ok(next_position)
})?;
let load_id = next_projection_id(&format!("offset-load-{backend}"));
let load_generation = runtime.block_on(store.claim(&load_id))?;
runtime.block_on(store.save(
&load_id,
load_generation,
None,
ProjectionCursor::from_position(manifest, "seed"),
))?;
measure_latency(&format!("offset_load_{backend}"), backend, note, || {
let loaded = runtime.block_on(store.load(&load_id))?;
Ok(loaded.map_or(0, |_| 1))
})
}
fn measure_throughput<E, F>(
scenario: &str,
backend: &str,
work_items: u64,
notes: &str,
mut run: F,
) -> Result<(), E>
where
F: FnMut() -> Result<u64, E>,
{
if !scenario_enabled(scenario) {
return Ok(());
}
for _ in 0..WARMUP_SAMPLES {
black_box(run()?);
}
let mut samples = Vec::with_capacity(MEASUREMENT_SAMPLES);
let region = Region::new(GLOBAL);
let cpu_start = process_cpu_ns();
let mut checksum = 0_u64;
for _ in 0..MEASUREMENT_SAMPLES {
let started = Instant::now();
checksum = checksum.wrapping_add(black_box(run()?));
samples.push(started.elapsed());
}
let cpu_ns = process_cpu_ns().saturating_sub(cpu_start);
let allocation = region.change();
black_box(checksum);
let snapshot = process_snapshot();
let mean_us = samples.iter().map(duration_us).sum::<f64>() / samples.len() as f64;
let operations = MEASUREMENT_SAMPLES as f64;
let alloc_count = (allocation.allocations + allocation.reallocations) as f64 / operations;
let alloc_bytes = allocation.bytes_allocated as f64 / operations;
let cpu_us = cpu_ns as f64 / 1_000.0 / operations;
println!(
"{scenario}\tthroughput\t{backend}\t{work_items}\t0\t{mean_us:.3}\t\t\t\
{cpu_us:.3}\t{alloc_count:.3}\t{alloc_bytes:.3}\t{}\t{}\t{notes}",
snapshot.thread_count, snapshot.peak_rss_kib
);
Ok(())
}
fn measure_latency<F>(
scenario: &str,
backend: &str,
notes: &str,
mut run: F,
) -> ProjectionResult<()>
where
F: FnMut() -> ProjectionResult<u64>,
{
if !scenario_enabled(scenario) {
return Ok(());
}
for _ in 0..LATENCY_WARMUP_OPS {
black_box(run()?);
}
let mut samples = Vec::with_capacity(LATENCY_RECORDED_OPS);
let region = Region::new(GLOBAL);
let cpu_start = process_cpu_ns();
let mut checksum = 0_u64;
for _ in 0..LATENCY_RECORDED_OPS {
let started = Instant::now();
checksum = checksum.wrapping_add(black_box(run()?));
samples.push(started.elapsed());
}
let cpu_ns = process_cpu_ns().saturating_sub(cpu_start);
let allocation = region.change();
black_box(checksum);
let snapshot = process_snapshot();
let p50_us = duration_us(&percentile_duration(&mut samples.clone(), 50));
let p99_us = duration_us(&percentile_duration(&mut samples, 99));
let operations = LATENCY_RECORDED_OPS as f64;
let alloc_count = (allocation.allocations + allocation.reallocations) as f64 / operations;
let alloc_bytes = allocation.bytes_allocated as f64 / operations;
let cpu_us = cpu_ns as f64 / 1_000.0 / operations;
println!(
"{scenario}\tlatency\t{backend}\t1\t{LATENCY_RECORDED_OPS}\t\t{p50_us:.3}\t\
{p99_us:.3}\t{cpu_us:.3}\t{alloc_count:.3}\t{alloc_bytes:.3}\t{}\t{}\t{notes}",
snapshot.thread_count, snapshot.peak_rss_kib
);
Ok(())
}
async fn seed_events<F>(
journal: &PostgresPersistence,
persistence_id: PersistenceId,
count: u64,
tags: F,
) -> datum_persistence::PersistenceResult<()>
where
F: Fn(u64) -> Vec<Tag>,
{
const CHUNK: u64 = 1_000;
let mut next = 1_u64;
while next <= count {
let end = (next + CHUNK - 1).min(count);
let events = (next..=end)
.map(|sequence_nr| StoredEvent {
persistence_id: persistence_id.clone(),
sequence_nr: SequenceNr::new(sequence_nr),
adapter_manifest: String::new(),
writer_uuid: "datum-projection-compare".into(),
timestamp_ms: sequence_nr as i64,
metadata: None,
payload: benchmark_payload(sequence_nr),
tags: tags(sequence_nr),
})
.collect();
let outcome = journal.append_one(AtomicWrite::new(events)?).await?;
if outcome != AppendOutcome::Accepted {
return Err(datum_persistence::PersistenceError::Failure(format!(
"projection benchmark fixture append rejected: {outcome:?}"
)));
}
next = end + 1;
}
Ok(())
}
fn benchmark_payload(event_id: u64) -> SerializedPayload {
let mut bytes = vec![0xA5; PAYLOAD_BYTES];
bytes[..size_of::<u64>()].copy_from_slice(&event_id.to_be_bytes());
SerializedPayload::new(SerializerId::new(9_119), "datum-projection-bench-v1", bytes)
}
fn event_id(envelope: &EventEnvelope) -> ProjectionResult<i64> {
let bytes = envelope
.payload
.payload
.get(..size_of::<u64>())
.ok_or_else(|| {
ProjectionError::Handler("benchmark payload is shorter than 8 bytes".into())
})?;
let mut id = [0_u8; size_of::<u64>()];
id.copy_from_slice(bytes);
i64::try_from(u64::from_be_bytes(id))
.map_err(|_| ProjectionError::Handler("benchmark event id exceeds BIGINT".into()))
}
fn ensure_completed(status: ProjectionStatus) -> ProjectionResult<()> {
if status == ProjectionStatus::Completed {
Ok(())
} else {
Err(ProjectionError::Runtime(format!(
"benchmark projection ended as {status:?}"
)))
}
}
fn ensure_count(actual: u64, expected: u64) -> ProjectionResult<()> {
if actual == expected {
Ok(())
} else {
Err(ProjectionError::Runtime(format!(
"benchmark processed {actual} items, expected {expected}"
)))
}
}
fn next_projection_id(label: &str) -> ProjectionId {
ProjectionId::new(
"projection-compare",
format!(
"{label}-{}-{}",
std::process::id(),
NEXT_ID.fetch_add(1, Ordering::Relaxed)
),
)
}
fn percentile_duration(samples: &mut [Duration], percentile: usize) -> Duration {
if samples.is_empty() {
return Duration::ZERO;
}
samples.sort_unstable();
let rank = (samples.len() - 1) * percentile / 100;
samples[rank]
}
fn duration_us(duration: &Duration) -> f64 {
duration.as_nanos() as f64 / 1_000.0
}
fn process_cpu_ns() -> u128 {
let Ok(stat) = std::fs::read_to_string("/proc/self/stat") else {
return 0;
};
let Some(close) = stat.rfind(')') else {
return 0;
};
let fields: Vec<&str> = stat[close + 1..].split_whitespace().collect();
if fields.len() <= 12 {
return 0;
}
let utime: u64 = fields[11].parse().unwrap_or(0);
let stime: u64 = fields[12].parse().unwrap_or(0);
(utime as u128 + stime as u128) * 10_000_000
}
struct ProcessSnapshot {
peak_rss_kib: u64,
thread_count: u64,
}
fn process_snapshot() -> ProcessSnapshot {
let Ok(status) = std::fs::read_to_string("/proc/self/status") else {
return ProcessSnapshot {
peak_rss_kib: 0,
thread_count: 0,
};
};
let mut peak_rss_kib = 0_u64;
let mut thread_count = 0_u64;
for line in status.lines() {
if let Some(rest) = line.strip_prefix("VmHWM:") {
peak_rss_kib = first_u64(rest);
} else if let Some(rest) = line.strip_prefix("Threads:") {
thread_count = first_u64(rest);
}
}
ProcessSnapshot {
peak_rss_kib,
thread_count,
}
}
fn first_u64(input: &str) -> u64 {
input
.split_whitespace()
.next()
.and_then(|value| value.parse().ok())
.unwrap_or(0)
}
fn scenario_enabled(name: &str) -> bool {
static FILTER: OnceLock<Option<Vec<String>>> = OnceLock::new();
FILTER
.get_or_init(|| {
env::var("DATUM_PROJECTION_COMPARE_FILTER")
.ok()
.map(|value| {
value
.split(',')
.map(str::trim)
.filter(|candidate| !candidate.is_empty())
.map(ToOwned::to_owned)
.collect::<Vec<_>>()
})
.filter(|candidates| !candidates.is_empty())
})
.as_ref()
.is_none_or(|candidates| candidates.iter().any(|candidate| name.contains(candidate)))
}
struct TemporaryDatabasePath {
path: PathBuf,
}
impl TemporaryDatabasePath {
fn new(label: &str) -> Self {
let timestamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_nanos();
let path = env::temp_dir().join(format!(
"datum-projection-compare-{label}-{}-{timestamp}",
std::process::id()
));
Self { path }
}
fn path(&self) -> &Path {
&self.path
}
}
impl Drop for TemporaryDatabasePath {
fn drop(&mut self) {
if let Err(error) = std::fs::remove_dir_all(&self.path)
&& error.kind() != std::io::ErrorKind::NotFound
{
eprintln!(
"warning: failed to remove temporary projection benchmark database {}: {error}",
self.path.display()
);
}
}
}