update

Author: float3

.github/workflows/CI.yaml

@@ -48,23 +48,12 @@ jobs:
         sudo apt update
         sudo apt install vulkan-sdk
 
-    - name: Build
-      run: cargo build --verbose --workspace --all-targets --all-features
-
-    - name: Run cargo check
-      run: cargo check --verbose --workspace --all-targets --all-features
-
-    - name: Run Clippy
-      run: cargo clippy --verbose --workspace --all-targets --all-features -- -D warnings
-
-    - name: Check formatting
-      run: cargo fmt --all -- --check
-
-    - name: Run tests
-      run: cargo test --verbose --workspace --all-targets --all-features --no-fail-fast --lib --bins --examples --tests --benches
-
-    - name: Check for uncommitted changes
-      run: git diff --exit-code
+    - run: cargo build --verbose --workspace --all-targets --all-features
+    - run: cargo check --verbose --workspace --all-targets --all-features
+    - run: cargo clippy --verbose --workspace --all-targets --all-features -- -D warnings
+    - run: cargo fmt --all -- --check
+    - run: cargo test --verbose --workspace --all-targets --all-features --no-fail-fast --lib --bins --examples --tests --benches
+    - run: git diff --exit-code
 
     - name: Generate cargo docs
       if: ${{ github.event_name == 'push' && matrix.rust == 'stable' }}

README.md

@@ -1,30 +1,33 @@
+# vkfetch
+
 this is a rewrite of https://github.com/Wunkolo/vkfetch \
 I referenced the code and took some of the ASCII art from it \
-thanks to wunkolo for writing the original, love you buddy \
-I rewrote it because I wanted to have vkfetch on an easy to access package manager
-
-# Goals
-- [ ] support all the features of the original vkfetch
-- [ ] support other gpus/vendors that aren't part of the original vkfetch
-- [x] use ANSI escape codes that are compatible with all terminals
-- [ ] add as much info as possible
+thanks to wunkolo for writing the original \
+I rewrote it because I wanted to have vkfetch on an easy to access package manager \
+I believe we now have feature parity with the original vkfetch
 
 # vkfetch-rs
 
