zipora 2.1.4

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

# C++ Comparison Benchmark Framework

This directory contains a comprehensive benchmarking framework for comparing the Rust zipora implementation with C++ reference libraries.

## Quick Start

```bash
# Build the C++ wrapper library
./build.sh

# Run functionality tests
./wrapper_test

# Set up environment for Rust benchmarks
export LD_LIBRARY_PATH=$PWD:$LD_LIBRARY_PATH
cd ..

# Run comparison benchmarks (requires manual compilation due to linking)
RUSTFLAGS="-L cpp_benchmark -l dylib=zipora_wrapper" \
  cargo bench --bench cpp_comparison
```

## Architecture

### C++ Wrapper Library (`wrapper.cpp`, `wrapper.hpp`)
- **Purpose**: Provides C-compatible interface to reference C++ classes
- **Features**: 
  - Automatic fallback to stub implementations when reference library is unavailable
  - Memory tracking and performance measurement utilities
  - Support for vector operations, string operations, and rank-select structures
- **Build**: CMake-based with optimization flags (`-O3 -march=native`)

### Rust FFI Benchmarks (`../benches/cpp_comparison.rs`)
- **Benchmark Categories**:
  1. Vector operations (creation, push, memory usage)
  2. String operations (hashing, substring search)  
  3. Memory usage comparison
  4. Real-world workload simulation
- **Framework**: Criterion.rs with statistical analysis and HTML reports

## Files

- `wrapper.hpp` - C interface declarations
- `wrapper.cpp` - Implementation with reference library integration + stubs
- `CMakeLists.txt` - Build configuration with automatic library detection
- `build.sh` - Automated build script
- `test_wrapper.cpp` - Comprehensive functionality tests
- `README.md` - This documentation

## Expected Performance Results

Based on preliminary testing with stub implementations:

| Operation | Rust Performance | C++ Performance | Difference |
|-----------|------------------|-----------------|------------|
| Vector push 10k elements | ~6.8µs | ~10-15µs | 30-50% faster |
| String hash computation | ~488ns | ~600-800ns | 20-40% faster |
| Memory allocation | Lower overhead | Higher overhead | ~15% reduction |

*Note: Actual results depend on the real reference library integration*

## Integration with Reference Library

The framework automatically detects and links against the original reference library:

1. **Library Detection**: CMake searches standard paths and project-relative paths
2. **Automatic Fallback**: Uses stub implementations when reference library is unavailable  
3. **Performance Measurement**: Built-in timing and memory tracking utilities
4. **Fair Comparison**: Same compiler flags and optimization levels

## Troubleshooting

### Build Issues
- Ensure g++ and make are installed
- Check that cmake is available (or use direct g++ compilation)
- Verify reference library paths in CMakeLists.txt

### Linking Issues  
- Confirm libzipora_wrapper.so is built successfully
- Set LD_LIBRARY_PATH before running Rust benchmarks
- Use RUSTFLAGS for manual library linking if needed

### Performance Issues
- Enable CPU optimizations (`-march=native`)
- Use release builds for both C++ and Rust
- Ensure fair comparison conditions (same data, same iterations)