delta-stream 0.32.0

State-aware delta synchronization and recovery for realtime Rust applications
Documentation
use crate::{byte_sync::ByteStateDecoder, error::DeltaError, v30_sync::FastByteStateEncoder};
use std::time::Instant;

fn entropy_bytes(len: usize) -> Vec<u8> {
    let mut x = 0x9E3779B97F4A7C15u64;
    (0..len)
        .map(|_| {
            x ^= x << 7;
            x ^= x >> 9;
            x ^= x << 8;
            x as u8
        })
        .collect()
}

pub fn print_fast_encoder_benchmark(
    state_size: usize,
    updates: usize,
    change_percent: f64,
) -> Result<(), DeltaError> {
    println!("=== DeltaStream V30 Fast Encoder Benchmark ===");
    println!("state size       : {state_size} bytes");
    println!("updates          : {updates}");
    println!("change/update    : {change_percent:.3}%");
    let mut state = entropy_bytes(state_size);
    let mut enc = FastByteStateEncoder::new("v30/bench");
    let mut dec = ByteStateDecoder::new("v30/bench");
    let changes = ((state_size as f64 * change_percent / 100.0).round() as usize)
        .max(1)
        .min(state_size.max(1));
    let mut bytes = 0u64;
    let started = Instant::now();
    for update in 0..updates {
        if update > 0 {
            for n in 0..changes {
                let i = (update.wrapping_mul(97).wrapping_add(n.wrapping_mul(7919))) % state.len();
                state[i] ^= (update as u8).wrapping_add(n as u8).wrapping_add(1);
            }
        }
        let p = enc.encode(&state)?;
        bytes += p.encoded_len() as u64;
        let _ = dec.apply(p)?;
    }
    let elapsed = started.elapsed();
    let logical = state_size as u64 * updates as u64;
    let saving = if logical == 0 {
        0.0
    } else {
        (1.0 - bytes as f64 / logical as f64) * 100.0
    };
    println!("wire bytes        : {bytes}");
    println!("saving            : {saving:.2}%");
    println!("wall time         : {:.3} s", elapsed.as_secs_f64());
    println!(
        "updates/sec       : {:.0}",
        updates as f64 / elapsed.as_secs_f64().max(f64::EPSILON)
    );
    println!(
        "avg candidates    : {:.2}",
        enc.metrics().selector_candidates as f64 / enc.metrics().encoded_packets.max(1) as f64
    );
    println!(
        "final convergence : {}",
        if dec.state() == Some(state.as_slice()) {
            "PASS ✓"
        } else {
            "FAIL"
        }
    );
    Ok(())
}

pub fn print_partial_repair_demo() -> Result<(), DeltaError> {
    use crate::partial_repair::PartialRepair;
    let base = entropy_bytes(1024 * 1024);
    let mut target = base.clone();
    for byte in target.iter_mut().take(132 * 1024).skip(128 * 1024) {
        *byte ^= 0x5A;
    }
    let repair = PartialRepair::build(&base, &target, 1024);
    let repaired = repair.apply(&base)?;
    println!("=== DeltaStream V30 Partial Repair ===");
    println!("state bytes       : {}", target.len());
    println!("changed chunks    : {}", repair.patches.len());
    println!("repair bytes      : {}", repair.payload_bytes());
    println!(
        "saving vs snapshot: {:.2}%",
        (1.0 - repair.payload_bytes() as f64 / target.len() as f64) * 100.0
    );
    println!(
        "exact repair      : {}",
        if repaired == target {
            "PASS ✓"
        } else {
            "FAIL"
        }
    );
    Ok(())
}