X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fintel%2Fvulkan%2Fanv_device.c;h=dd2a1ea34ad35703730e6ffcd825ab30aa03b683;hb=0a44a680ff702bb4488c345db84a35c190be345e;hp=7a7d8328db8380cdce9616bfce25d03ed0c397b4;hpb=c633f228b482f21b7646728569f807bb452fddfb;p=mesa.git diff --git a/src/intel/vulkan/anv_device.c b/src/intel/vulkan/anv_device.c index 7a7d8328db8..dd2a1ea34ad 100644 --- a/src/intel/vulkan/anv_device.c +++ b/src/intel/vulkan/anv_device.c @@ -21,18 +21,18 @@ * IN THE SOFTWARE. */ -#include #include #include #include #include -#include #include #include #include "anv_private.h" #include "util/strtod.h" #include "util/debug.h" +#include "util/build_id.h" +#include "util/vk_util.h" #include "genxml/gen7_pack.h" @@ -54,31 +54,18 @@ compiler_perf_log(void *data, const char *fmt, ...) va_end(args); } -static bool -anv_get_function_timestamp(void *ptr, uint32_t* timestamp) -{ - Dl_info info; - struct stat st; - if (!dladdr(ptr, &info) || !info.dli_fname) - return false; - - if (stat(info.dli_fname, &st)) - return false; - - *timestamp = st.st_mtim.tv_sec; - return true; -} - static bool anv_device_get_cache_uuid(void *uuid) { - uint32_t timestamp; + const struct build_id_note *note = build_id_find_nhdr("libvulkan_intel.so"); + if (!note) + return false; - memset(uuid, 0, VK_UUID_SIZE); - if (!anv_get_function_timestamp(anv_device_get_cache_uuid, ×tamp)) + unsigned len = build_id_length(note); + if (len < VK_UUID_SIZE) return false; - snprintf(uuid, VK_UUID_SIZE, "anv-%d", timestamp); + build_id_read(note, uuid, VK_UUID_SIZE); return true; } @@ -215,7 +202,7 @@ anv_physical_device_init(struct anv_physical_device *device, isl_device_init(&device->isl_dev, &device->info, swizzled); - close(fd); + device->local_fd = fd; return VK_SUCCESS; fail: @@ -228,6 +215,7 @@ anv_physical_device_finish(struct anv_physical_device *device) { anv_finish_wsi(device); ralloc_free(device->compiler); + close(device->local_fd); } static const VkExtensionProperties global_extensions[] = { @@ -253,6 +241,10 @@ static const VkExtensionProperties global_extensions[] = { .specVersion = 5, }, #endif + { + .extensionName = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, + .specVersion = 1, + }, }; static const VkExtensionProperties device_extensions[] = { @@ -263,6 +255,14 @@ static const VkExtensionProperties device_extensions[] = { { .extensionName = VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, .specVersion = 1, + }, + { + .extensionName = VK_KHR_MAINTENANCE1_EXTENSION_NAME, + .specVersion = 1, + }, + { + .extensionName = VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, + .specVersion = 1, } }; @@ -445,7 +445,7 @@ void anv_GetPhysicalDeviceFeatures( .imageCubeArray = true, .independentBlend = true, .geometryShader = true, - .tessellationShader = false, + .tessellationShader = true, .sampleRateShading = true, .dualSrcBlend = true, .logicOp = true, @@ -479,7 +479,7 @@ void anv_GetPhysicalDeviceFeatures( .shaderStorageImageArrayDynamicIndexing = true, .shaderClipDistance = true, .shaderCullDistance = true, - .shaderFloat64 = false, + .shaderFloat64 = pdevice->info.gen >= 8, .shaderInt64 = false, .shaderInt16 = false, .shaderResourceMinLod = false, @@ -493,6 +493,21 @@ void anv_GetPhysicalDeviceFeatures( pdevice->compiler->scalar_stage[MESA_SHADER_GEOMETRY]; } +void anv_GetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2KHR* pFeatures) +{ + anv_GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features); + + vk_foreach_struct(ext, pFeatures->pNext) { + switch (ext->sType) { + default: + anv_debug_ignored_stype(ext->sType); + break; + } + } +} + void anv_GetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) @@ -539,19 +554,19 @@ void anv_GetPhysicalDeviceProperties( .maxDescriptorSetSampledImages = 256, .maxDescriptorSetStorageImages = 256, .maxDescriptorSetInputAttachments = 256, - .maxVertexInputAttributes = 32, - .maxVertexInputBindings = 32, + .maxVertexInputAttributes = MAX_VBS, + .maxVertexInputBindings = MAX_VBS, .maxVertexInputAttributeOffset = 2047, .maxVertexInputBindingStride = 2048, .maxVertexOutputComponents = 128, - .maxTessellationGenerationLevel = 0, - .maxTessellationPatchSize = 0, - .maxTessellationControlPerVertexInputComponents = 0, - .maxTessellationControlPerVertexOutputComponents = 0, - .maxTessellationControlPerPatchOutputComponents = 0, - .maxTessellationControlTotalOutputComponents = 0, - .maxTessellationEvaluationInputComponents = 0, - .maxTessellationEvaluationOutputComponents = 0, + .maxTessellationGenerationLevel = 64, + .maxTessellationPatchSize = 32, + .maxTessellationControlPerVertexInputComponents = 128, + .maxTessellationControlPerVertexOutputComponents = 128, + .maxTessellationControlPerPatchOutputComponents = 128, + .maxTessellationControlTotalOutputComponents = 2048, + .maxTessellationEvaluationInputComponents = 128, + .maxTessellationEvaluationOutputComponents = 128, .maxGeometryShaderInvocations = 32, .maxGeometryInputComponents = 64, .maxGeometryOutputComponents = 128, @@ -623,7 +638,7 @@ void anv_GetPhysicalDeviceProperties( }; *pProperties = (VkPhysicalDeviceProperties) { - .apiVersion = VK_MAKE_VERSION(1, 0, 5), + .apiVersion = VK_MAKE_VERSION(1, 0, 39), .driverVersion = 1, .vendorID = 0x8086, .deviceID = pdevice->chipset_id, @@ -636,11 +651,42 @@ void anv_GetPhysicalDeviceProperties( memcpy(pProperties->pipelineCacheUUID, pdevice->uuid, VK_UUID_SIZE); } +void anv_GetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR* pProperties) +{ + anv_GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties); + + vk_foreach_struct(ext, pProperties->pNext) { + switch (ext->sType) { + default: + anv_debug_ignored_stype(ext->sType); + break; + } + } +} + +static void +anv_get_queue_family_properties(struct anv_physical_device *phys_dev, + VkQueueFamilyProperties *props) +{ + *props = (VkQueueFamilyProperties) { + .queueFlags = VK_QUEUE_GRAPHICS_BIT | + VK_QUEUE_COMPUTE_BIT | + VK_QUEUE_TRANSFER_BIT, + .queueCount = 1, + .timestampValidBits = 36, /* XXX: Real value here */ + .minImageTransferGranularity = (VkExtent3D) { 1, 1, 1 }, + }; +} + void anv_GetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) { + ANV_FROM_HANDLE(anv_physical_device, phys_dev, physicalDevice); + if (pQueueFamilyProperties == NULL) { *pCount = 1; return; @@ -655,16 +701,46 @@ void anv_GetPhysicalDeviceQueueFamilyProperties( if (*pCount == 0) return; - *pQueueFamilyProperties = (VkQueueFamilyProperties) { - .queueFlags = VK_QUEUE_GRAPHICS_BIT | - VK_QUEUE_COMPUTE_BIT | - VK_QUEUE_TRANSFER_BIT, - .queueCount = 1, - .timestampValidBits = 36, /* XXX: Real value here */ - .minImageTransferGranularity = (VkExtent3D) { 1, 1, 1 }, - }; - *pCount = 1; + anv_get_queue_family_properties(phys_dev, pQueueFamilyProperties); +} + +void anv_GetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2KHR* pQueueFamilyProperties) +{ + + ANV_FROM_HANDLE(anv_physical_device, phys_dev, physicalDevice); + + if (pQueueFamilyProperties == NULL) { + *pQueueFamilyPropertyCount = 1; + return; + } + + /* The spec implicitly allows the incoming count to be 0. From the Vulkan + * 1.0.38 spec, Section 4.1 Physical Devices: + * + * If the value referenced by pQueueFamilyPropertyCount is not 0 [then + * do stuff]. + */ + if (*pQueueFamilyPropertyCount == 0) + return; + + /* We support exactly one queue family. So need to traverse only the first + * array element's pNext chain. + */ + *pQueueFamilyPropertyCount = 1; + anv_get_queue_family_properties(phys_dev, + &pQueueFamilyProperties->queueFamilyProperties); + + vk_foreach_struct(ext, pQueueFamilyProperties->pNext) { + switch (ext->sType) { + default: + anv_debug_ignored_stype(ext->sType); + break; + } + } } void anv_GetPhysicalDeviceMemoryProperties( @@ -719,6 +795,22 @@ void anv_GetPhysicalDeviceMemoryProperties( }; } +void anv_GetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) +{ + anv_GetPhysicalDeviceMemoryProperties(physicalDevice, + &pMemoryProperties->memoryProperties); + + vk_foreach_struct(ext, pMemoryProperties->pNext) { + switch (ext->sType) { + default: + anv_debug_ignored_stype(ext->sType); + break; + } + } +} + PFN_vkVoidFunction anv_GetInstanceProcAddr( VkInstance instance, const char* pName) @@ -948,7 +1040,7 @@ VkResult anv_CreateDevice( anv_state_pool_init(&device->dynamic_state_pool, &device->dynamic_state_block_pool); - anv_block_pool_init(&device->instruction_block_pool, device, 128 * 1024); + anv_block_pool_init(&device->instruction_block_pool, device, 1024 * 1024); anv_state_pool_init(&device->instruction_state_pool, &device->instruction_block_pool); @@ -1448,11 +1540,12 @@ VkResult anv_InvalidateMappedMemoryRanges( } void anv_GetBufferMemoryRequirements( - VkDevice device, + VkDevice _device, VkBuffer _buffer, VkMemoryRequirements* pMemoryRequirements) { ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); + ANV_FROM_HANDLE(anv_device, device, _device); /* The Vulkan spec (git aaed022) says: * @@ -1461,20 +1554,21 @@ void anv_GetBufferMemoryRequirements( * only if the memory type `i` in the VkPhysicalDeviceMemoryProperties * structure for the physical device is supported. * - * We support exactly one memory type. + * We support exactly one memory type on LLC, two on non-LLC. */ - pMemoryRequirements->memoryTypeBits = 1; + pMemoryRequirements->memoryTypeBits = device->info.has_llc ? 1 : 3; pMemoryRequirements->size = buffer->size; pMemoryRequirements->alignment = 16; } void anv_GetImageMemoryRequirements( - VkDevice device, + VkDevice _device, VkImage _image, VkMemoryRequirements* pMemoryRequirements) { ANV_FROM_HANDLE(anv_image, image, _image); + ANV_FROM_HANDLE(anv_device, device, _device); /* The Vulkan spec (git aaed022) says: * @@ -1483,9 +1577,9 @@ void anv_GetImageMemoryRequirements( * only if the memory type `i` in the VkPhysicalDeviceMemoryProperties * structure for the physical device is supported. * - * We support exactly one memory type. + * We support exactly one memory type on LLC, two on non-LLC. */ - pMemoryRequirements->memoryTypeBits = 1; + pMemoryRequirements->memoryTypeBits = device->info.has_llc ? 1 : 3; pMemoryRequirements->size = image->size; pMemoryRequirements->alignment = image->alignment; @@ -2034,3 +2128,47 @@ void anv_DestroyFramebuffer( vk_free2(&device->alloc, pAllocator, fb); } + +/* vk_icd.h does not declare this function, so we declare it here to + * suppress Wmissing-prototypes. + */ +PUBLIC VKAPI_ATTR VkResult VKAPI_CALL +vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion); + +PUBLIC VKAPI_ATTR VkResult VKAPI_CALL +vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion) +{ + /* For the full details on loader interface versioning, see + * . + * What follows is a condensed summary, to help you navigate the large and + * confusing official doc. + * + * - Loader interface v0 is incompatible with later versions. We don't + * support it. + * + * - In loader interface v1: + * - The first ICD entrypoint called by the loader is + * vk_icdGetInstanceProcAddr(). The ICD must statically expose this + * entrypoint. + * - The ICD must statically expose no other Vulkan symbol unless it is + * linked with -Bsymbolic. + * - Each dispatchable Vulkan handle created by the ICD must be + * a pointer to a struct whose first member is VK_LOADER_DATA. The + * ICD must initialize VK_LOADER_DATA.loadMagic to ICD_LOADER_MAGIC. + * - The loader implements vkCreate{PLATFORM}SurfaceKHR() and + * vkDestroySurfaceKHR(). The ICD must be capable of working with + * such loader-managed surfaces. + * + * - Loader interface v2 differs from v1 in: + * - The first ICD entrypoint called by the loader is + * vk_icdNegotiateLoaderICDInterfaceVersion(). The ICD must + * statically expose this entrypoint. + * + * - Loader interface v3 differs from v2 in: + * - The ICD must implement vkCreate{PLATFORM}SurfaceKHR(), + * vkDestroySurfaceKHR(), and other API which uses VKSurfaceKHR, + * because the loader no longer does so. + */ + *pSupportedVersion = MIN2(*pSupportedVersion, 3u); + return VK_SUCCESS; +}