stats

Author: brandonros

Cargo.lock

@@ -4,10 +4,10 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-cust = { git = "https://github.com/Rust-GPU/Rust-CUDA.git" }
+cust = { git = "https://github.com/LegNeato/Rust-CUDA.git", rev = "6a3b08bfaa3c3441f7e3d8a522ad444d794e35b5" }
 hex = "0.4.3"
 rand = "0.8"
 
 [build-dependencies]
-#cuda_builder = { git = "https://github.com/LegNeato/Rust-CUDA.git", rev = "5bfda9ad027bfe1829c5c7263908ec0ed124c528" }
-cuda_builder = { git = "https://github.com/Rust-GPU/Rust-CUDA.git" }
+cuda_builder = { git = "https://github.com/LegNeato/Rust-CUDA.git", rev = "6a3b08bfaa3c3441f7e3d8a522ad444d794e35b5" }
+#cuda_builder = { git = "https://github.com/Rust-GPU/Rust-CUDA.git" }

Cargo.toml

@@ -7,8 +7,8 @@ edition = "2024"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-#cuda_std = { git = "https://github.com/LegNeato/Rust-CUDA.git", rev = "5bfda9ad027bfe1829c5c7263908ec0ed124c528" }
-#curve25519-dalek = { version = "4.1.3", default-features = false, features = ["alloc", "precomputed-tables"] }
+cuda_std = { git = "https://github.com/LegNeato/Rust-CUDA.git", rev = "6a3b08bfaa3c3441f7e3d8a522ad444d794e35b5" }
+curve25519-dalek = { version = "4.1.3", default-features = false, features = ["alloc", "precomputed-tables"] }
 
-cuda_std = { git = "https://github.com/Rust-GPU/Rust-CUDA.git" }
-curve25519-dalek = { git = "https://github.com/brandonros/curve25519-dalek.git", rev = "5c453288e39eed68697c3a689f7adf14a3a93ef3", default-features = false, features = ["alloc", "precomputed-tables", "cuda"] }
+#cuda_std = { git = "https://github.com/Rust-GPU/Rust-CUDA.git" }
+#curve25519-dalek = { git = "https://github.com/brandonros/curve25519-dalek.git", rev = "5c453288e39eed68697c3a689f7adf14a3a93ef3", default-features = false, features = ["alloc", "precomputed-tables", "cuda"] }

kernel/Cargo.toml

@@ -1,3 +1,10 @@
 [toolchain]
 channel = "nightly-2025-03-02"
-components = ["clippy", "llvm-tools-preview", "rust-src", "rustc-dev", "rustfmt", "rust-analyzer"]
+components = [
+    "clippy",
+    "llvm-tools-preview", 
+    "rust-src",
+    "rustc-dev",
+    "rustfmt",
+    "rust-analyzer"
+]

rust-toolchain.toml

@@ -1,3 +1,5 @@
+mod stats;
+
 use cust::device::Device;
 use cust::module::{Module, ModuleJitOption};
 use cust::prelude::Context;
