thread pinning

Author: HardhatChad

Cargo.toml

@@ -26,6 +26,7 @@ cached = "0.46.1"
 chrono = "0.4.38"
 clap = { version = "4.4.12", features = ["derive"] }
 colored = "2.0"
+core_affinity = "0.8.1" 
 drillx = "2.0.0"
 futures = "0.3.30"
 num_cpus = "1.16.0"

src/mine.rs

@@ -28,7 +28,7 @@ impl Miner {
         self.open().await;
 
         // Check num threads
-        self.check_num_cores(args.threads);
+        self.check_num_cores(args.cores);
 
         // Start mining loop
         loop {
@@ -45,13 +45,9 @@ impl Miner {
             let cutoff_time = self.get_cutoff(proof, args.buffer_time).await;
 
             // Run drillx
-            let solution = Self::find_hash_par(
-                proof,
-                cutoff_time,
-                args.threads,
-                config.min_difficulty as u32,
-            )
-            .await;
+            let solution =
+                Self::find_hash_par(proof, cutoff_time, args.cores, config.min_difficulty as u32)
+                    .await;
 
             // Submit most difficult hash
             let mut compute_budget = 500_000;
@@ -75,60 +71,68 @@ impl Miner {
     async fn find_hash_par(
         proof: Proof,
         cutoff_time: u64,
-        threads: u64,
+        cores: u64,
         min_difficulty: u32,
     ) -> Solution {
         // Dispatch job to each thread
         let progress_bar = Arc::new(spinner::new_progress_bar());
         progress_bar.set_message("Mining...");
-        let handles: Vec<_> = (0..threads)
+        let core_ids = core_affinity::get_core_ids().unwrap();
+        let handles: Vec<_> = core_ids
+            .into_iter()
             .map(|i| {
                 std::thread::spawn({
                     let proof = proof.clone();
                     let progress_bar = progress_bar.clone();
                     let mut memory = equix::SolverMemory::new();
                     move || {
-                        let timer = Instant::now();
-                        let mut nonce = u64::MAX.saturating_div(threads).saturating_mul(i);
-                        let mut best_nonce = nonce;
-                        let mut best_difficulty = 0;
-                        let mut best_hash = Hash::default();
-                        loop {
-                            // Create hash
-                            if let Ok(hx) = drillx::hash_with_memory(
-                                &mut memory,
-                                &proof.challenge,
-                                &nonce.to_le_bytes(),
-                            ) {
-                                let difficulty = hx.difficulty();
-                                if difficulty.gt(&best_difficulty) {
-                                    best_nonce = nonce;
-                                    best_difficulty = difficulty;
-                                    best_hash = hx;
+                        let res = core_affinity::set_for_current(i);
+                        if res {
+                            let timer = Instant::now();
+                            let mut nonce =
+                                u64::MAX.saturating_div(cores).saturating_mul(i.id as u64);
+                            let mut best_nonce = nonce;
+                            let mut best_difficulty = 0;
+                            let mut best_hash = Hash::default();
+                            loop {
+                                // Create hash
+                                if let Ok(hx) = drillx::hash_with_memory(
+                                    &mut memory,
+                                    &proof.challenge,
+                                    &nonce.to_le_bytes(),
+                                ) {
+                                    let difficulty = hx.difficulty();
+                                    if difficulty.gt(&best_difficulty) {
+                                        best_nonce = nonce;
+                                        best_difficulty = difficulty;
+                                        best_hash = hx;
+                                    }
                                 }
-                            }
 
-                            // Exit if time has elapsed
-                            if nonce % 100 == 0 {
-                                if timer.elapsed().as_secs().ge(&cutoff_time) {
-                                    if best_difficulty.ge(&min_difficulty) {
-                                        // Mine until min difficulty has been met
-                                        break;
+                                // Exit if time has elapsed
+                                if nonce % 100 == 0 {
+                                    if timer.elapsed().as_secs().ge(&cutoff_time) {
+                                        if best_difficulty.ge(&min_difficulty) {
+                                            // Mine until min difficulty has been met
+                                            break;
+                                        }
+                                    } else if cores == 0 {
+                                        progress_bar.set_message(format!(
+                                            "Mining... ({} sec remaining)",
+                                            cutoff_time.saturating_sub(timer.elapsed().as_secs()),
+                                        ));
                                     }
-                                } else if i == 0 {
-                                    progress_bar.set_message(format!(
-                                        "Mining... ({} sec remaining)",
-                                        cutoff_time.saturating_sub(timer.elapsed().as_secs()),
-                                    ));
                                 }
+
+                                // Increment nonce
+                                nonce += 1;
                             }
 
-                            // Increment nonce
-                            nonce += 1;
+                            // Return the best nonce
+                            (best_nonce, best_difficulty, best_hash)
+                        } else {
+                            (0, 0, Hash::default())
                         }
-
-                        // Return the best nonce
-                        (best_nonce, best_difficulty, best_hash)
                     }
                 })
             })
@@ -158,14 +162,12 @@ impl Miner {
         Solution::new(best_hash.d, best_nonce.to_le_bytes())
     }
 
-    pub fn check_num_cores(&self, threads: u64) {
-        // Check num threads
+    pub fn check_num_cores(&self, cores: u64) {
         let num_cores = num_cpus::get() as u64;
-        if threads.gt(&num_cores) {
+        if cores.gt(&num_cores) {
             println!(
-                "{} Number of threads ({}) exceeds available cores ({})",
+                "{} Cannot exceeds available cores ({})",
                 "WARNING".bold().yellow(),
-                threads,
                 num_cores
             );
         }