fix: code cleanup and stream synchronization after copying C from device to host memory

Author: madhav-madhusoodanan

samples/introduction/matmul/src/main.rs

@@ -4,23 +4,21 @@ use cust::function::{BlockSize, GridSize};
 use cust::launch;
 use cust::memory::{AsyncCopyDestination, DeviceBuffer, LockedBuffer};
 use cust::module::Module;
-use cust::prelude::EventStatus;
 use cust::stream::{Stream, StreamFlags};
-use std::time::Instant;
 
 static PTX: &str = include_str!(concat!(env!("OUT_DIR"), "/kernels.ptx"));
 
-fn matrix_multiply(block_size: usize, dimsA: (usize, usize, usize), dimsB: (usize, usize, usize)) -> Result<(), cust::error::CudaError> {
-    let dimsC = (dimsB.0, dimsA.1, 1);
-    let size_a = dimsA.0 * dimsA.1;
+fn matrix_multiply(block_size: usize, dims_a: (usize, usize, usize), dims_b: (usize, usize, usize)) -> Result<(), cust::error::CudaError> {
+    let dims_c = (dims_b.0, dims_a.1, 1);
+    let size_a = dims_a.0 * dims_a.1;
     let h_a = LockedBuffer::new(&1.0f32, size_a).expect("host array couldn't be initialized!");
 
-    let size_b = dimsB.0 * dimsB.1;
+    let size_b = dims_b.0 * dims_b.1;
     let h_b = LockedBuffer::new(&0.01f32, size_b).expect("host array couldn't be initialized!");
 
     let stream = Stream::new(StreamFlags::NON_BLOCKING, None).expect("Stream couldn't be init!");
 
-    let mut size_c = dimsB.0 * dimsA.1;
+    let size_c = dims_b.0 * dims_a.1;
     let mut h_c =
         LockedBuffer::new(&0.0f32, size_c).expect("host array couldn't be initialized!");
 
@@ -29,11 +27,11 @@ fn matrix_multiply(block_size: usize, dimsA: (usize, usize, usize), dimsB: (usiz
 
     let d_a = DeviceBuffer::from_slice(h_a.as_slice()).expect("device array couldn't be initialized!");
     let d_b = DeviceBuffer::from_slice(h_b.as_slice()).expect("device array couldn't be initialized!");
-    let mut d_c = DeviceBuffer::from_slice(h_c.as_slice()).expect("device array couldn't be initialized!");
+    let d_c = DeviceBuffer::from_slice(h_c.as_slice()).expect("device array couldn't be initialized!");
 
     stream.synchronize().expect("Stream couldn't synchronize!");
     let threads = BlockSize::xy(block_size as u32, block_size as u32);
-    let grid = GridSize::xy((dimsB.0 / (threads.x as usize)).try_into().unwrap(), (dimsA.1 / (threads.y as usize)).try_into().unwrap());
+    let grid = GridSize::xy((dims_b.0 / (threads.x as usize)).try_into().unwrap(), (dims_a.1 / (threads.y as usize)).try_into().unwrap());
 
     println!("Computing result using CUDA Kernel...");
 
@@ -47,8 +45,8 @@ fn matrix_multiply(block_size: usize, dimsA: (usize, usize, usize), dimsB: (usiz
             d_c.as_device_ptr(),
             d_a.as_device_ptr(),
             d_b.as_device_ptr(),
-            dimsA.0 as usize,
-            dimsB.0 as usize
+            dims_a.0 as usize,
+            dims_b.0 as usize
         ))?;
     }
 
@@ -67,8 +65,8 @@ fn matrix_multiply(block_size: usize, dimsA: (usize, usize, usize), dimsB: (usiz
                 d_c.as_device_ptr(),
                 d_a.as_device_ptr(),
                 d_b.as_device_ptr(),
-                dimsA.0 as usize,
-                dimsB.0 as usize,
+                dims_a.0 as usize,
+                dims_b.0 as usize,
             ))?;
         }
     }
@@ -86,30 +84,31 @@ fn matrix_multiply(block_size: usize, dimsA: (usize, usize, usize), dimsB: (usiz
 
     let avg_time = gpu_time as f32 / N_ITER as f32;
     println!("Average time spent executing by the GPU: {} microseconds", avg_time);
-    let flopsPerMatrixMul = 2.0 * (dimsA.0 as f32) * (dimsA.1 as f32) * (dimsB.0 as f32);
-    let gigaFlops = (flopsPerMatrixMul / (avg_time)) / 1000.0;
-    println!("Performance = {} GFlop/s", gigaFlops);
+    let flops_per_matrix_mul = 2.0 * (dims_a.0 as f32) * (dims_a.1 as f32) * (dims_b.0 as f32);
+    let giga_flops = (flops_per_matrix_mul / (avg_time)) / 1000.0;
+    println!("Performance = {} GFlop/s", giga_flops);
 
     unsafe{ 
         d_c
             .async_copy_to(&mut h_c, &stream)
             .expect("Could not copy from device to host!");
     }
+    stream.synchronize().expect("Stream couldn't synchronize!");
 
     // checking computed result
     // test relative error by the formula
     // |<x, y>_cpu - <x, y>_gpu| / |<x, y>_cpu|
     let machine_epsilon = 1.19209290E-07f32;
     let mut correct = true;
 
-    for i in 0..(dimsC.0 * dimsC.1) {
-        let abs_err = (h_c[i] - (dimsA.0 as f32 * 0.01f32)).abs();
-        let dot_length = (dimsA.0 as f32).abs();
+    for i in 0..(dims_c.0 * dims_c.1) {
+        let abs_err = (h_c[i] - (dims_a.0 as f32 * 0.01f32)).abs();
+        let dot_length = (dims_a.0 as f32).abs();
         let abs_val = h_c[i].abs();
         let rel_err = abs_err / abs_val.max(dot_length * machine_epsilon);
 
         if rel_err > 1e-6 {
-            println!("Error at index {}: CPU = {}, GPU = {}, rel_err = {}", i, dimsA.0 as f32 * 0.01f32, h_c[i], rel_err);
+            println!("Error at index {}: CPU = {}, GPU = {}, rel_err = {}", i, dims_a.0 as f32 * 0.01f32, h_c[i], rel_err);
             correct = false;
         }
     }
@@ -132,14 +131,13 @@ fn main() -> Result<(), cust::error::CudaError> {
     println!("Device Name: {}", device.name().unwrap());
 
     let block_size: u32  = 32;
-    let dimsA: (usize, usize, usize) = (block_size as usize, block_size as usize, 1);
-    let dimsB: (usize, usize, usize) = (block_size as usize, block_size as usize, 1);
+    let dims_a: (usize, usize, usize) = (block_size as usize, block_size as usize, 1);
+    let dims_b: (usize, usize, usize) = (block_size as usize, block_size as usize, 1);
 
-    if dimsA.0 != dimsB.1 {
+    if dims_a.0 != dims_b.1 {
         panic!("Matrix multiplication not possible with the given dimensions!");
     }
 
-    matrix_multiply(block_size as usize, dimsA, dimsB);
-
+    matrix_multiply(block_size as usize, dims_a, dims_b)?;
     Ok(())
 }