-<!-- you can install this with cargo
+you need to have vulkanloader installed
+on nix that's the `vulkanloader` package
+on ubuntu it looks like this:
+
+
+```sh
+wget -qO- https://packages.lunarg.com/lunarg-signing-key-pub.asc | sudo tee /etc/apt/trusted.gpg.d/lunarg.asc
+sudo wget -qO /etc/apt/sources.list.d/lunarg-vulkan-noble.list http://packages.lunarg.com/vulkan/lunarg-vulkan-noble.list
+sudo apt update
+sudo apt install vulkan-sdk
+```
 
 ```sh
 cargo install vkfetch-rs
-``` -->
+```
 
-## build it from source (you need to have some libraries installed)
+## build it from source
 
 ```sh
 git clone https://github.com/float3/vkfetch-rs
 cd vkfetch-rs
 cargo build
 ```
-
-# current progress (comparison with original vkfetch)
-
-![ZO59XD7.png](./Z059XD7.png)

Z059XD7.png

@@ -1,4 +1,8 @@
 use ash::vk;
+use ash::vk::PhysicalDeviceProperties2;
+use ash::vk::PhysicalDeviceShaderCoreProperties2AMD;
+use ash::vk::PhysicalDeviceShaderCorePropertiesAMD;
+use ash::vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV;
 use ash::Instance;
 use std::ffi::CStr;
 
@@ -39,10 +43,14 @@ pub struct GPUCharacteristics {
     // NVIDIA-specific properties.
     pub streaming_multiprocessors: Option<u32>,
     pub warps_per_sm: Option<u32>,
-    // General device limits (useful for performance and capability queries).
+    // General device limits.
     pub max_image_dimension_2d: u32,
     pub max_compute_shared_memory_size: u32,
     pub max_compute_work_group_invocations: u32,
+    // New feature flags.
+    pub dedicated_transfer_queue: bool,
+    pub dedicated_async_compute_queue: bool,
+    pub supports_ray_tracing: bool,
 }
 
 impl PhysicalDevice {
@@ -56,8 +64,8 @@ impl PhysicalDevice {
         // Query additional driver properties.
         let mut driver_properties: vk::PhysicalDeviceDriverProperties =
             vk::PhysicalDeviceDriverProperties::default();
-        let mut properties2: vk::PhysicalDeviceProperties2 =
-            vk::PhysicalDeviceProperties2::default().push_next(&mut driver_properties);
+        let mut properties2: PhysicalDeviceProperties2 =
+            PhysicalDeviceProperties2::default().push_next(&mut driver_properties);
         unsafe {
             instance.get_physical_device_properties2(physical_device, &mut properties2);
         }
@@ -111,6 +119,37 @@ impl PhysicalDevice {
             f32::NAN
         };
 
+        // Query queue family properties.
+        let queue_families =
+            unsafe { instance.get_physical_device_queue_family_properties(physical_device) };
+        let mut dedicated_transfer_queue = false;
+        let mut dedicated_async_compute_queue = false;
+        for qf in queue_families.iter() {
+            let flags = qf.queue_flags;
+            if flags.contains(vk::QueueFlags::TRANSFER)
+                && !(flags.contains(vk::QueueFlags::GRAPHICS)
+                    || flags.contains(vk::QueueFlags::COMPUTE))
+            {
+                dedicated_transfer_queue = true;
+            }
+            if flags.contains(vk::QueueFlags::COMPUTE) && !flags.contains(vk::QueueFlags::GRAPHICS)
+            {
+                dedicated_async_compute_queue = true;
+            }
+        }
+
+        // Check for ray tracing support via device extensions.
+        let extensions = unsafe {
+            instance
+                .enumerate_device_extension_properties(physical_device)
+                .unwrap_or_default()
+        };
+        let supports_ray_tracing = extensions.iter().any(|ext| {
+            let ext_name = unsafe { CStr::from_ptr(ext.extension_name.as_ptr()) };
+            ext_name.to_str().unwrap_or("") == "VK_KHR_ray_tracing_pipeline"
+                || ext_name.to_str().unwrap_or("") == "VK_NV_ray_tracing"
+        });
+
         let mut characteristics = GPUCharacteristics {
             memory_pressure,
             // Vendor-specific fields start as None.
@@ -127,16 +166,18 @@ impl PhysicalDevice {
             max_image_dimension_2d: limits.max_image_dimension2_d,
             max_compute_shared_memory_size: limits.max_compute_shared_memory_size,
             max_compute_work_group_invocations: limits.max_compute_work_group_invocations,
+            // New features:
+            dedicated_transfer_queue,
+            dedicated_async_compute_queue,
+            supports_ray_tracing,
         };
 
         // Query vendor-specific properties.
         match vendor {
             Vendor::AMD => {
-                let mut shader_core_properties =
-                    vk::PhysicalDeviceShaderCorePropertiesAMD::default();
-                let mut shader_core_properties2 =
-                    vk::PhysicalDeviceShaderCoreProperties2AMD::default();
-                let mut amd_properties2 = vk::PhysicalDeviceProperties2::default()
+                let mut shader_core_properties = PhysicalDeviceShaderCorePropertiesAMD::default();
+                let mut shader_core_properties2 = PhysicalDeviceShaderCoreProperties2AMD::default();
+                let mut amd_properties2 = PhysicalDeviceProperties2::default()
                     .push_next(&mut shader_core_properties)
                     .push_next(&mut shader_core_properties2);
                 unsafe {
@@ -159,9 +200,9 @@ impl PhysicalDevice {
                 characteristics.wavefront_size = Some(shader_core_properties.wavefront_size);
             }
             Vendor::Nvidia => {
-                let mut sm_builtins = vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV::default();
+                let mut sm_builtins = PhysicalDeviceShaderSMBuiltinsPropertiesNV::default();
                 let mut nv_properties2 =
-                    vk::PhysicalDeviceProperties2::default().push_next(&mut sm_builtins);
+                    PhysicalDeviceProperties2::default().push_next(&mut sm_builtins);
                 unsafe {
                     instance.get_physical_device_properties2(physical_device, &mut nv_properties2);
                 }
@@ -284,7 +325,6 @@ mod tests {
             max_image_dimension2_d: 8192,
             max_compute_shared_memory_size: 16384,
             max_compute_work_group_invocations: 1024,
-            // Other fields can use defaults.
             ..Default::default()
         };
 
@@ -303,6 +343,9 @@ mod tests {
             max_image_dimension_2d: limits.max_image_dimension2_d,
             max_compute_shared_memory_size: limits.max_compute_shared_memory_size,
             max_compute_work_group_invocations: limits.max_compute_work_group_invocations,
+            dedicated_transfer_queue: false,
+            dedicated_async_compute_queue: false,
+            supports_ray_tracing: false,
         };
 
         assert_eq!(characteristics.max_image_dimension_2d, 8192);

src/device.rs

@@ -1,10 +1,10 @@
-// lib.rs (or main.rs)
 pub mod ascii_art;
 pub mod device;
 pub mod vendor;
 
 use ash::{self, vk, Entry, Instance};
 use device::PhysicalDevice;
+use std::error::Error;
 use vendor::Vendor;
 
 const BOLD: &str = "\x1B[1m";
@@ -13,7 +13,10 @@ const ALIGNMENT: &str = "    ";
 const EMPTY: &str = "";
 
 /// Fetches and prints information for a given physical device.
-pub fn fetch_device(instance: &Instance, device_handle: vk::PhysicalDevice) {
+pub fn fetch_device(
+    instance: &Instance,
+    device_handle: vk::PhysicalDevice,
+) -> Result<(), Box<dyn Error>> {
     let properties = unsafe { instance.get_physical_device_properties(device_handle) };
     let mut properties2 = vk::PhysicalDeviceProperties2::default();
     unsafe {
@@ -27,12 +30,17 @@ pub fn fetch_device(instance: &Instance, device_handle: vk::PhysicalDevice) {
     let device = PhysicalDevice::new(instance, device_handle);
     let info = get_device_info(&device, vendor.get_styles()[0]);
 
+    let x = art.get(0).unwrap().len();
+    let empty = " ".repeat(x);
+
     for i in 0..art.len().max(info.len()) {
-        let art_line = art.get(i).map(String::as_str).unwrap_or(EMPTY);
+        let art_line = art.get(i).map(String::as_str).unwrap_or(&empty);
         let info_line = info.get(i).map(String::as_str).unwrap_or(EMPTY);
         println!(" {} {}", art_line, info_line);
     }
+
     println!();
+    Ok(())
 }
 
 /// Returns a vector of formatted strings representing the device info,
@@ -162,7 +170,7 @@ fn get_device_info(device: &PhysicalDevice, color: &str) -> Vec<String> {
     //     format_bytes(device.characteristics.max_image_dimension_2d.into())
     // ));
     lines.push(format!(
-        "{}{}Max Compute Shared Memory Size{}: {} bytes",
+        "{}{}Max Compute Shared Memory Size{}: {}",
         ALIGNMENT,
         color,
         RESET,
@@ -180,6 +188,40 @@ fn get_device_info(device: &PhysicalDevice, color: &str) -> Vec<String> {
                 .into()
         )
     ));
+    lines.push(format!(
+        "{} | {} | {}",
+        format!(
+            "{}{}Raytracing{}: {}",
+            ALIGNMENT,
+            color,
+            RESET,
+            if device.characteristics.supports_ray_tracing {
+                "[x]"
+            } else {
+                "[ ]"
+            },
+        ),
+        format!(
+            "{}Dedicated Transfer Queue{}: {}",
+            color,
+            RESET,
+            if device.characteristics.supports_ray_tracing {
+                "[x]"
+            } else {
+                "[ ]"
+            },
+        ),
+        format!(
+            "{}Dedicated Async Compute Queue{}: {}",
+            color,
+            RESET,
+            if device.characteristics.supports_ray_tracing {
+                "[x]"
+            } else {
+                "[ ]"
+            },
+        ),
+    ));
 
     lines
 }
@@ -297,6 +339,9 @@ mod tests {
                 max_image_dimension_2d: 16384,
                 max_compute_shared_memory_size: 65536,
                 max_compute_work_group_invocations: 1024,
+                dedicated_transfer_queue: true,
+                dedicated_async_compute_queue: true,
+                supports_ray_tracing: true,
             },
         }
     }