lsm 0.4.1

An implementation of log-structured merge trees in pure Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use clap::Parser;

use tempfile::{Builder, TempDir};

use tracing_subscriber::prelude::*;
use tracing_tracy::TracyLayer;

use lsm::{Database, Params, StartMode, WriteOptions};

#[derive(Parser)]
#[clap(author, version, about, long_about = None)]
struct Args {
    #[clap(long)]
    enable_tracing: bool,
    #[clap(long)]
    log_level_stats: Option<String>,
    #[clap(long, default_value = "100000")]
    num_entries: usize,
}

async fn bench_init(args: &Args) -> (TempDir, Database) {
    if args.enable_tracing {
        tracing_subscriber::registry()
            .with(TracyLayer::default())
            .init();
    }

    let _ = env_logger::builder().is_test(true).try_init();
    let tmp_dir = Builder::new()
        .prefix("lsm-async-benchmark-")
        .tempdir()
        .unwrap();

    let mut db_path = tmp_dir.path().to_path_buf();
    db_path.push("storage.lsm");

    let params = Params {
        db_path,
        log_level_stats: args.log_level_stats.clone(),
        ..Default::default()
    };
    const SM: StartMode = StartMode::CreateOrOverride;

    let database = Database::new_with_params(SM, params)
        .await
        .expect("Failed to create database instance");

    (tmp_dir, database)
}

async fn main_inner() {
    let args = Args::parse();

    let (_tmpdir, database) = bench_init(&args).await;

    log::info!("Starting read/write benchmark");

    let options = WriteOptions { sync: false };

    log::debug!("Writing {} entries", args.num_entries);

    for pos in 0..args.num_entries {
        let key = format!("{pos}").into_bytes();
        let value = format!("some_string_{pos}").into_bytes();
        database.put_opts(key, value, &options).await.unwrap();
    }

    log::debug!("Reading {} entries", args.num_entries);

    for pos in 0..args.num_entries {
        let key = format!("{pos}").into_bytes();
        let expected = format!("some_string_{pos}").into_bytes();

        assert_eq!(
            database.get(&key).await.unwrap().unwrap().get_value(),
            expected,
        );
    }

    database.stop().await.unwrap();
    log::info!("Done");
}

#[cfg(feature = "async-io")]
fn main() {
    tokio_uring::start(async {
        main_inner().await;
    });
}

#[cfg(not(feature = "async-io"))]
#[tokio::main]
async fn main() {
    main_inner().await;
}