From a548f74f7d0917fc58dfe782f0e983be5cf6f4b4 Mon Sep 17 00:00:00 2001 From: Nikolaus Heger Date: Fri, 26 Dec 2025 12:47:42 +0800 Subject: [PATCH] fmt --- crates/engine-gpu/src/lib.rs | 5 ++-- crates/miner-cli/src/main.rs | 58 ++++++++++++++++++++---------------- 2 files changed, 35 insertions(+), 28 deletions(-) diff --git a/crates/engine-gpu/src/lib.rs b/crates/engine-gpu/src/lib.rs index 93bd20c..c088d2a 100644 --- a/crates/engine-gpu/src/lib.rs +++ b/crates/engine-gpu/src/lib.rs @@ -355,9 +355,8 @@ impl MinerEngine for GpuEngine { }); // Clone resources to use outside the closure (they are cheap handles) - let resources = WORKER_RESOURCES.with(|resources_cell| { - resources_cell.borrow().as_ref().unwrap().clone() - }); + let resources = WORKER_RESOURCES + .with(|resources_cell| resources_cell.borrow().as_ref().unwrap().clone()); // Pre-convert header and target once (not per range) let mut header_u32s = [0u32; 8]; diff --git a/crates/miner-cli/src/main.rs b/crates/miner-cli/src/main.rs index e4c942b..3982878 100644 --- a/crates/miner-cli/src/main.rs +++ b/crates/miner-cli/src/main.rs @@ -376,7 +376,7 @@ async fn run_benchmark_command( let benchmark_start = Instant::now(); // Create a large range that should take the full duration - // 100M is definitely not enough for modern GPUs. + // 100M is definitely not enough for modern GPUs. // Let's make it huge so we don't run out of range logic in this simple benchmark. // However, the worker range logic below relies on fixed offsets. // If we want correct benchmarking, we should ideally dynamic dispatch, but fixed ranges are okay for short duration. @@ -388,7 +388,7 @@ async fn run_benchmark_command( let mut header = [0u8; 32]; rand::thread_rng().fill_bytes(&mut header); let difficulty = U512::MAX; // High difficulty - no solutions expected - + // We need a context from *some* engine. They should be compatible (same job). // Just pick one. let ref_engine = cpu_engine.as_ref().or(gpu_engine.as_ref()).unwrap(); @@ -408,20 +408,26 @@ async fn run_benchmark_command( if effective_gpu_workers > 0 { if let Some(gpu_engine_arc) = &gpu_engine { - // We can't easily get device count from MinerEngine trait without downcasting or extending trait. - // But we know it's GpuEngine here if feature=gpu is enabled. - #[cfg(feature = "gpu")] - { - if let Some(gpu_ptr) = gpu_engine_arc.as_any().downcast_ref::() { - let device_count = gpu_ptr.device_count(); - if effective_gpu_workers > device_count { - println!("⚠️ WARNING: You have requested {} GPU workers for {} device(s).", effective_gpu_workers, device_count); - println!(" Multiple workers per device creates contention and typically reduces hashrate."); - println!(" Recommended: 1 worker per GPU device."); - println!(); - } - } - } + // We can't easily get device count from MinerEngine trait without downcasting or extending trait. + // But we know it's GpuEngine here if feature=gpu is enabled. + #[cfg(feature = "gpu")] + { + if let Some(gpu_ptr) = gpu_engine_arc + .as_any() + .downcast_ref::() + { + let device_count = gpu_ptr.device_count(); + if effective_gpu_workers > device_count { + println!( + "⚠️ WARNING: You have requested {} GPU workers for {} device(s).", + effective_gpu_workers, device_count + ); + println!(" Multiple workers per device creates contention and typically reduces hashrate."); + println!(" Recommended: 1 worker per GPU device."); + println!(); + } + } + } } } @@ -445,7 +451,7 @@ async fn run_benchmark_command( // Calculate a disjoint range for this worker. // Simple strategy: Worker K gets [K*chunk, (K+1)*chunk] repeatedly? - // The original code was: + // The original code was: // worker_range = start + id*chunk .. start + (id+1)*chunk // And then loop engine.search_range inside. // Wait, the original code Loop: @@ -462,25 +468,27 @@ async fn run_benchmark_command( // But for "Total hashes", we are counting correctly. // // However, if we mix CPU and GPU, we have different chunk sizes. - // We need to make sure ranges don't overlap if that matters? + // We need to make sure ranges don't overlap if that matters? // For benchmarking hash rate, overlap doesn't matter (we just want to burn cycles). // But to be clean: // Let's just give each worker a dedicated slice of the huge space. // Or just stick to the "loop same small range" approach which fits CPU cache better maybe? // Actually, for GPU, repeatedly doing same range is fine. - + let handle = thread::spawn(move || { // We'll just define a range based on worker ID and a large multiplier // so they don't overlap easily, though it doesn't matter for pure hashrate. // Use a large stride to separate workers. - let stride = U512::from(1_000_000_000_000u64); - let worker_start = benchmark_range.start.saturating_add( - U512::from(worker_id as u64).saturating_mul(stride) - ); - + let stride = U512::from(1_000_000_000_000u64); + let worker_start = benchmark_range + .start + .saturating_add(U512::from(worker_id as u64).saturating_mul(stride)); + let worker_range = EngineRange { start: worker_start, - end: worker_start.saturating_add(U512::from(nonces_per_worker)).saturating_sub(U512::from(1u64)), + end: worker_start + .saturating_add(U512::from(nonces_per_worker)) + .saturating_sub(U512::from(1u64)), }; let mut worker_hashes = 0u64;