// Optional bounded hardware check. The Python runner inserts the actual copy-layout functions at the marker. #define VK_NO_PROTOTYPES #include #include #include #include #include #include #include #include #include #include #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN #include #else #include #endif #define CHECK(x) do { if (!(x)) { std::fprintf(stderr,"FAIL:%d %s\n",__LINE__,#x); std::exit(1); } } while (0) #define APIS(X) X(vkCreateInstance) X(vkDestroyInstance) X(vkEnumerateInstanceLayerProperties) \ X(vkEnumerateInstanceExtensionProperties) X(vkEnumeratePhysicalDevices) X(vkGetPhysicalDeviceProperties) \ X(vkGetPhysicalDeviceFormatProperties) X(vkGetPhysicalDeviceQueueFamilyProperties) \ X(vkGetPhysicalDeviceMemoryProperties) X(vkCreateDevice) X(vkDestroyDevice) X(vkGetDeviceQueue) \ X(vkCreateBuffer) X(vkDestroyBuffer) X(vkGetBufferMemoryRequirements) X(vkBindBufferMemory) \ X(vkCreateImage) X(vkDestroyImage) X(vkGetImageMemoryRequirements) X(vkBindImageMemory) \ X(vkAllocateMemory) X(vkFreeMemory) X(vkMapMemory) X(vkUnmapMemory) X(vkCreateCommandPool) \ X(vkDestroyCommandPool) X(vkAllocateCommandBuffers) X(vkBeginCommandBuffer) X(vkEndCommandBuffer) \ X(vkCmdPipelineBarrier) X(vkCmdCopyBufferToImage) X(vkCmdCopyImageToBuffer) X(vkCmdFillBuffer) \ X(vkCreateFence) X(vkDestroyFence) X(vkQueueSubmit) X(vkWaitForFences) #define DECLARE(n) PFN_##n n; APIS(DECLARE) struct Texture {}; struct NvnState { int64_t copy_stride=16; }; struct BufferRef { VkBuffer buffer{}; uint64_t offset=0,size=0; explicit operator bool() const { return buffer!=VK_NULL_HANDLE; } }; VkBuffer copy_buffer; std::atomic validation_errors{0}; void warn(int,const char* text) { std::fprintf(stderr,"%s\n",text); } BufferRef gpu_buffer_bind(uint64_t addr,uint64_t size,bool) { return addr==0x1000 && size<=24 ? BufferRef{copy_buffer,0,size} : BufferRef{}; } // PRODUCTION_COPY_LAYOUT uint32_t memory_type(const VkPhysicalDeviceMemoryProperties& props,uint32_t bits,VkMemoryPropertyFlags required) { for(uint32_t i=0;i(symbol(#n)); api_ready=api_ready && n; APIS(LOAD) #undef LOAD auto gip=reinterpret_cast(symbol("vkGetInstanceProcAddr")); if(!api_ready || !gip) { #ifdef _WIN32 FreeLibrary(loader); #else dlclose(loader); #endif return skip("required Vulkan entry points unavailable"); } uint32_t nl=0; CHECK(vkEnumerateInstanceLayerProperties(&nl,nullptr)==VK_SUCCESS); std::vector layers_list(nl); CHECK(vkEnumerateInstanceLayerProperties(&nl,layers_list.data())==VK_SUCCESS); uint32_t ne=0; CHECK(vkEnumerateInstanceExtensionProperties(nullptr,&ne,nullptr)==VK_SUCCESS); std::vector extensions(ne); CHECK(vkEnumerateInstanceExtensionProperties(nullptr,&ne,extensions.data())==VK_SUCCESS); bool validation=false,debug_utils=false; for(const auto& layer:layers_list) if(!std::strcmp(layer.layerName,"VK_LAYER_KHRONOS_validation")) validation=true; for(const auto& ext:extensions) if(!std::strcmp(ext.extensionName,VK_EXT_DEBUG_UTILS_EXTENSION_NAME)) debug_utils=true; const char* layer="VK_LAYER_KHRONOS_validation"; const char* extension=VK_EXT_DEBUG_UTILS_EXTENSION_NAME; VkDebugUtilsMessengerCreateInfoEXT db{VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT}; db.messageSeverity=VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; db.messageType=VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT|VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT|VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; db.pfnUserCallback=[](VkDebugUtilsMessageSeverityFlagBitsEXT severity,VkDebugUtilsMessageTypeFlagsEXT, const VkDebugUtilsMessengerCallbackDataEXT* data,void*) -> VkBool32 { if(severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) { validation_errors.fetch_add(1,std::memory_order_relaxed); std::fprintf(stderr,"validation: %s\n",data->pMessage); } return VK_FALSE; }; VkApplicationInfo app{VK_STRUCTURE_TYPE_APPLICATION_INFO}; app.apiVersion=VK_API_VERSION_1_1; VkInstanceCreateInfo ici{VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO}; ici.pApplicationInfo=&app; if(validation) { ici.enabledLayerCount=1;ici.ppEnabledLayerNames=&layer; } if(validation && debug_utils) { ici.enabledExtensionCount=1;ici.ppEnabledExtensionNames=&extension;ici.pNext=&db; } VkInstance instance{}; const VkResult instance_result=vkCreateInstance(&ici,nullptr,&instance); if(instance_result==VK_ERROR_INCOMPATIBLE_DRIVER || instance_result==VK_ERROR_INITIALIZATION_FAILED) { #ifdef _WIN32 FreeLibrary(loader); #else dlclose(loader); #endif return skip("Vulkan instance or compatible driver unavailable"); } CHECK(instance_result==VK_SUCCESS); VkDebugUtilsMessengerEXT messenger{}; PFN_vkDestroyDebugUtilsMessengerEXT destroy_debug=nullptr; if(validation && debug_utils) { auto create_debug=reinterpret_cast(gip(instance,"vkCreateDebugUtilsMessengerEXT")); destroy_debug=reinterpret_cast(gip(instance,"vkDestroyDebugUtilsMessengerEXT")); CHECK(create_debug && destroy_debug && create_debug(instance,&db,nullptr,&messenger)==VK_SUCCESS); } std::printf("Khronos validation: %s\n",validation ? (debug_utils ? "enabled" : "enabled; debug utils unavailable") : "unavailable"); uint32_t np=0; const VkResult enumerate_result=vkEnumeratePhysicalDevices(instance,&np,nullptr); if(enumerate_result==VK_ERROR_INITIALIZATION_FAILED) { if(messenger) { destroy_debug(instance,messenger,nullptr); } vkDestroyInstance(instance,nullptr); #ifdef _WIN32 FreeLibrary(loader); #else dlclose(loader); #endif return skip("Vulkan physical-device enumeration unavailable"); } CHECK(enumerate_result==VK_SUCCESS); if(!np) { if(messenger) destroy_debug(instance,messenger,nullptr); vkDestroyInstance(instance,nullptr); #ifdef _WIN32 FreeLibrary(loader); #else dlclose(loader); #endif return skip("no Vulkan physical devices found"); } std::vector devices(np); CHECK(vkEnumeratePhysicalDevices(instance,&np,devices.data())==VK_SUCCESS); VkPhysicalDevice physical{}; VkPhysicalDeviceProperties properties{}; VkPhysicalDeviceMemoryProperties memory{}; uint32_t family=UINT32_MAX; const std::string wanted=requested_device ? lower(requested_device) : std::string{}; for(auto candidate:devices) { VkPhysicalDeviceProperties candidate_properties{}; vkGetPhysicalDeviceProperties(candidate,&candidate_properties); if(candidate_properties.apiVersion < VK_API_VERSION_1_1) continue; if(!wanted.empty() && lower(candidate_properties.deviceName).find(wanted)==std::string::npos) continue; VkFormatProperties format{}; vkGetPhysicalDeviceFormatProperties(candidate,VK_FORMAT_R8G8B8A8_UNORM,&format); const VkFormatFeatureFlags needed=VK_FORMAT_FEATURE_TRANSFER_SRC_BIT|VK_FORMAT_FEATURE_TRANSFER_DST_BIT; if((format.optimalTilingFeatures&needed)!=needed) continue; uint32_t nq=0; vkGetPhysicalDeviceQueueFamilyProperties(candidate,&nq,nullptr); std::vector queues(nq); vkGetPhysicalDeviceQueueFamilyProperties(candidate,&nq,queues.data()); uint32_t candidate_family=UINT32_MAX; for(uint32_t q=0;q