rename found_flag

Author: brandonros

kernel/src/lib.rs

@@ -37,7 +37,7 @@ pub unsafe fn find_vanity_private_key(
     vanity_prefix_len: usize, 
     rng_seed: u64,
     // output
-    found_flag_slice_ptr: *mut cuda_std::atomic::AtomicF32,
+    found_matches_slice_ptr: *mut cuda_std::atomic::AtomicF32,
     found_private_key_ptr: *mut u8,
     found_public_key_ptr: *mut u8,
     found_bs58_encoded_public_key_ptr: *mut u8,
@@ -76,22 +76,22 @@ pub unsafe fn find_vanity_private_key(
 
     // if match, copy found match to host
     if matches {
-        let found_flag_slice = unsafe { core::slice::from_raw_parts_mut(found_flag_slice_ptr, 1) };
+        let found_matches_slice = unsafe { core::slice::from_raw_parts_mut(found_matches_slice_ptr, 1) };
         let found_private_key = unsafe { core::slice::from_raw_parts_mut(found_private_key_ptr, 32) };
         let found_public_key = unsafe { core::slice::from_raw_parts_mut(found_public_key_ptr, 32) };
         let found_bs58_encoded_public_key = unsafe { core::slice::from_raw_parts_mut(found_bs58_encoded_public_key_ptr, 64) };
         let found_thread_idx_slice = unsafe { core::slice::from_raw_parts_mut(found_thread_idx_slice_ptr, 1) };
-        let found_flag = &mut found_flag_slice[0];
+        let found_matches = &mut found_matches_slice[0];
 
         // if first find, copy results to host
-        if found_flag.load(core::sync::atomic::Ordering::SeqCst) == 0.0 {
+        if found_matches.load(core::sync::atomic::Ordering::SeqCst) == 0.0 {
             found_private_key.copy_from_slice(&private_key[0..32]);
             found_public_key.copy_from_slice(&public_key_bytes[0..32]);
             found_bs58_encoded_public_key.copy_from_slice(&bs58_encoded_public_key[0..64]);
             found_thread_idx_slice[0] = thread_idx as u32;
         }
 
-        found_flag.fetch_add(1.0, core::sync::atomic::Ordering::SeqCst);
+        found_matches.fetch_add(1.0, core::sync::atomic::Ordering::SeqCst);
         cuda_std::atomic::mid::device_thread_fence(core::sync::atomic::Ordering::SeqCst);   
     }
 }

scripts/vast.sh

@@ -4,6 +4,8 @@ PORT=13360
 HOST=ssh4.vast.ai
 USER=root
 
+ssh -p $PORT $USER@$HOST
+
 # generate key
 ssh -o StrictHostKeyChecking=no -p $PORT $USER@$HOST <<'EOF'
 if [[ ! -f ~/.ssh/id_rsa ]]
@@ -68,5 +70,5 @@ EOF
 # run
 ssh -o StrictHostKeyChecking=no -p $PORT $USER@$HOST <<'EOF'
 pushd ed25519-vanity-rs
-./target/release/ed25519_vanity aa 16384 256
+./target/release/ed25519_vanity aa 8192 256
 EOF

src/main.rs

@@ -52,14 +52,14 @@ fn device_main(
     loop {
         let rng_seed: u64 = rng.r#gen::<u64>();
 
-        let mut found_flag_slice = [0.0f32; 1];
+        let mut found_matches_slice = [0.0f32; 1];
         let mut found_private_key = [0u8; 32];
         let mut found_public_key = [0u8; 32];
         let mut found_bs58_encoded_public_key = [0u8; 64];
         let mut found_thread_idx_slice = [0u32; 1];
 
         let vanity_prefix_dev = vanity_prefix_bytes.as_dbuf()?;
-        let found_flag_slice_dev = found_flag_slice.as_dbuf()?;
+        let found_matches_slice_dev = found_matches_slice.as_dbuf()?;
         let found_private_key_dev = found_private_key.as_dbuf()?;
         let found_public_key_dev = found_public_key.as_dbuf()?;
         let found_bs58_encoded_public_key_dev = found_bs58_encoded_public_key.as_dbuf()?;    
@@ -73,7 +73,7 @@ fn device_main(
                     vanity_prefix_dev.as_device_ptr(),
                     vanity_prefix_len,
                     rng_seed,
-                    found_flag_slice_dev.as_device_ptr(),
+                    found_matches_slice_dev.as_device_ptr(),
                     found_private_key_dev.as_device_ptr(),
                     found_public_key_dev.as_device_ptr(),
                     found_bs58_encoded_public_key_dev.as_device_ptr(),
@@ -88,30 +88,28 @@ fn device_main(
         global_stats.add_launch(operations_per_launch);
 
         // Check if we found a match
-        found_flag_slice_dev.copy_to(&mut found_flag_slice)?;
+        found_matches_slice_dev.copy_to(&mut found_matches_slice)?;
 
-        if found_flag_slice[0] != 0.0 {
+        let found_matches = found_matches_slice[0];
+        if found_matches != 0.0 {
             // We found a match! Copy results back to host
             found_private_key_dev.copy_to(&mut found_private_key)?;
             found_public_key_dev.copy_to(&mut found_public_key)?;
             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)?;
 
-            global_stats.add_matches(found_flag_slice[0] as usize);
+            global_stats.add_matches(found_matches 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();
+            let encoded_public_key_string = String::from_utf8(found_bs58_encoded_public_key.to_vec()).unwrap();
+            println!("[{ordinal}] First match: seed = {rng_seed} thread_idx = {found_thread_idx} encoded_public_key = {encoded_public_key_string} wallet = {wallet_formatted_result}");
 
             // 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
+                found_matches,
             );
         }
     }

src/stats.rs

@@ -29,7 +29,7 @@ impl GlobalStats {
         self.matches_found.fetch_add(matches, Ordering::Relaxed);
     }
 
-    pub fn print_stats(&self, device_id: usize, matches_this_launch: f32, public_key: &str, wallet: &str, seed: u64, thread_idx: u32) {
+    pub fn print_stats(&self, device_id: usize, matches_this_launch: f32) {
         let launches = self.launches.load(Ordering::Relaxed);
         let matches = self.matches_found.load(Ordering::Relaxed);
         let operations = self.total_operations.load(Ordering::Relaxed);
@@ -41,7 +41,6 @@ impl GlobalStats {
         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");
     }
 }