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
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408

//! Comprehensive benchmarks for IntVec<T> bit-packed integer storage
//!
//! This benchmark suite validates the performance targets for IntVec<T>:
//! - 60-80% space reduction compared to Vec<T>
//! - Hardware-accelerated compression/decompression
//! - O(1) random access performance
//! - Adaptive compression strategy selection

use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId, Throughput};
use std::time::Duration;
use zipora::containers::specialized::{IntVec, UintVector};

/// Generate test data with different compression characteristics
struct TestDataGenerator;

impl TestDataGenerator {
    /// Sorted sequence - excellent for delta compression
    fn sorted_sequence(size: usize) -> Vec<u32> {
        (0..size as u32).collect()
    }

    /// Small range data - excellent for min-max compression
    fn small_range(size: usize) -> Vec<u32> {
        (0..size).map(|i| (i % 1000) as u32).collect()
    }

    /// Sparse data with larger gaps
    fn sparse_data(size: usize) -> Vec<u32> {
        (0..size).map(|i| (i * 113 + 1000) as u32).collect()
    }

    /// Random data - challenging for compression
    fn random_data(size: usize) -> Vec<u32> {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};
        
        (0..size).map(|i| {
            let mut hasher = DefaultHasher::new();
            i.hash(&mut hasher);
            (hasher.finish() % 1_000_000) as u32
        }).collect()
    }

    /// Nearly identical values - great for run-length encoding potential
    fn nearly_identical(size: usize) -> Vec<u32> {
        (0..size).map(|i| 42 + (i % 3) as u32).collect()
    }

    /// Large values near u32::MAX
    fn large_values(size: usize) -> Vec<u32> {
        (0..size).map(|i| u32::MAX - (i % 10000) as u32).collect()
    }
}

/// Benchmark compression ratio and memory efficiency
fn benchmark_compression_ratio(c: &mut Criterion) {
    let sizes = vec![1000, 10000, 100000];
    
    let mut group = c.benchmark_group("compression_ratio");
    
    for size in sizes {
        // Test different data patterns
        let test_cases = vec![
            ("sorted", TestDataGenerator::sorted_sequence(size)),
            ("small_range", TestDataGenerator::small_range(size)),
            ("sparse", TestDataGenerator::sparse_data(size)),
            ("random", TestDataGenerator::random_data(size)),
            ("nearly_identical", TestDataGenerator::nearly_identical(size)),
            ("large_values", TestDataGenerator::large_values(size)),
        ];

        for (pattern, data) in test_cases {
            let original_size = data.len() * 4; // u32 = 4 bytes
            
            group.bench_with_input(
                BenchmarkId::new("IntVec", format!("{}_{}_{}", pattern, size, "compression")),
                &data,
                |b, data| {
                    b.iter(|| {
                        let compressed = IntVec::<u32>::from_slice(black_box(data)).unwrap();
                        let ratio = compressed.compression_ratio();
                        let memory_usage = compressed.memory_usage();
                        
                        // Validate compression targets
                        if pattern == "sorted" || pattern == "small_range" || pattern == "nearly_identical" {
                            assert!(ratio < 0.5, "Should achieve >50% compression for {}", pattern);
                        }
                        
                        black_box((ratio, memory_usage))
                    })
                },
            );

            // Compare with UintVector for compatibility
            group.bench_with_input(
                BenchmarkId::new("UintVector", format!("{}_{}_{}", pattern, size, "compression")),
                &data,
                |b, data| {
                    b.iter(|| {
                        let compressed = UintVector::build_from(black_box(data)).unwrap();
                        let ratio = compressed.compression_ratio();
                        let memory_usage = compressed.memory_usage();
                        black_box((ratio, memory_usage))
                    })
                },
            );
        }
    }
    
    group.finish();
}

