remove unused code; refactor code

.gitignore

@@ -4,3 +4,6 @@ primes.json
 primes*.json
 primes*.txt
 primes*.zip
+dhat*
+flamegraph*
+perf*

Cargo.lock

@@ -240,9 +240,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.70"
+version = "2.0.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0209b68b3613b093e0ec905354eccaedcfe83b8cb37cbdeae64026c3064c16"
+checksum = "b146dcf730474b4bcd16c311627b31ede9ab149045db4d6088b3becaea046462"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -7,18 +7,21 @@ edition = "2021"
 
 [dependencies]
 num = "0.4"
-thread-priority = "1.1"
 rand = "0.8"
 num-bigint = { default-features = false, version = "0.4", features = ["serde"] }
 once_cell = "1.19"
 serde_json = "1.0"
 
+[target.'cfg(windows)'.dependencies]
+thread-priority = "1.1"
+
 [profile.release]
 lto = true              # Enable link-time optimization
 codegen-units = 1       # Reduce number of codegen units to increase optimizations
 panic = 'abort'         # Abort on panic
-strip = true            # Strip symbols from binary; remove pdb
+# strip = true            # Strip symbols from binary; remove pdb
 overflow-checks = false
+debug = true
 
 [profile.dev]
 opt-level = 3

src/main.rs

@@ -1,12 +1,10 @@
 #![warn(clippy::perf)]
 #![warn(clippy::all)]
 
-pub mod is_prime;
+mod is_prime;
-pub mod primality_test;
 
 use crate::is_prime::prime_utils;
 use num::{BigUint, One};
-use once_cell::sync::Lazy;
 use std::{
     env::args,
     io::Write,
@@ -96,10 +94,8 @@ fn worker(
 }
 
 fn main() {
-    let mut args = args();
+    if let Some(prime) = args().nth(1) {
-    if args.len() == 2 {
         use std::str::FromStr;
-        let prime = args.nth(1).unwrap();
         let prime = BigUint::from_str(&prime).unwrap();
 
         let is_prime = is_prime::prime_utils::is_prime(&prime);
@@ -155,26 +151,20 @@ fn main() {
     let mut primes = primearc.lock().unwrap();
     primes.sort_unstable();
 
-    #[allow(clippy::cast_possible_wrap)]
+    let removed = primes.len() - NU;
-    let removed: i32 = if primes.len() > NU {
-        let rem = primes.len() - NU;
     primes.truncate(NU);
-        rem as i32
-    } else {
-        0
-    };
 
     let added = NU - primes.len();
     if primes.len() < NU {
-        static INC: once_cell::sync::Lazy<BigUint> = Lazy::new(|| BigUint::from(2u8));
+        let inc = BigUint::from(2u8);
 
         println!("[INFO] less primes than expected");
         let mut number = BigUint::from(THREADS) * BigUint::from(workloads);
-        if &number % &*INC == BigUint::ZERO {
+        if &number % &inc == BigUint::ZERO {
             number += BigUint::one();
         }
         loop {
-            number += &*INC;
+            number += &inc;
             if prime_utils::is_prime(&number) {
                 primes.push(number.clone());
                 if primes.len() == NU {

src/primality_test.rs

@@ -1,59 +0,0 @@
-pub mod primality_tests {
-    use num::{BigUint, Integer, One, Zero};
-    use rand::RngCore;
-
-    fn generate_random_biguint(num_bits: usize) -> BigUint {
-        let mut rng = rand::thread_rng();
-        let bytes = num_bits / 8 + 1;
-        let mut buf = vec![0u8; bytes];
-        rng.fill_bytes(&mut buf);
-        BigUint::from_bytes_be(&buf)
-    }
-
-    #[must_use]
-    pub fn is_probably_prime(number: &BigUint, iterations: u32) -> bool {
-        if number <= &BigUint::one() || number == &BigUint::from(4u32) {
-            return false;
-        } else if number <= &BigUint::from(3u32) {
-            return true;
-        }
-        let one = BigUint::one();
-        let mut d = number - &one;
-        while d.is_even() {
-            d /= 2u32;
-        }
-        for _ in 0..iterations {
-            let a = generate_random_biguint((number.bits() - 1) as usize);
-            let mut x = mod_exp(a.clone(), &d, number);
-            if x == one || x == number - &one {
-                continue;
-            }
-            let mut continue_loop = false;
-            for _ in 0..(number.bits() - 1) {
-                x = mod_exp(x.clone(), &BigUint::from(2u32), number);
-                if x == number - &one {
-                    continue_loop = true;
-                    break;
-                }
-            }
-            if !continue_loop {
-                return false;
-            }
-        }
-        true
-    }
-
-    fn mod_exp(mut base: BigUint, ex: &BigUint, modulus: &BigUint) -> BigUint {
-        let mut exp = ex.clone();
-        let mut result = BigUint::one();
-        base %= modulus;
-        while !exp.is_zero() {
-            if exp.is_odd() {
-                result = (&result * &base) % modulus;
-            }
-            base = base.pow(2) % modulus;
-            exp /= 2u32;
-        }
-        result
-    }
-}