feat: vendor midstream and sublinear-time-solver libraries

Add ruvnet/midstream (AIMDS real-time inference) and
ruvnet/sublinear-time-solver (sublinear optimization algorithms)
as vendored dependencies under vendor/.

Co-Authored-By: claude-flow <ruv@ruv.net>
This commit is contained in:
ruv
2026-03-02 23:32:45 -05:00
parent 14902e6b4e
commit e91bb8a1d5
1600 changed files with 1852646 additions and 0 deletions
@@ -0,0 +1,293 @@
# 🚀 Temporal Neural Solver Benchmark Suite
**Critical Validation: Sub-Millisecond P99.9 Latency Achievement**
This comprehensive benchmark suite validates the breakthrough performance of the Temporal Neural Solver approach, comparing System A (traditional micro-net) with System B (temporal solver net) across multiple performance dimensions.
## 🎯 Success Criteria
### Primary Objectives
1. **Sub-Millisecond Latency**: System B achieves P99.9 latency < 0.9ms
2. **Performance Improvement**: ≥20% latency improvement over System A
3. **Gate Performance**: Pass rate ≥90% with average certificate error ≤0.02
### Research Impact
Validate that solver-gated neural networks achieve unprecedented performance while maintaining mathematical guarantees through certificate verification.
## 📊 Benchmark Components
### 1. Latency Benchmark (`benches/latency_benchmark.rs`)
**Objective**: Measure end-to-end prediction latency with high precision
**Key Metrics**:
- P50, P90, P95, P99, P99.9, P99.99 latency percentiles
- Phase-by-phase latency breakdown (ingestion, prior, network, gate, finalization)
- Success rates and error analysis
- Warmup handling for stable measurements
**Target Validation**: P99.9 < 0.9ms for System B
### 2. Throughput Benchmark (`benches/throughput_benchmark.rs`)
**Objective**: Measure prediction throughput under various load conditions
**Key Metrics**:
- Predictions per second at different batch sizes
- Multi-threaded performance scaling
- Memory usage patterns
- CPU utilization analysis
- Error rates under load
**Test Configurations**:
- Batch sizes: 1, 4, 8, 16, 32, 64, 128
- Thread counts: 1, 2, 4, 8
- Load duration: 30 seconds per configuration
### 3. System Comparison (`benches/system_comparison.rs`)
**Objective**: Head-to-head comparison across multiple scenarios
**Key Metrics**:
- Comprehensive latency analysis
- Gate pass rates (System B only)
- Certificate error measurements
- Resource efficiency comparison
- Reliability and success rates
**Test Scenarios**:
- Small sequences (32×4)
- Medium sequences (64×4)
- Large sequences (128×4)
- Wide features (64×8)
- Narrow features (64×2)
### 4. Statistical Analysis (`benches/statistical_analysis.rs`)
**Objective**: Rigorous statistical validation of performance differences
**Statistical Tests**:
- Paired t-tests for mean differences
- Mann-Whitney U tests for distribution differences
- Bootstrap confidence intervals
- Effect size calculations (Cohen's d, Glass's Δ, Hedge's g)
- Power analysis
**Effect Size Classifications**:
- Negligible: < 0.2
- Small: 0.2 - 0.5
- Medium: 0.5 - 0.8
- Large: > 0.8
## 🚀 Quick Start
### Prerequisites
```bash
# Install Rust toolchain
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Install dependencies
cargo build --release
```
### Running Benchmarks
#### Option 1: Complete Benchmark Suite (Recommended)
```bash
# Run all benchmarks with comprehensive reporting
./scripts/run_all_benchmarks.sh
```
#### Option 2: Individual Benchmarks
```bash
# Latency analysis
cargo bench --bench latency_benchmark
# Throughput analysis
cargo bench --bench throughput_benchmark
# System comparison
cargo bench --bench system_comparison
# Statistical validation
cargo bench --bench statistical_analysis
```
#### Option 3: Quick Verification
```bash
# Verify benchmarks compile and run basic tests
./scripts/verify_benchmarks.sh
```
## 📋 Benchmark Configuration
### Performance Targets
- **Latency Budget (per tick)**:
- Ingestion: 0.10ms
- Prior computation: 0.10ms
- Neural network: 0.30ms
- Solver gate: 0.20ms
- Finalization: 0.10ms
- **Total P99.9 ≤ 0.90ms**
### Test Parameters
- **Sample sizes**: 10,000 - 100,000 measurements
- **Input dimensions**: 64×4 (sequence × features)
- **Output dimensions**: 2
- **Warmup iterations**: 10,000
- **Statistical confidence**: 95%
### System Configurations
#### System A (Traditional Micro-Net)
- Direct end-to-end prediction
- Standard GRU/TCN architecture
- FP32 training, INT8 inference
- No mathematical verification
#### System B (Temporal Solver Net)
- Kalman filter prior integration
- Residual learning approach
- Sublinear solver gating
- Mathematical certificates with error bounds
- PageRank-based active selection
## 📊 Output Reports
### Generated Artifacts
1. **`BREAKTHROUGH_VALIDATION_REPORT.md`** - Main validation report
2. **`latency_benchmark_report.md`** - Detailed latency analysis
3. **`throughput_benchmark_report.md`** - Throughput performance
4. **`system_comparison_report.md`** - Head-to-head comparison
5. **`statistical_analysis_report.md`** - Statistical validation
6. **`benchmark_run.log`** - Complete execution log
7. **`index.html`** - Interactive results browser
### Report Structure
Each report includes:
- Executive summary with key findings
- Detailed metric tables
- Performance comparisons
- Success criteria validation
- Statistical significance analysis
- Visualizations and interpretations
## 🔬 Methodology
### Measurement Precision
- High-resolution timing using `std::time::Instant`
- Nanosecond precision for latency measurements
- Proper warmup phases to ensure stable measurements
- Multiple measurement rounds for statistical validity
### Statistical Rigor
- Paired comparisons to control for input variability
- Multiple statistical tests for robustness
- Effect size calculations for practical significance
- Bootstrap methods for confidence intervals
- Power analysis for sample adequacy
### Reproducibility
- Deterministic random seeds for consistent results
- Comprehensive configuration documentation
- Version-controlled benchmark suite
- Standardized execution environment
## 🏆 Success Validation
The benchmark suite validates success through:
1. **Performance Thresholds**: Direct measurement against latency targets
2. **Statistical Significance**: Rigorous hypothesis testing (p < 0.05)
3. **Effect Size**: Meaningful practical differences (Cohen's d > 0.5)
4. **Consistency**: Results across multiple test scenarios
5. **Reliability**: Gate pass rates and certificate compliance
### Breakthrough Criteria
-**Criterion 1**: System B P99.9 latency < 0.9ms
-**Criterion 2**: ≥20% latency improvement over System A
-**Criterion 3**: Gate pass rate ≥90% with cert error ≤0.02
## 🔧 Advanced Usage
### Custom Configurations
```bash
# Run with custom sample size
MEASUREMENT_SAMPLES=50000 cargo bench --bench latency_benchmark
# Extended statistical analysis
STATISTICAL_SAMPLES=20000 cargo bench --bench statistical_analysis
```
### Profiling Integration
```bash
# Profile latency bottlenecks
cargo bench --bench latency_benchmark --profile
# Memory profiling
valgrind --tool=massif cargo bench --bench throughput_benchmark
```
### Continuous Integration
```bash
# Automated validation in CI/CD
./scripts/run_all_benchmarks.sh --ci-mode --timeout=3600
```
## 📈 Performance Optimization
### System Tuning
- CPU governor set to 'performance'
- Isolated CPU cores for benchmarking
- Disabled CPU frequency scaling
- Minimized system background processes
### Memory Management
- Pre-allocated test data to avoid allocation overhead
- Proper memory warming for consistent measurements
- Memory usage tracking and optimization
## 🚨 Troubleshooting
### Common Issues
#### Compilation Errors
```bash
# Update dependencies
cargo update
# Clean rebuild
cargo clean && cargo build --release
```
#### Performance Variations
```bash
# Verify system state
./scripts/verify_benchmarks.sh
# Check CPU governor
cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
```
#### Timeout Issues
```bash
# Extend timeouts for slower systems
TIMEOUT_MULTIPLIER=2 ./scripts/run_all_benchmarks.sh
```
### Getting Help
- Check benchmark logs in `benchmark_results/`
- Review individual benchmark reports for detailed diagnostics
- Verify system prerequisites and configuration
## 🎉 Expected Results
Based on the temporal neural solver breakthrough:
- **System B P99.9 latency**: 0.7-0.8ms (vs 0.9ms target)
- **Latency improvement**: 25-35% over System A
- **Gate pass rate**: 92-95%
- **Certificate error**: 0.015-0.018 average
- **Throughput improvement**: 15-25% at optimal batch sizes
This represents a **significant breakthrough** in real-time neural prediction systems, achieving unprecedented sub-millisecond performance with mathematical guarantees.
---
**🚀 Ready to validate the breakthrough? Run `./scripts/run_all_benchmarks.sh` and witness the future of temporal neural networks!**