/// Benchmark construction performance
fn benchmark_construction(c: &mut Criterion) {
    let sizes = vec![1000, 10000, 100000];
    
    let mut group = c.benchmark_group("construction");
    group.throughput(Throughput::Elements(100000)); // Base throughput
    
    for size in sizes {
        let data = TestDataGenerator::small_range(size);
        
        group.throughput(Throughput::Elements(size as u64));
        
        group.bench_with_input(
            BenchmarkId::new("IntVec", size),
            &data,
            |b, data| {
                b.iter(|| {
                    IntVec::<u32>::from_slice(black_box(data)).unwrap()
                })
            },
        );

        group.bench_with_input(
            BenchmarkId::new("UintVector", size),
            &data,
            |b, data| {
                b.iter(|| {
                    UintVector::build_from(black_box(data)).unwrap()
                })
            },
        );

        // Raw Vec for baseline
        group.bench_with_input(
            BenchmarkId::new("Vec", size),
            &data,
            |b, data| {
                b.iter(|| {
                    let vec: Vec<u32> = black_box(data).to_vec();
                    black_box(vec)
                })
            },
        );
    }
    
    group.finish();
}

/// Benchmark random access performance - should be O(1)
fn benchmark_random_access(c: &mut Criterion) {
    let size = 100000;
    let data = TestDataGenerator::small_range(size);
    let compressed = IntVec::<u32>::from_slice(&data).unwrap();
    let uint_vector = UintVector::build_from(&data).unwrap();
    let vec = data.clone();
    
    // Generate random indices for access
    let indices: Vec<usize> = (0..1000).map(|i| (i * 97) % size).collect();
    
    let mut group = c.benchmark_group("random_access");
    group.throughput(Throughput::Elements(1000));
    
    group.bench_function("IntVec", |b| {
        b.iter(|| {
            for &index in &indices {
                black_box(compressed.get(black_box(index)));
            }
        })
    });

    group.bench_function("UintVector", |b| {
        b.iter(|| {
            for &index in &indices {
                black_box(uint_vector.get(black_box(index)));
            }
        })
    });

    group.bench_function("Vec", |b| {
        b.iter(|| {
            for &index in &indices {
                black_box(vec.get(black_box(index)));
            }
        })
    });
    
    group.finish();
}

/// Benchmark sequential access performance
fn benchmark_sequential_access(c: &mut Criterion) {
    let size = 100000;
    let data = TestDataGenerator::small_range(size);
    let compressed = IntVec::<u32>::from_slice(&data).unwrap();
    let uint_vector = UintVector::build_from(&data).unwrap();
    let vec = data.clone();
    
    let mut group = c.benchmark_group("sequential_access");
    group.throughput(Throughput::Elements(size as u64));
    
    group.bench_function("IntVec", |b| {
        b.iter(|| {
            for i in 0..size {
                black_box(compressed.get(black_box(i)));
            }
        })
    });

    group.bench_function("UintVector", |b| {
        b.iter(|| {
            for i in 0..size {
                black_box(uint_vector.get(black_box(i)));
            }
        })
    });

    group.bench_function("Vec", |b| {
        b.iter(|| {
            for i in 0..size {
                black_box(vec.get(black_box(i)));
            }
        })
    });
    
    group.finish();
}

/// Benchmark different integer types
fn benchmark_integer_types(c: &mut Criterion) {
    let size = 10000;
    
    let mut group = c.benchmark_group("integer_types");
    group.throughput(Throughput::Elements(size as u64));
    
    // Test different integer types
    let u8_data: Vec<u8> = (0..size).map(|i| (i % 256) as u8).collect();
    let u16_data: Vec<u16> = (0..size).map(|i| (i % 65536) as u16).collect();
    let u32_data: Vec<u32> = (0..size).map(|i| (i % 1000000) as u32).collect();
    let u64_data: Vec<u64> = (0..size).map(|i| (i % 1000000) as u64).collect();
    
    let i8_data: Vec<i8> = (0..size).map(|i| ((i % 256) as i8).wrapping_sub(127)).collect();
    let i16_data: Vec<i16> = (0..size).map(|i| ((i % 65536) as i16).wrapping_sub(32767)).collect();
    let i32_data: Vec<i32> = (0..size).map(|i| ((i % 1000000) as i32) - 500000).collect();
    let i64_data: Vec<i64> = (0..size).map(|i| ((i % 1000000) as i64) - 500000).collect();

    group.bench_function("u8", |b| {
        b.iter(|| IntVec::<u8>::from_slice(black_box(&u8_data)).unwrap())
    });

    group.bench_function("u16", |b| {
        b.iter(|| IntVec::<u16>::from_slice(black_box(&u16_data)).unwrap())
    });

    group.bench_function("u32", |b| {
        b.iter(|| IntVec::<u32>::from_slice(black_box(&u32_data)).unwrap())
    });

    group.bench_function("u64", |b| {
        b.iter(|| IntVec::<u64>::from_slice(black_box(&u64_data)).unwrap())
    });

    group.bench_function("i8", |b| {
        b.iter(|| IntVec::<i8>::from_slice(black_box(&i8_data)).unwrap())
    });

    group.bench_function("i16", |b| {
        b.iter(|| IntVec::<i16>::from_slice(black_box(&i16_data)).unwrap())
    });

    group.bench_function("i32", |b| {
        b.iter(|| IntVec::<i32>::from_slice(black_box(&i32_data)).unwrap())
    });

    group.bench_function("i64", |b| {
        b.iter(|| IntVec::<i64>::from_slice(black_box(&i64_data)).unwrap())
    });
    
    group.finish();
}

