zipora 3.1.5

High-performance Rust implementation providing advanced data structures and compression algorithms with memory safety guarantees. Features LRU page cache, sophisticated caching layer, fiber-based concurrency, real-time compression, secure memory pools, SIMD optimizations, and complete C FFI for migration from C++.
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

use zipora::IntVec;
use std::time::Instant;

fn main() -> Result<(), zipora::ZiporaError> {
    // Test dataset: 100,000 u32 elements
    let test_data: Vec<u32> = (0..100_000).collect();
    let data_size_mb = (test_data.len() * 4) as f64 / 1_024_000.0;
    
    println!("Testing IntVec performance with {} elements ({:.2} MB)", 
             test_data.len(), data_size_mb);
    println!("{}", "=".repeat(60));
    
    // Warm up
    for _ in 0..3 {
        let _ = IntVec::from_slice(&test_data)?;
        let _ = IntVec::from_slice_bulk(&test_data)?;
    }
    
    // Test regular from_slice
    let mut regular_times = Vec::new();
    for _ in 0..10 {
        let start = Instant::now();
        let _vec = IntVec::from_slice(&test_data)?;
        let elapsed = start.elapsed();
        regular_times.push(elapsed);
    }
    
    // Test bulk from_slice_bulk
    let mut bulk_times = Vec::new();
    for _ in 0..10 {
        let start = Instant::now();
        let _vec = IntVec::from_slice_bulk(&test_data)?;
        let elapsed = start.elapsed();
        bulk_times.push(elapsed);
    }
    
    // Calculate statistics
    let regular_avg = regular_times.iter().sum::<std::time::Duration>() / regular_times.len() as u32;
    let bulk_avg = bulk_times.iter().sum::<std::time::Duration>() / bulk_times.len() as u32;
    
    let regular_throughput = data_size_mb / regular_avg.as_secs_f64();
    let bulk_throughput = data_size_mb / bulk_avg.as_secs_f64();
    
    let speedup = bulk_throughput / regular_throughput;
    
    println!("\nResults (average of 10 runs):");
    println!("Regular from_slice:");
    println!("  Time: {:.3} ms", regular_avg.as_secs_f64() * 1000.0);
    println!("  Throughput: {:.1} MB/s", regular_throughput);
    
    println!("\nBulk from_slice_bulk:");
    println!("  Time: {:.3} ms", bulk_avg.as_secs_f64() * 1000.0);
    println!("  Throughput: {:.1} MB/s", bulk_throughput);
    
    println!("\nSpeedup: {:.2}x", speedup);
    
    if speedup >= 1.0 {
        println!("✅ PASS: Bulk constructor is faster!");
    } else {
        println!("❌ FAIL: Bulk constructor is slower (target: ≥1.0x)");
    }
    
    Ok(())
}