7.3 KiB
7.3 KiB
Visual SpaceTime Explorer
Interactive visualization tool for understanding and exploring space-time tradeoffs in algorithms and systems.
Features
- Interactive Plots: Pan, zoom, and explore tradeoff curves in real-time
- Live Parameter Updates: See immediate impact of changing data sizes and strategies
- Multiple Visualizations: Memory hierarchy, checkpoint intervals, cost analysis, 3D views
- Educational Mode: Learn theoretical concepts through visual demonstrations
- Export Capabilities: Save analyses and plots for presentations or reports
Installation
# From sqrtspace-tools root directory
pip install matplotlib numpy
# For full features including animations
pip install matplotlib numpy scipy
Quick Start
from explorer import SpaceTimeVisualizer
# Launch interactive explorer
visualizer = SpaceTimeVisualizer()
visualizer.create_main_window()
# The explorer will open with:
# - Main tradeoff curves
# - Memory hierarchy view
# - Checkpoint visualization
# - Cost analysis
# - Performance metrics
# - 3D space-time-cost plot
Interactive Controls
Sliders
- Data Size: Adjust n from 100 to 1 billion (log scale)
- See how different algorithms scale with data size
Radio Buttons
- Strategy: Choose between sqrt_n, linear, log_n, constant
- View: Switch between tradeoff, animated, comparison views
Mouse Controls
- Pan: Click and drag on plots
- Zoom: Scroll wheel or right-click drag
- Reset: Double-click to reset view
Export Button
- Save current analysis as JSON
- Export plots as high-resolution PNG
Visualization Types
1. Main Tradeoff Curves
Shows theoretical and practical space-time tradeoffs:
# The main plot displays:
- O(n) space algorithms (standard)
- O(√n) space algorithms (Williams' bound)
- O(log n) space algorithms (compressed)
- O(1) space algorithms (streaming)
- Feasible region (gray shaded area)
- Current configuration (red dot)
2. Memory Hierarchy View
Visualizes data distribution across cache levels:
# Shows how data is placed in:
- L1 Cache (32KB, 1ns)
- L2 Cache (256KB, 3ns)
- L3 Cache (8MB, 12ns)
- RAM (32GB, 100ns)
- SSD (512GB, 10μs)
3. Checkpoint Intervals
Compares different checkpointing strategies:
# Strategies visualized:
- No checkpointing (full memory)
- √n intervals (optimal)
- Fixed intervals (e.g., every 1000)
- Exponential intervals (doubling)
4. Cost Analysis
Breaks down costs by component:
# Cost factors:
- Memory cost (cloud storage)
- Time cost (compute hours)
- Total cost (combined)
- Comparison across strategies
5. Performance Metrics
Radar chart showing multiple dimensions:
# Metrics evaluated:
- Memory Efficiency (0-100%)
- Speed (0-100%)
- Fault Tolerance (0-100%)
- Scalability (0-100%)
- Cost Efficiency (0-100%)
6. 3D Visualization
Three-dimensional view of space-time-cost:
# Axes:
- X: log₁₀(Space)
- Y: log₁₀(Time)
- Z: log₁₀(Cost)
# Shows tradeoff surfaces for different strategies
Example Visualizations
Run comprehensive examples:
python example_visualizations.py
This creates four sets of visualizations:
1. Algorithm Comparison
- Sorting algorithms (QuickSort vs MergeSort vs External Sort)
- Search structures (Array vs BST vs Hash vs B-tree)
- Matrix multiplication strategies
- Graph algorithms with memory constraints
2. Real-World Systems
- Database buffer pool strategies
- LLM inference with KV-cache optimization
- MapReduce shuffle strategies
- Mobile app memory management
3. Optimization Impact
- Memory reduction factors (10x to 1,000,000x)
- Time overhead analysis
- Cloud cost analysis
- Breakeven calculations
4. Educational Diagrams
- Williams' space-time bound
- Memory hierarchy and latencies
- Checkpoint strategy comparison
- Cache line utilization
- Algorithm selection guide
- Cost-benefit spider charts
Use Cases
1. Algorithm Design
# Compare different algorithm implementations
visualizer.current_n = 10**6 # 1 million elements
visualizer.update_all_plots()
# See which strategy is optimal for your data size
2. System Tuning
# Analyze memory hierarchy impact
# Adjust parameters to match your system
hierarchy = MemoryHierarchy.detect_system()
visualizer.hierarchy = hierarchy
3. Education
# Create educational visualizations
from example_visualizations import create_educational_diagrams
create_educational_diagrams()
# Perfect for teaching space-time tradeoffs
4. Research
# Export data for analysis
visualizer._export_data(None)
# Creates JSON with all metrics and parameters
# Saves high-resolution plots
Advanced Features
Custom Strategies
Add your own algorithms:
class CustomVisualizer(SpaceTimeVisualizer):
def _get_strategy_metrics(self, n, strategy):
if strategy == 'my_algorithm':
space = n ** 0.7 # Custom space complexity
time = n * np.log(n) ** 2 # Custom time
cost = space * 0.1 + time * 0.01
return space, time, cost
return super()._get_strategy_metrics(n, strategy)
Animation Mode
View algorithms in action:
# Launch animated view
visualizer.create_animated_view()
# Shows:
# - Processing progress
# - Checkpoint creation
# - Memory usage over time
Comparison Mode
Side-by-side strategy comparison:
# Launch comparison view
visualizer.create_comparison_view()
# Creates 2x2 grid comparing all strategies
Understanding the Visualizations
Space-Time Curves
- Lower-left: Better (less space, less time)
- Upper-right: Worse (more space, more time)
- Gray region: Theoretically impossible
- Green region: Feasible implementations
Memory Distribution
- Darker colors: Faster memory (L1, L2)
- Lighter colors: Slower memory (RAM, SSD)
- Bar width: Amount of data in that level
- Numbers: Access latency in nanoseconds
Checkpoint Timeline
- Blocks: Work between checkpoints
- Width: Amount of progress
- Gaps: Checkpoint operations
- Colors: Different strategies
Cost Analysis
- Log scale: Costs vary by orders of magnitude
- Red outline: Currently selected strategy
- Bar height: Relative cost (lower is better)
Tips for Best Results
-
Start with your actual data size: Use the slider to match your workload
-
Consider all metrics: Don't optimize for memory alone - check time and cost
-
Test edge cases: Try very small and very large data sizes
-
Export findings: Save configurations that work well
-
Compare strategies: Use the comparison view for thorough analysis
Interpreting Results
When to use O(√n) strategies:
- Data size >> available memory
- Memory is expensive (cloud/embedded)
- Can tolerate 10-50% time overhead
- Need fault tolerance
When to avoid:
- Data fits in memory
- Latency critical (< 10ms)
- Simple algorithms sufficient
- Overhead not justified
Future Enhancements
- Real-time profiling integration
- Custom algorithm import
- Collaborative sharing
- AR/VR visualization
- Machine learning predictions
See Also
- SpaceTimeCore: Core calculations
- Profiler: Profile your applications