Fix ray tracing memory mapping on systems without ReBAR, fix System Latency math calculation, clarify VRAM/RAM bandwidth labels, and silence verbose diagnostics prints

Author: Soddentrough

gpubench-core/src/benchmarks/fp32.rs

@@ -72,7 +72,6 @@ impl Benchmark for Fp32Bench {
         // Wait, the cpp code's `Run` is just 1 dispatch?
         // Ah, the CLI runner orchestrates the `Run` iteration loop.
         for iter in 0..5 {
-            println!("[DIAGNOSTIC] FP32 iter {}", iter);
             let temp_buffer = context.create_buffer(8 * 1024 * 1024, None)?;
             context.set_kernel_arg_buffer(self.kernel, 0, temp_buffer)?;
             context.dispatch(self.kernel, 1024, 1, 1, 64, 1, 1)?;

gpubench-core/src/benchmarks/membw.rs

@@ -68,7 +68,6 @@ impl Benchmark for MemBwBench {
         let mut actual_iters = 0;
 
         while start.elapsed().as_secs_f64() < 2.5 {
-            println!("[DIAGNOSTIC] MemBw iter {}", actual_iters);
             context.dispatch(self.kernel, workgroups, 1, 1, 512, 1, 1)?;
             context.wait_idle()?;
             actual_iters += 1;

gpubench-core/src/vulkan.rs

@@ -77,7 +77,6 @@ pub struct VulkanContext {
 
 impl VulkanContext {
     pub fn new() -> Result<Self, String> {
-        println!("[DIAGNOSTIC] VulkanContext::new() called");
         let core = VULKAN_CORE.as_ref().map_err(|e| e.clone())?;
         let instance = &core.1;
 
@@ -165,7 +164,6 @@ impl ComputeContext for VulkanContext {
     }
 
     fn pick_device(&mut self, index: u32) -> Result<(), String> {
-        println!("[DIAGNOSTIC] VulkanContext::pick_device() called with index {}", index);
         if index as usize >= self.physical_devices.len() {
             return Err("Invalid device index".to_string());
         }
@@ -242,7 +240,6 @@ impl ComputeContext for VulkanContext {
 
         device_info.p_next = &features2_create as *const _ as *const std::ffi::c_void;
 
-        println!("[DIAGNOSTIC] create_device executing");
         let device = unsafe { instance.create_device(pdevice, &device_info, None).map_err(|e| e.to_string())? };
 
         let rt_pipeline = if self.device_infos[self.selected_device_idx as usize].ray_tracing_support {
@@ -252,8 +249,7 @@ impl ComputeContext for VulkanContext {
         let rt_as = if self.device_infos[self.selected_device_idx as usize].ray_tracing_support {
             Some(AccelerationStructure::new(instance, &device))
         } else { None };
-
-        println!("[DIAGNOSTIC] create_device success");
+        
         let queue = unsafe { device.get_device_queue(queue_family_index, 0) };
 
         let pool_info = vk::CommandPoolCreateInfo::default()
@@ -306,9 +302,6 @@ impl ComputeContext for VulkanContext {
         let mem_type_idx = self.find_memory_type(mem_req.memory_type_bits, properties).unwrap_or_else(|_| {
             self.find_memory_type(mem_req.memory_type_bits, vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT).unwrap()
         });
-        
-        println!("[DIAGNOSTIC] create_buffer: using mem_type_idx {}", mem_type_idx);
-        
         let mut alloc_flags = vk::MemoryAllocateFlagsInfo::default().flags(vk::MemoryAllocateFlags::DEVICE_ADDRESS);
         let alloc_info = vk::MemoryAllocateInfo::default()
             .allocation_size(mem_req.size)
@@ -318,19 +311,15 @@ impl ComputeContext for VulkanContext {
         let memory = unsafe { device.allocate_memory(&alloc_info, None).map_err(|e| e.to_string())? };
         unsafe { device.bind_buffer_memory(buffer, memory, 0).map_err(|e| e.to_string())? };
 
-        if let Some(data) = host_ptr {
-            let ptr = unsafe { device.map_memory(memory, 0, size as u64, vk::MemoryMapFlags::empty()).map_err(|e| e.to_string())? };
-            unsafe { std::ptr::copy_nonoverlapping(data.as_ptr(), ptr as *mut u8, data.len().min(size)) };
-            unsafe { device.unmap_memory(memory) };
-        }
-
         let id = self.next_buffer_id;
         self.next_buffer_id += 1;
         let bda_info = vk::BufferDeviceAddressInfo::default().buffer(buffer);
-        let bda = unsafe { device.get_buffer_device_address(&bda_info) };
-        println!("[DIAGNOSTIC] create_buffer: id={}, size={}, align={}, bda=0x{:X}", id, size, mem_req.alignment, bda);
-
         self.buffers.insert(id, VulkanBuffer { buffer, memory, _size: size });
+
+        if let Some(data) = host_ptr {
+            self.write_buffer(id, 0, data)?;
+        }
+
         Ok(id)
     }
 
@@ -1176,12 +1165,9 @@ impl ComputeContext for VulkanContext {
 
 impl Drop for VulkanContext {
     fn drop(&mut self) {
-        println!("[DIAGNOSTIC] VulkanContext::drop() called");
         if let Some(device) = &self.device {
             unsafe {
-                println!("[DIAGNOSTIC] device_wait_idle");
                 let _ = device.device_wait_idle();
-                println!("[DIAGNOSTIC] destroying kernels");
                 for (_, k) in self.kernels.drain() {
                     device.destroy_pipeline(k.pipeline, None);
                     device.destroy_pipeline_layout(k.pipeline_layout, None);
@@ -1192,13 +1178,9 @@ impl Drop for VulkanContext {
                     device.destroy_buffer(vbuf.buffer, None);
                     device.free_memory(vbuf.memory, None);
                 }
-                println!("[DIAGNOSTIC] destroying fence");
                 device.destroy_fence(self.fence, None);
-                println!("[DIAGNOSTIC] destroying pool");
                 device.destroy_command_pool(self.command_pool, None);
-                println!("[DIAGNOSTIC] destroying device");
                 device.destroy_device(None);
-                println!("[DIAGNOSTIC] Drop complete");
             }
         }
     }

gpubench-gui/src/main.rs

@@ -421,24 +421,18 @@ impl Application for GPUBenchApp {
                         ),
                         Command::perform(
                             async move {
-                                println!("[DIAGNOSTIC] Waiting 500ms to allow UI redraw...");
                                 tokio::time::sleep(std::time::Duration::from_millis(500)).await;
-                                println!("[DIAGNOSTIC] spawn_blocking started");
                                 let res = tokio::task::spawn_blocking(move || {
-                                    println!("[DIAGNOSTIC] run_benchmarks executing");
-                                    let r = run_benchmarks(
+                                    run_benchmarks(
                                         &tests_to_run,
                                         &vec![d_idx],
                                         &vec![b_str],
                                         false,
                                         false,
                                         false,
                                         progress_callback
-                                    );
-                                    println!("[DIAGNOSTIC] run_benchmarks finished");
-                                    r
+                                    )
                                 }).await;
-                                println!("[DIAGNOSTIC] spawn_blocking finished, await result: {:?}", res.is_ok());
                             },
                             |_| Message::BenchmarksComplete
                         )
@@ -759,10 +753,10 @@ impl Application for GPUBenchApp {
                 };
 
                 let sys_content = column![
-                    metric_row("MemBandwidth", "Max Bandwidth", self.gpu_bw, "GB/s", "Measures the maximum rate at which data can be read from or stored into the GPU's VRAM. Critical for high-resolution textures and large datasets."),
-                    metric_row("SysMemBandwidth", "System Bandwidth", self.sys_mem_bw, "GB/s", "Measures the maximum multi-threaded bandwidth to the host's system RAM. Important for CPU-to-GPU data transfers and general system performance."),
-                    metric_row("SysMemBandwidth", "Sys Bandwidth (1 Thread)", self.sys_mem_bw_single, "GB/s", "Measures single-threaded bandwidth to system RAM, which indicates memory channel efficiency and latency-bound transfer speeds."),
-                    metric_row("SysMemLatency", "System Latency", self.sys_mem_lat, "ns", "Measures the time it takes to fetch a single un-cached piece of data from system memory. Lower is better. Essential for game engines and unpredictable data access."),
+                    metric_row("MemBandwidth", "GPU VRAM Bandwidth", self.gpu_bw, "GB/s", "Measures the maximum rate at which data can be read from or stored into the GPU's VRAM. Critical for high-resolution textures and large datasets."),
+                    metric_row("SysMemBandwidth", "System RAM Bandwidth", self.sys_mem_bw, "GB/s", "Measures the maximum multi-threaded bandwidth to the host's system RAM. Important for CPU-to-GPU data transfers and general system performance."),
+                    metric_row("SysMemBandwidth", "System RAM (1 Thread)", self.sys_mem_bw_single, "GB/s", "Measures single-threaded bandwidth to system RAM, which indicates memory channel efficiency and latency-bound transfer speeds."),
+                    metric_row("SysMemLatency", "System RAM Latency", self.sys_mem_lat, "ns", "Measures the time it takes to fetch a single un-cached piece of data from system memory. Lower is better. Essential for game engines and unpredictable data access."),
                 ].spacing(12).into();
 
                 let compute_content = column![
@@ -880,8 +874,10 @@ impl GPUBenchApp {
 
         let mut value = ((res.operations as f64) / (res.time_ms / 1000.0)) as f32;
 
-        if res.metric == "ms/op" || res.metric == "ns" {
+        if res.metric == "ms/op" {
             value = (res.time_ms as f32) / (res.operations as f32);
+        } else if res.metric == "ns" {
+            value = ((res.time_ms * 1_000_000.0) as f32) / (res.operations as f32);
         } else if res.metric == "GIS/s" || res.metric == "GRays/s" || res.metric == "GB/s" {
             value /= 1e9;
         } else if res.metric == "TFLOPS" || res.metric == "TOPS" {

gpubench-sys/build.rs

@@ -4,6 +4,8 @@ fn main() {
         .build();
 
     println!("cargo:rustc-link-search=native={}/build", dst.display());
+    println!("cargo:rustc-link-search=native={}/build/Release", dst.display());
+    println!("cargo:rustc-link-search=native={}/build/Debug", dst.display());
     println!("cargo:rustc-link-lib=static=gpubench_lib");
     println!("cargo:rustc-link-lib=vulkan");