tidaldb/tidal/benches/ranking.rs

#![allow(clippy::unwrap_used)]

//! Criterion benchmarks for the ranking profile executor.
//!
//! Measures scoring latency for 200 candidates across different profiles:
//! - `trending`: exercises velocity reads + gate filtering
//! - `hot`: exercises view count reads + age computation
//! - `full_pipeline`: trending with gates (filter + sort + normalize)

use std::time::Duration;

use criterion::{Criterion, black_box, criterion_group, criterion_main};
use tidaldb::{
    ranking::{ProfileExecutor, ProfileRegistry, builtins::register_builtins},
    schema::{DecaySpec, EntityId, EntityKind, SchemaBuilder, Timestamp, Window},
    signals::{NoopWalWriter, SignalLedger},
};

#[allow(clippy::cast_precision_loss)]
fn make_ledger_with_200_items() -> SignalLedger {
    let mut builder = SchemaBuilder::new();
    for sig in &["view", "share", "like"] {
        let _ = builder
            .signal(
                sig,
                EntityKind::Item,
                DecaySpec::Exponential {
                    half_life: Duration::from_secs(7 * 24 * 3600),
                },
            )
            .windows(&[Window::OneHour, Window::SevenDays])
            .velocity(true)
            .add();
    }
    let schema = builder.build().unwrap();
    let ledger = SignalLedger::new(schema, Box::new(NoopWalWriter));
    let base_ns = 1_708_000_000_000_000_000u64;
    for i in 0u64..200 {
        let entity_id = EntityId::new(i + 1);
        let ts = Timestamp::from_nanos(base_ns - i * 3_600_000_000_000);
        ledger
            .record_signal("view", entity_id, (200 - i) as f64, ts)
            .unwrap();
        ledger
            .record_signal("share", entity_id, (i % 10) as f64, ts)
            .unwrap();
        ledger
            .record_signal("like", entity_id, (i % 5) as f64, ts)
            .unwrap();
    }
    ledger
}

fn bench_score_200_trending(c: &mut Criterion) {
    let ledger = make_ledger_with_200_items();
    let mut registry = ProfileRegistry::new();
    register_builtins(&mut registry).unwrap();
    let profile = registry.get("trending").unwrap().clone();
    let executor = ProfileExecutor::new(&ledger);
    let candidates: Vec<EntityId> = (1..=200).map(EntityId::new).collect();
    let now = Timestamp::from_nanos(1_708_000_000_000_000_000u64);

    c.bench_function("score_200_trending", |b| {
        b.iter(|| executor.score(black_box(&candidates), black_box(&profile), black_box(now)));
    });
}

fn bench_score_200_hot(c: &mut Criterion) {
    let ledger = make_ledger_with_200_items();
    let mut registry = ProfileRegistry::new();
    register_builtins(&mut registry).unwrap();
    let profile = registry.get("hot").unwrap().clone();
    let executor = ProfileExecutor::new(&ledger);
    let candidates: Vec<EntityId> = (1..=200).map(EntityId::new).collect();
    let now = Timestamp::from_nanos(1_708_000_000_000_000_000u64);

    c.bench_function("score_200_hot", |b| {
        b.iter(|| executor.score(black_box(&candidates), black_box(&profile), black_box(now)));
    });
}

fn bench_score_200_full_pipeline(c: &mut Criterion) {
    let ledger = make_ledger_with_200_items();
    let mut registry = ProfileRegistry::new();
    register_builtins(&mut registry).unwrap();
    let profile = registry.get("trending").unwrap().clone();
    let executor = ProfileExecutor::new(&ledger);
    let candidates: Vec<EntityId> = (1..=200).map(EntityId::new).collect();
    let now = Timestamp::from_nanos(1_708_000_000_000_000_000u64);

    c.bench_function("score_200_full_pipeline", |b| {
        b.iter(|| executor.score(black_box(&candidates), black_box(&profile), black_box(now)));
    });
}

// ── T2: signal-value pre-pass (one `entries.get()` per signal type) ──────────
//
// `for_you` reads `view` twice per candidate at *different* aggregations
// (`Sort::Hot` reads `view` Value; a boost reads `view` DecayScore), so the
// pre-pass collapses two `DashMap` gets to one. The win is a shard-lock saved,
// so it is small single-threaded and grows under concurrent signal-write
// contention — hence the `_under_writes` variants. `with_signal_plan(false)`
// scores the same inputs through the direct per-term path for a true A/B.

fn for_you_profile() -> tidaldb::ranking::profile::RankingProfile {
    let mut registry = ProfileRegistry::new();
    register_builtins(&mut registry).unwrap();
    registry.get("for_you").unwrap().clone()
}

fn bench_for_you_plan(c: &mut Criterion) {
    let ledger = make_ledger_with_200_items();
    let profile = for_you_profile();
    let candidates: Vec<EntityId> = (1..=200).map(EntityId::new).collect();
    let now = Timestamp::from_nanos(1_708_000_000_000_000_000u64);

    for plan in [true, false] {
        let executor = ProfileExecutor::new(&ledger).with_signal_plan(plan);
        let id = if plan {
            "for_you_plan"
        } else {
            "for_you_no_plan"
        };
        c.bench_function(id, |b| {
            b.iter(|| executor.score(black_box(&candidates), black_box(&profile), black_box(now)));
        });
    }
}

#[allow(clippy::cast_precision_loss)]
fn bench_for_you_under_writes(c: &mut Criterion) {
    use std::sync::{
        Arc,
        atomic::{AtomicBool, Ordering},
    };

    let profile = for_you_profile();
    let candidates: Vec<EntityId> = (1..=200).map(EntityId::new).collect();
    let now = Timestamp::from_nanos(1_708_000_000_000_000_000u64);

    let mut group = c.benchmark_group("for_you_under_writes");
    group.measurement_time(Duration::from_secs(8));

    for plan in [true, false] {
        let ledger = Arc::new(make_ledger_with_200_items());
        let stop = Arc::new(AtomicBool::new(false));
        // Four writers continuously record `view`/`like` signals, contending the
        // same shards the scorer reads — the scenario where collapsing gets pays.
        let writers: Vec<_> = (0..4u64)
            .map(|w| {
                let ledger = Arc::clone(&ledger);
                let stop = Arc::clone(&stop);
                std::thread::spawn(move || {
                    let mut i = w;
                    while !stop.load(Ordering::Relaxed) {
                        let eid = EntityId::new((i % 200) + 1);
                        let ts = Timestamp::from_nanos(1_708_000_000_000_000_000u64 + i * 1000);
                        let _ = ledger.record_signal("view", eid, 1.0, ts);
                        let _ = ledger.record_signal("like", eid, 1.0, ts);
                        i += 4;
                    }
                })
            })
            .collect();

        let executor = ProfileExecutor::new(&ledger).with_signal_plan(plan);
        let id = if plan { "plan" } else { "no_plan" };
        group.bench_function(id, |b| {
            b.iter(|| executor.score(black_box(&candidates), black_box(&profile), black_box(now)));
        });

        stop.store(true, Ordering::Relaxed);
        for w in writers {
            w.join().unwrap();
        }
    }
    group.finish();
}

criterion_group!(
    benches,
    bench_score_200_trending,
    bench_score_200_hot,
    bench_score_200_full_pipeline,
    bench_for_you_plan,
    bench_for_you_under_writes
);
criterion_main!(benches);