ipfrs 0.2.0

Next-generation distributed file system with content-addressing, semantic search, and logic programming
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Benchmarks for block storage operations

use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use ipfrs::{Node, NodeConfig};
use std::hint::black_box;
use tokio::runtime::Runtime;

/// Benchmark block put operations
fn bench_block_put(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();
    let mut group = c.benchmark_group("block_put");

    // Test different block sizes
    for size in [1024, 10 * 1024, 100 * 1024, 1024 * 1024].iter() {
        group.throughput(Throughput::Bytes(*size as u64));
        group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
            b.to_async(&rt).iter(|| async {
                let mut node = Node::new(NodeConfig::default()).unwrap();
                node.start().await.unwrap();

                let data = vec![0u8; size];
                let cid = black_box(node.add_bytes(data.clone()).await.unwrap());

                node.stop().await.unwrap();
                cid
            });
        });
    }
    group.finish();
}

/// Benchmark block get operations
fn bench_block_get(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();
    let mut group = c.benchmark_group("block_get");

    for size in [1024, 10 * 1024, 100 * 1024, 1024 * 1024].iter() {
        group.throughput(Throughput::Bytes(*size as u64));
        group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
            // Setup: Add block first
            let cid = rt.block_on(async {
                let mut node = Node::new(NodeConfig::default()).unwrap();
                node.start().await.unwrap();
                let data = vec![0u8; size];
                let cid = node.add_bytes(data.clone()).await.unwrap();
                node.stop().await.unwrap();
                cid
            });

            b.to_async(&rt).iter(|| async {
                let mut node = Node::new(NodeConfig::default()).unwrap();
                node.start().await.unwrap();

                let block = black_box(node.get(&cid).await.unwrap());

                node.stop().await.unwrap();
                block
            });
        });
    }
    group.finish();
}

/// Benchmark block stat operations (metadata only)
fn bench_block_stat(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();
    let mut group = c.benchmark_group("block_stat");

    // Setup: Add some blocks
    let cids = rt.block_on(async {
        let mut node = Node::new(NodeConfig::default()).unwrap();
        node.start().await.unwrap();

        let mut cids = Vec::new();
        for size in [1024, 10 * 1024, 100 * 1024] {
            let data = vec![0u8; size];
            cids.push(node.add_bytes(data).await.unwrap());
        }

        node.stop().await.unwrap();
        cids
    });

    group.bench_function("block_stat", |b| {
        b.to_async(&rt).iter(|| async {
            let mut node = Node::new(NodeConfig::default()).unwrap();
            node.start().await.unwrap();

            for cid in &cids {
                let _stat = black_box(node.block_stat(cid).await.unwrap());
            }

            node.stop().await.unwrap();
        });
    });
    group.finish();
}

/// Benchmark batch block operations
fn bench_batch_put(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();
    let mut group = c.benchmark_group("batch_put");

    for count in [10, 50, 100].iter() {
        let total_bytes = count * 1024; // Each block is 1KB
        group.throughput(Throughput::Bytes(total_bytes as u64));
        group.bench_with_input(BenchmarkId::from_parameter(count), count, |b, &count| {
            b.to_async(&rt).iter(|| async {
                let mut node = Node::new(NodeConfig::default()).unwrap();
                node.start().await.unwrap();

                let mut cids = Vec::new();
                for _ in 0..count {
                    let data = vec![0u8; 1024];
                    cids.push(node.add_bytes(data.clone()).await.unwrap());
                }

                node.stop().await.unwrap();
                black_box(cids)
            });
        });
    }
    group.finish();
}

criterion_group!(
    benches,
    bench_block_put,
    bench_block_get,
    bench_block_stat,
    bench_batch_put
);
criterion_main!(benches);