rusty_bench - π Calculator Benchmark

A Rust-based Monte Carlo simulation benchmark for estimating the value of π using multi-threading with CPU core pinning. Implementation was done using different LLMs in comparison (individual branches): prompt.md

Features

• Monte Carlo π estimation using random point generation
• Thread pinning to specific CPU cores via core_affinity crate
• Real-time progress visualization with:
  • Accuracy percentage
  • Sampling rate
  • Current estimate of π
  • Thread utilization information
• Graceful shutdown via Ctrl+C
• Input validation for target digits (0-15) and thread counts
• Comprehensive test suite covering edge cases and core functionality

Usage

To run the benchmark:

cargo run --release

Interaction Guide

1. When prompted, enter:
   • Number of correct π digits to calculate (0 = unlimited)
   • Number of threads to use (auto-limited by available CPU cores)
2. Press Enter to start
3. Use Ctrl+C at any time to stop the calculation

Example session:

        ╔═══════════════════════════════╗
        ║                               ║
        ║      ███████████████████      ║
        ║      █     █     █     █      ║
        ║      █     █     ███████      ║
        ║      █     █     █     █      ║
        ║                               ║
        ╚═══════════════════════════════╝
        rusty_bench — π Calculator
        
Enter 0 digits to run until interrupted. Enter q at a prompt to quit.
How many correct digits of Pi? (0 = run until Ctrl+C, q = quit): 5
How many threads should be used? (q = quit): 4
[####################] 100.0% 5/5 π=3.1415927 1.20e+05/s 4t 10.2s
Reached target of 5 correct digit(s).
Pi estimate: 3.141592700000000
Total runtime: 10.23s

Dependencies

The project requires the following Rust crates:

• core_affinity For CPU core pinning
• ctrlc For handling Ctrl+C interrupts
• rand For random number generation

These dependencies are automatically managed by Cargo.

Notes

• The program uses a batch size of 65,536 points per thread iteration for performance
• Accuracy is calculated using a tolerance-based comparison against π
• If core affinity enumeration fails, threads will not be pinned but will still run in parallel
• The maximum achievable precision with f64 is approximately 15 digits