adding xeon phi enumeration

.gitea/workflows/Build.yml

@@ -27,8 +27,8 @@ jobs:
       - name: Building Flint
         run: zig build flint
 
-      - name: Building Phi
+      #- name: Building Phi
-        run: zig build phi
+      #  run: zig build phi
 
       - name: Generating docs
         run: zig build docs

.gitea/workflows/Test.yml

@@ -24,5 +24,5 @@ jobs:
     - name: Flint Tests
       run: zig build test-flint
 
-    - name: Phi Tests
+    #- name: Phi Tests
-      run: zig build test-phi
+    #  run: zig build test-phi

build.zig

@@ -256,11 +256,13 @@ fn customSoft(
     _: *std.Build.Module,
     _: *std.Build.Module,
     base_c_mod: *std.Build.Module,
-    _: std.Build.ResolvedTarget,
+    target: std.Build.ResolvedTarget,
-    _: std.builtin.OptimizeMode,
+    optimize: std.builtin.OptimizeMode,
     use_llvm: bool,
 ) !void {
     const spv = b.lazyDependency("SPIRV_Interpreter", .{
+        .target = target,
+        .optimize = optimize,
         .@"no-example" = true,
         .@"no-test" = true,
         .@"use-llvm" = use_llvm,
@@ -306,17 +308,27 @@ fn optionsFlint(b: *std.Build, options: *Step.Options) !void {
 }
 
 fn customPhi(
-    _: *std.Build,
+    b: *std.Build,
     _: *Step.Compile,
     lib_mod: *std.Build.Module,
     _: *std.Build.Module,
     _: *std.Build.Module,
     base_c_mod: *std.Build.Module,
-    _: std.Build.ResolvedTarget,
+    target: std.Build.ResolvedTarget,
-    _: std.builtin.OptimizeMode,
+    optimize: std.builtin.OptimizeMode,
-    _: bool,
+    use_llvm: bool,
 ) !void {
     lib_mod.addImport("phi_c", base_c_mod);
+
+    const miclib = b.lazyDependency("miclib", .{
+        .target = target,
+        .optimize = optimize,
+        .miclib_include = "/usr/local/include",
+        .miclib_libdir = "/usr/local/lib",
+        .@"use-llvm" = use_llvm,
+    }) orelse return error.UnresolvedDependency;
+
+    lib_mod.addImport("miclib", miclib.module("miclib"));
 }
 
 fn optionsPhi(b: *std.Build, options: *Step.Options) !void {

build.zig.zon

@@ -41,6 +41,13 @@
         //    .path = "../SPIRV-Interpreter",
         //    .lazy = true,
         //},
+
+        // Phi dependencies
+        .miclib = .{
+            .url = "git+https://git.kbz8.me/kbz_8/miclib-zig.git#9d99ef63bf279c3f464821f8a82b0435c55d56a7",
+            .hash = "miclib-1.0.0-AbDwS3-6AABd_H8542J7l6p1q6asRusmQ-xdpQZ8bQ71",
+            .lazy = true,
+        },
     },
 
     .paths = .{

src/phi/PhiInstance.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const vk = @import("vulkan");
 const base = @import("base");
 const lib = @import("lib.zig");
+const mic = lib.mic;
 
 const PhiPhysicalDevice = @import("PhiPhysicalDevice.zig");
 
@@ -61,22 +62,35 @@ fn destroy(interface: *Interface, allocator: std.mem.Allocator) VkError!void {
     allocator.destroy(self);
 }
 
-fn requestPhysicalDevices(interface: *Interface, allocator: std.mem.Allocator, devices: []base.drm.Card) VkError!void {
+fn requestPhysicalDevices(interface: *Interface, allocator: std.mem.Allocator, _: []base.drm.Card) VkError!void {
     if (interface.physical_devices.items.len != 0) {
         return;
     }
 
-    const io_var = interface.io();
+    var devices = mic.DeviceList.init() catch |err| {
+        std.log.scoped(.MIC).err("Failed to create device list: {s}", .{@errorName(err)});
+        return VkError.InitializationFailed;
+    };
+    defer devices.deinit();
 
-    for (devices[0..]) |device| {
+    const count = devices.count() catch |err| {
-        const drm_device = device.getDevice(io_var, allocator, .{}) catch continue;
+        std.log.scoped(.MIC).err("Failed to fetch device list count: {s}", .{@errorName(err)});
+        return VkError.InitializationFailed;
+    };
 
-        if (drm_device.node_type != .render or
+    for (0..count) |index| {
-            std.meta.activeTag(drm_device.device_info) != .pci or
+        const device_num = devices.deviceAtIndex(index) catch |err| {
-            drm_device.device_info.pci.vendor_id != lib.INTEL_PCI_VENDOR_ID)
+            std.log.scoped(.MIC).err("Failed to fetch device: {s}", .{@errorName(err)});
             continue;
+        };
 
-        const physical_device = try PhiPhysicalDevice.create(allocator, interface, &drm_device);
+        var device = mic.Device.open(device_num) catch |err| {
+            std.log.scoped(.MIC).err("Failed to open device {d}: {s}", .{ device_num, @errorName(err) });
+            continue;
+        };
+        defer device.deinit();
+
+        const physical_device = try PhiPhysicalDevice.create(allocator, interface, device);
         errdefer physical_device.interface.release(allocator) catch {};
 
         const dispatchable = try Dispatchable(base.PhysicalDevice).wrap(allocator, &physical_device.interface);

src/phi/PhiPhysicalDevice.zig

@@ -3,6 +3,7 @@ const builtin = @import("builtin");
 const vk = @import("vulkan");
 const base = @import("base");
 const lib = @import("lib.zig");
+const mic = lib.mic;
 
 const pci_ids = @import("pci_ids.zig").map;
 
@@ -31,7 +32,7 @@ pub const EXTENSIONS = [_]vk.ExtensionProperties{
 
 interface: Interface,
 
-pub fn create(allocator: std.mem.Allocator, instance: *base.Instance, drm_device: *const base.drm.Device) VkError!*Self {
+pub fn create(allocator: std.mem.Allocator, instance: *base.Instance, mic_device: mic.Device) VkError!*Self {
     const self = allocator.create(Self) catch return VkError.OutOfHostMemory;
     errdefer allocator.destroy(self);
 
@@ -54,25 +55,34 @@ pub fn create(allocator: std.mem.Allocator, instance: *base.Instance, drm_device
     };
 
     interface.props.api_version = @bitCast(lib.VULKAN_VERSION);
-    interface.props.vendor_id = lib.INTEL_PCI_VENDOR_ID;
     interface.props.driver_version = @bitCast(base.DRIVER_VERSION);
-    interface.props.device_id = drm_device.device_info.pci.device_id;
     interface.props.device_type = .discrete_gpu;
 
     @memset(interface.props.device_name[0..], 0);
 
-    for (pci_ids[0..]) |pci| {
+    if (mic_device.pciConfig()) |pci_value| {
-        if (pci.id != drm_device.device_info.pci.device_id)
+        var pci = pci_value;
-            continue;
+        defer pci.deinit();
 
-        const len = @min(vk.MAX_PHYSICAL_DEVICE_NAME_SIZE, pci.name.len);
+        interface.props.vendor_id = pci.vendorId();
-        @memcpy(interface.props.device_name[0..len], pci.name[0..len]);
+        interface.props.device_id = pci.deviceId();
 
-        const driver_mark = " [Phi ApeDriver]";
+        for (pci_ids[0..]) |pci_info| {
+            if (pci.id != pci.deviceId())
+                continue;
 
-        @memcpy(interface.props.device_name[len .. len + driver_mark.len], driver_mark);
+            const len = @min(vk.MAX_PHYSICAL_DEVICE_NAME_SIZE, pci_info.name.len);
+            @memcpy(interface.props.device_name[0..len], pci_info.name[0..len]);
 
-        break;
+            const driver_mark = " [Phi ApeDriver]";
+
+            @memcpy(interface.props.device_name[len .. len + driver_mark.len], driver_mark);
+
+            break;
+        }
+    } else |err| {
+        std.log.scoped(.MIC).err("Failed to fetch device PCI config: {s}", .{@errorName(err)});
+        return VkError.InitializationFailed;
     }
 
     interface.props.pipeline_cache_uuid = undefined;

src/phi/lib.zig

@@ -2,8 +2,9 @@ const std = @import("std");
 const vk = @import("vulkan");
 pub const base = @import("base");
 
-pub const c = @import("intel_c");
+pub const c = @import("phi_c");
 pub const config = base.config;
+pub const mic = @import("miclib");
 
 pub const PhiInstance = @import("PhiInstance.zig");
 pub const PhiDevice = @import("PhiDevice.zig");
@@ -38,8 +39,6 @@ pub const DRIVER_NAME = "Phi";
 
 pub const PHYSICAL_DEVICE_DEFAULT_NAME = "Intel(R) Xeon Phi(TM) Coprocessor";
 
-pub const INTEL_PCI_VENDOR_ID = 0x8086;
-
 pub const VULKAN_VERSION = vk.makeApiVersion(
     0,
     config.phi_vulkan_version.major,