adding queues and debug allocators

src/soft/SoftDevice.zig

@@ -1,9 +1,13 @@
 const std = @import("std");
 const vk = @import("vulkan");
 const base = @import("base");
+const builtin = @import("builtin");
+
+const Debug = std.builtin.OptimizeMode.Debug;
 
 const SoftDeviceMemory = @import("SoftDeviceMemory.zig");
 const SoftFence = @import("SoftFence.zig");
+const SoftQueue = @import("SoftQueue.zig");
 
 const VkError = base.VkError;
 
@@ -13,7 +17,7 @@ pub const Interface = base.Device;
 const SpawnError = std.Thread.SpawnError;
 
 interface: Interface,
-device_allocator: std.heap.ThreadSafeAllocator,
+device_allocator: if (builtin.mode == Debug) std.heap.DebugAllocator(.{}) else std.heap.ThreadSafeAllocator,
 workers: std.Thread.Pool,
 
 pub fn create(physical_device: *base.PhysicalDevice, allocator: std.mem.Allocator, info: *const vk.DeviceCreateInfo) VkError!*Self {
@@ -22,6 +26,11 @@ pub fn create(physical_device: *base.PhysicalDevice, allocator: std.mem.Allocato
 
     var interface = try Interface.init(allocator, physical_device, info);
 
+    interface.vtable = &.{
+        .createQueue = SoftQueue.create,
+        .destroyQueue = SoftQueue.destroy,
+    };
+
     interface.dispatch_table = &.{
         .allocateMemory = allocateMemory,
         .createFence = createFence,
@@ -35,20 +44,30 @@ pub fn create(physical_device: *base.PhysicalDevice, allocator: std.mem.Allocato
 
     self.* = .{
         .interface = interface,
-        .device_allocator = .{ .child_allocator = std.heap.c_allocator }, // TODO: better device allocator
+        .device_allocator = if (builtin.mode == Debug) .init else .{ .child_allocator = std.heap.c_allocator }, // TODO: better device allocator
         .workers = undefined,
     };
 
-    self.workers.init(.{ .allocator = self.interface.host_allocator.allocator() }) catch |err| return switch (err) {
+    self.workers.init(.{ .allocator = self.device_allocator.allocator() }) catch |err| return switch (err) {
         SpawnError.OutOfMemory, SpawnError.LockedMemoryLimitExceeded => VkError.OutOfDeviceMemory,
         else => VkError.Unknown,
     };
+
+    try self.interface.createQueues(allocator, info);
     return self;
 }
 
 pub fn destroy(interface: *Interface, allocator: std.mem.Allocator) VkError!void {
     const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
     self.workers.deinit();
+
+    if (builtin.mode == Debug) {
+        // All device memory allocations should've been freed by now
+        if (!self.device_allocator.detectLeaks()) {
+            std.log.scoped(.vkDestroyDevice).debug("No device memory leaks detected", .{});
+        }
+    }
+
     allocator.destroy(self);
 }
 

src/soft/SoftInstance.zig

@@ -18,9 +18,11 @@ pub fn create(allocator: std.mem.Allocator, infos: *const vk.InstanceCreateInfo)
 
     self.interface = try base.Instance.init(allocator, infos);
     self.interface.dispatch_table = &.{
+        .destroyInstance = destroyInstance,
+    };
+    self.interface.vtable = &.{
         .requestPhysicalDevices = requestPhysicalDevices,
         .releasePhysicalDevices = releasePhysicalDevices,
-        .destroyInstance = destroyInstance,
     };
     return &self.interface;
 }

src/soft/SoftPhysicalDevice.zig

@@ -74,6 +74,7 @@ pub fn create(allocator: std.mem.Allocator, instance: *const base.Instance) VkEr
             .timestamp_valid_bits = 0,
             .min_image_transfer_granularity = .{ .width = 1, .height = 1, .depth = 1 },
         },
+        // TODO: maybe add a compute specialized queue
     };
     interface.queue_family_props = std.ArrayList(vk.QueueFamilyProperties).fromOwnedSlice(queue_family_props[0..]);
 

src/soft/SoftQueue.zig

@@ -13,7 +13,7 @@ pub const Interface = base.Queue;
 interface: Interface,
 mutex: std.Thread.Mutex,
 
-pub fn create(allocator: std.mem.Allocator, device: *const base.Device, index: u32, family_index: u32, flags: vk.DeviceQueueCreateFlags) VkError!*Self {
+pub fn create(allocator: std.mem.Allocator, device: *const base.Device, index: u32, family_index: u32, flags: vk.DeviceQueueCreateFlags) VkError!*Interface {
     const self = allocator.create(Self) catch return VkError.OutOfHostMemory;
     errdefer allocator.destroy(self);
 
@@ -29,7 +29,12 @@ pub fn create(allocator: std.mem.Allocator, device: *const base.Device, index: u
         .interface = interface,
         .mutex = .{},
     };
-    return self;
+    return &self.interface;
+}
+
+pub fn destroy(interface: *Interface, allocator: std.mem.Allocator) VkError!void {
+    const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
+    allocator.destroy(self);
 }
 
 pub fn bindSparse(interface: *Interface, info: []*const vk.BindSparseInfo, fence: ?*base.Fence) VkError!void {