making VK_EXT_external_memory_host support optional

Author: Hugobros3

include/shady/runtime.h

@@ -36,6 +36,7 @@ Command* launch_kernel(Program*, Device*, const char* entry_point, int dimx, int
 bool wait_completion(Command*);
 
 Buffer* allocate_buffer_device(Device*, size_t);
+bool can_import_host_memory(Device*);
 Buffer* import_buffer_host(Device*, void*, size_t);
 void destroy_buffer(Buffer*);
 

src/runtime/runtime.c

@@ -74,6 +74,8 @@ Command* launch_kernel(Program* p, Device* d, const char* entry_point, int dimx,
 
 bool wait_completion(Command* cmd) { return cmd->wait_for_completion(cmd); }
 
+bool can_import_host_memory(Device* device) { return device->can_import_host_memory(device); }
+
 Buffer* allocate_buffer_device(Device* device, size_t bytes) { return device->allocate_buffer(device, bytes); }
 Buffer* import_buffer_host(Device* device, void* ptr, size_t bytes) { return device->import_host_memory_as_buffer(device, ptr, bytes); }
 

src/runtime/runtime_private.h

@@ -28,6 +28,7 @@ struct Device_ {
     Command* (*launch_kernel)(Device*, Program*, const char* entry_point, int dimx, int dimy, int dimz, int args_count, void** args);
     Buffer* (*allocate_buffer)(Device*, size_t bytes);
     Buffer* (*import_host_memory_as_buffer)(Device*, void* base, size_t bytes);
+    bool (*can_import_host_memory)(Device*);
 };
 
 struct Program_ {

src/runtime/vulkan/vk_runtime_buffer.c

@@ -100,10 +100,27 @@ VkrBuffer* vkr_allocate_buffer_device(VkrDevice* device, size_t size) {
     return NULL;
 }
 
-VkrBuffer* vkr_import_buffer_host(VkrDevice* device, void* ptr, size_t size) {
+static bool vkr_can_import_host_memory_(VkrDevice* device, bool log) {
+    if (!device->caps.supported_extensions[ShadySupportsEXT_external_memory_host]) {
+        if (log)
+            error_print("host imported buffers require VK_EXT_external_memory_host\n");
+        return false;
+    }
     if (!device->caps.features.buffer_device_address.bufferDeviceAddress) {
-        error_print("host imported buffers require VK_KHR_buffer_device_address\n");
-        return NULL;
+        if (log)
+            error_print("host imported buffers require VK_KHR_buffer_device_address\n");
+        return false;
+    }
+    return true;
+}
+
+bool vkr_can_import_host_memory(VkrDevice* device) {
+    return vkr_can_import_host_memory_(device, false);
+}
+
+VkrBuffer* vkr_import_buffer_host(VkrDevice* device, void* ptr, size_t size) {
+    if (!vkr_can_import_host_memory_(device, true)) {
+        error_die();
     }
 
     VkrBuffer* buffer = calloc(sizeof(VkrBuffer), 1);

src/runtime/vulkan/vk_runtime_device.c

@@ -315,6 +315,7 @@ bool probe_vkr_devices(VkrBackend* runtime) {
                 .allocate_buffer = (Buffer*(*)(Device*, size_t)) vkr_allocate_buffer_device,
                 .import_host_memory_as_buffer = (Buffer*(*)(Device*, void*, size_t)) vkr_import_buffer_host,
                 .launch_kernel = (Command*(*)(Device*, Program*, String, int, int, int, int, void**)) vkr_launch_kernel,
+                .can_import_host_memory = vkr_can_import_host_memory,
             };
             append_list(Device*, runtime->base.runtime->devices, device);
         }

src/runtime/vulkan/vk_runtime_private.h

@@ -34,7 +34,7 @@ X(0, KHR_spirv_1_4,                      empty_fns) \
 X(0, KHR_portability_subset,             empty_fns) \
 X(0, KHR_shader_subgroup_extended_types, empty_fns) \
 X(0, EXT_external_memory,                empty_fns) \
-X(1, EXT_external_memory_host,           external_memory_host_fns) \
+X(0, EXT_external_memory_host,           external_memory_host_fns) \
 X(0, EXT_subgroup_size_control,          empty_fns) \
 X(0, KHR_shader_float16_int8,            empty_fns) \
 X(0, KHR_8bit_storage,                   empty_fns) \
@@ -169,6 +169,7 @@ typedef struct VkrBuffer_ {
 
 VkrBuffer* vkr_allocate_buffer_device(VkrDevice* device, size_t size);
 VkrBuffer* vkr_import_buffer_host(VkrDevice* device, void* ptr, size_t size);
+bool vkr_can_import_host_memory(VkrDevice* device);
 
 typedef struct VkrCommand_ VkrCommand;