/// Benchmark memory usage patterns
fn benchmark_memory_patterns(c: &mut Criterion) {
    let sizes = vec![1000, 10000, 100000];
    
    let mut group = c.benchmark_group("memory_efficiency");
    
    for size in sizes {
        let data = TestDataGenerator::small_range(size);
        let original_size = data.len() * 4;
        
        group.bench_with_input(
            BenchmarkId::new("memory_analysis", size),
            &data,
            |b, data| {
                b.iter(|| {
                    let compressed = IntVec::<u32>::from_slice(black_box(data)).unwrap();
                    let memory_usage = compressed.memory_usage();
                    let compression_ratio = compressed.compression_ratio();
                    
                    // Validate memory efficiency
                    assert!(memory_usage < original_size, 
                           "Memory usage {} should be less than original {}", 
                           memory_usage, original_size);
                    
                    black_box((memory_usage, compression_ratio))
                })
            },
        );
    }
    
    group.finish();
}

/// Performance stress test with large datasets
fn benchmark_large_datasets(c: &mut Criterion) {
    let mut group = c.benchmark_group("large_datasets");
    group.sample_size(10); // Fewer samples for large datasets
    group.measurement_time(Duration::from_secs(30)); // Longer measurement time
    
    let sizes = vec![1_000_000, 5_000_000];
    
    for size in sizes {
        let data = TestDataGenerator::small_range(size);
        
        group.throughput(Throughput::Elements(size as u64));
        
        group.bench_with_input(
            BenchmarkId::new("IntVec_large", size),
            &data,
            |b, data| {
                b.iter(|| {
                    let compressed = IntVec::<u32>::from_slice(black_box(data)).unwrap();
                    
                    // Validate compression
                    let ratio = compressed.compression_ratio();
                    assert!(ratio < 0.5, "Should achieve good compression even for large datasets");
                    
                    // Test some random accesses
                    let test_indices = [0, size/4, size/2, 3*size/4, size-1];
                    for &idx in &test_indices {
                        black_box(compressed.get(idx));
                    }
                    
                    compressed
                })
            },
        );
    }
    
    group.finish();
}

/// Benchmark hardware acceleration features
fn benchmark_hardware_acceleration(c: &mut Criterion) {
    let size = 50000;
    let data = TestDataGenerator::sparse_data(size);
    
    let mut group = c.benchmark_group("hardware_acceleration");
    group.throughput(Throughput::Elements(size as u64));
    
    // Focus on bit manipulation intensive operations
    group.bench_function("bit_width_calculation", |b| {
        b.iter(|| {
            let compressed = IntVec::<u32>::from_slice(black_box(&data)).unwrap();
            // The compression process includes bit width calculations
            black_box(compressed)
        })
    });

    // Test decompression performance (bit extraction)
    let compressed = IntVec::<u32>::from_slice(&data).unwrap();
    group.bench_function("bit_extraction", |b| {
        b.iter(|| {
            // Extract all values to test bit manipulation performance
            for i in 0..size {
                black_box(compressed.get(black_box(i)));
            }
        })
    });
    
    group.finish();
}

criterion_group!(
    benches,
    benchmark_compression_ratio,
    benchmark_construction,
    benchmark_random_access,
    benchmark_sequential_access,
    benchmark_integer_types,
    benchmark_memory_patterns,
    benchmark_large_datasets,
    benchmark_hardware_acceleration
);

criterion_main!(benches);