@@ -13,7 +15,8 @@ fn device_main(
     ordinal: usize, 
     vanity_prefix: String, 
     blocks_per_grid: usize, 
-    threads_per_block: usize
+    threads_per_block: usize,
+    global_stats: Arc<GlobalStats>
 ) -> Result<(), Box<dyn Error + Send + Sync>> {
     // check if the vanity prefix contains any of the forbidden characters
     assert!(vanity_prefix.contains("l") == false); // lowercase L
@@ -51,7 +54,6 @@ fn device_main(
         launches += 1;
         total_operations += operations_per_launch;
         let rng_seed: u64 = rng.r#gen::<u64>();
-        //let rng_seed: u64 = 3314977520786701659;
 
         let mut found_flag_slice = [0.0f32; 1];
         let mut found_private_key = [0u8; 32];
@@ -85,6 +87,9 @@ fn device_main(
 
         stream.synchronize()?;
 
+        // increment stats
+        global_stats.add_launch(operations_per_launch);
+
         // Check if we found a match
         found_flag_slice_dev.copy_to(&mut found_flag_slice)?;
 
@@ -95,20 +100,22 @@ fn device_main(
             found_bs58_encoded_public_key_dev.copy_to(&mut found_bs58_encoded_public_key)?;
             found_thread_idx_slice_dev.copy_to(&mut found_thread_idx_slice)?;
 
-            // print
+            global_stats.add_matches(found_flag_slice[0] as usize);
+
+            // Format results
             let found_thread_idx = found_thread_idx_slice[0];
             let wallet_formatted_result = hex::encode([found_private_key, found_public_key].concat());
             let public_key_string = String::from_utf8(found_bs58_encoded_public_key.to_vec()).unwrap();
-            println!("[{ordinal}] Found match: {rng_seed} {found_thread_idx} {public_key_string} {wallet_formatted_result}");
-
-            // increment stats
-            matches_found += found_flag_slice[0] as usize;
-            let elapsed = start_time.elapsed();
-            let elapsed_seconds = elapsed.as_secs_f64();
-            let launches_per_second = launches as f64 / elapsed_seconds;
-            let operations_per_second = total_operations as f64 / elapsed_seconds / 1_000_000.00;
-            let matches_per_second = matches_found as f64 / elapsed_seconds;
-            println!("[{ordinal}] Found {matches_found} matches in {elapsed_seconds:.2}s ({matches_per_second:.6} matches/sec, {launches_per_second:.2} launches/sec, {operations_per_second:.2}M ops/sec) with {launches} launches {total_operations} operations {operations_per_launch} ops/launch {blocks_per_grid} blocks/grid {threads_per_block} threads/block");
+
+            // Print stats using global counters
+            global_stats.print_stats(
+                ordinal,
+                found_flag_slice[0],
+                &public_key_string,
+                &wallet_formatted_result,
+                rng_seed,
+                found_thread_idx
+            );
         }
     }
 }
@@ -121,16 +128,26 @@ fn main() -> Result<(), Box<dyn Error>> {
     let threads_per_block = args[3].parse::<usize>().unwrap();
 
     // Initialize CUDA context and get default stream
-    
     cust::init(CudaFlags::empty())?;
     let num_devices = Device::num_devices()?;
     println!("Found {} CUDA devices", num_devices);
 
+    // Initialize global stats
+    let global_stats = Arc::new(GlobalStats::new());
+
+    // start threads
     let mut handles = Vec::new();
     for i in 0..num_devices as usize {
         println!("Starting device {}", i);
         let vanity_prefix_clone = vanity_prefix.clone();
-        let handle = std::thread::spawn(move || device_main(i, vanity_prefix_clone, blocks_per_grid, threads_per_block));
+        let stats_clone = Arc::clone(&global_stats);
+        let handle = std::thread::spawn(move || device_main(
+            i,
+            vanity_prefix_clone,
+            blocks_per_grid,
+            threads_per_block,
+            stats_clone
+        ));
         handles.push(handle);
     }
     for handle in handles {

src/main.rs

@@ -0,0 +1,42 @@
+pub struct GlobalStats {
+    launches: AtomicUsize,
+    matches_found: AtomicUsize,
+    total_operations: AtomicU64,
+    start_time: Instant,
+}
+
+impl GlobalStats {
+    pub fn new() -> Self {
+        Self {
+            launches: AtomicUsize::new(0),
+            matches_found: AtomicUsize::new(0),
+            total_operations: AtomicU64::new(0),
+            start_time: Instant::now(),
+        }
+    }
+
+    fn add_launch(&self, operations: usize) {
+        self.launches.fetch_add(1, Ordering::Relaxed);
+        self.total_operations.fetch_add(operations as u64, Ordering::Relaxed);
+    }
+
+    fn add_matches(&self, matches: usize) {
+        self.matches_found.fetch_add(matches, Ordering::Relaxed);
+    }
+
+    fn print_stats(&self, device_id: usize, matches_this_launch: f32, public_key: &str, wallet: &str, seed: u64, thread_idx: u32) {
+        let launches = self.launches.load(Ordering::Relaxed);
+        let matches = self.matches_found.load(Ordering::Relaxed);
+        let operations = self.total_operations.load(Ordering::Relaxed);
+        
+        let elapsed = self.start_time.elapsed();
+        let elapsed_seconds = elapsed.as_secs_f64();
+        let launches_per_second = launches as f64 / elapsed_seconds;
+        let operations_per_second = operations as f64 / elapsed_seconds / 1_000_000.0;
+        let matches_per_second = matches as f64 / elapsed_seconds;
+
+        println!("[{device_id}] Found {matches_this_launch} matches this launch");
+        println!("[{device_id}] First match: seed = {seed} thread_idx = {thread_idx} public_key = {public_key} wallet = {wallet}");
+        println!("[{device_id}] GLOBAL STATS: Found {matches} matches in {elapsed_seconds:.2}s ({matches_per_second:.6} matches/sec, {launches_per_second:.2} launches/sec, {operations_per_second:.2}M ops/sec) with {launches} total launches, {operations} total operations");
+    }
+}