Parallel sum

par_sum_pow_mod.rs

use std::thread;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use std::sync::Arc;

const MOD:u64 = 123456789;
// change to stack based for lower stack overhead
fn powmod(n: u64, p: u64, m: u64) -> u64 {
    if p == 0 {
        return 1;
    }
    if p == 1 {
        return n % m;
    }
    let t = powmod(n, p / 2, m);
    if p % 2 == 1 {
        return (((t * t) % m) * n) % m;
    } else {
        return (t * t) % m;
    }
}

fn main() {
    let count_lock = Arc::new(AtomicUsize::new(1));
    let num_worker = 4;
    let n = 50_000_000;
    let mut workers = Vec::new();
    for i in (0..num_worker) {
        let lock = Arc::clone(&count_lock);
        let thread = thread::spawn(move || {
            let mut sum = 0;
            loop {
                let acquired = lock.fetch_add(1, Ordering::SeqCst) as u64;
                if acquired > n {
                    break
                }
                sum = (sum + powmod(acquired, acquired, MOD)) % MOD;
            }
            sum
        });
        workers.push(thread);
    }
    let mut total_sum = 0;
    for w in workers {
        total_sum = (total_sum + w.join().expect("thread result error")) % MOD;
    }
    println!("Total sum: {}", total_sum);
}