ac: use 1D GEPs for descriptors and constants

[mesa.git] / src / amd / vulkan / radv_device.c

diff --git a/src/amd/vulkan/radv_device.c b/src/amd/vulkan/radv_device.c
index 039682cb38411aaeedde19cf07b3b073738bc12b..4b64f5101ed3fb187cc9873f0ca0d17842e270a0 100644 (file)
--- a/src/amd/vulkan/radv_device.c
+++ b/src/amd/vulkan/radv_device.c
@@ -960,6 +960,12 @@ void radv_GetPhysicalDeviceFeatures2(
                        features->ycbcrImageArrays = true;
                        break;
                }
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: {
+                       VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *features =
+                               (VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *)ext;
+                       features->uniformBufferStandardLayout = true;
+                       break;
+               }
                default:
                        break;
                }
@@ -3031,7 +3037,6 @@ VkResult radv_QueueSubmit(
                        if (result != VK_SUCCESS)
                                return result;
                }
-               fence->submitted = true;
        }
 
        return VK_SUCCESS;
@@ -3127,6 +3132,23 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(
        return radv_GetInstanceProcAddr(instance, pName);
 }
 
+PUBLIC
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(
+       VkInstance                                  _instance,
+       const char*                                 pName);
+
+PUBLIC
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(
+       VkInstance                                  _instance,
+       const char*                                 pName)
+{
+       RADV_FROM_HANDLE(radv_instance, instance, _instance);
+
+       return radv_lookup_physical_device_entrypoint_checked(pName,
+                                                             instance ? instance->apiVersion : 0,
+                                                             instance ? &instance->enabled_extensions : NULL);
+}
+
 PFN_vkVoidFunction radv_GetDeviceProcAddr(
        VkDevice                                    _device,
        const char*                                 pName)
@@ -3639,8 +3661,6 @@ radv_sparse_image_opaque_bind_memory(struct radv_device *device,
                        }
 
                        fence_emitted = true;
-                       if (fence)
-                               fence->submitted = true;
                }
 
                radv_free_sem_info(&sem_info);
@@ -3653,7 +3673,6 @@ radv_sparse_image_opaque_bind_memory(struct radv_device *device,
                        if (result != VK_SUCCESS)
                                return result;
                }
-               fence->submitted = true;
        }
 
        return VK_SUCCESS;
@@ -3679,8 +3698,6 @@ VkResult radv_CreateFence(
                return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
        fence->fence_wsi = NULL;
-       fence->submitted = false;
-       fence->signalled = !!(pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT);
        fence->temp_syncobj = 0;
        if (device->always_use_syncobj || handleTypes) {
                int ret = device->ws->create_syncobj(device->ws, &fence->syncobj);
@@ -3699,6 +3716,8 @@ VkResult radv_CreateFence(
                        return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
                }
                fence->syncobj = 0;
+               if (pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT)
+                       device->ws->signal_fence(fence->fence);
        }
 
        *pFence = radv_fence_to_handle(fence);
@@ -3746,13 +3765,14 @@ static uint64_t radv_get_absolute_timeout(uint64_t timeout)
 }
 
 
-static bool radv_all_fences_plain_and_submitted(uint32_t fenceCount, const VkFence *pFences)
+static bool radv_all_fences_plain_and_submitted(struct radv_device *device,
+                                                uint32_t fenceCount, const VkFence *pFences)
 {
        for (uint32_t i = 0; i < fenceCount; ++i) {
                RADV_FROM_HANDLE(radv_fence, fence, pFences[i]);
                if (fence->fence == NULL || fence->syncobj ||
-                   fence->temp_syncobj ||
-                   (!fence->signalled && !fence->submitted))
+                   fence->temp_syncobj || fence->fence_wsi ||
+                   (!device->ws->is_fence_waitable(fence->fence)))
                        return false;
        }
        return true;
@@ -3798,7 +3818,7 @@ VkResult radv_WaitForFences(
 
        if (!waitAll && fenceCount > 1) {
                /* Not doing this by default for waitAll, due to needing to allocate twice. */
-               if (device->physical_device->rad_info.drm_minor >= 10 && radv_all_fences_plain_and_submitted(fenceCount, pFences)) {
+               if (device->physical_device->rad_info.drm_minor >= 10 && radv_all_fences_plain_and_submitted(device, fenceCount, pFences)) {
                        uint32_t wait_count = 0;
                        struct radeon_winsys_fence **fences = malloc(sizeof(struct radeon_winsys_fence *) * fenceCount);
                        if (!fences)
@@ -3807,7 +3827,7 @@ VkResult radv_WaitForFences(
                        for (uint32_t i = 0; i < fenceCount; ++i) {
                                RADV_FROM_HANDLE(radv_fence, fence, pFences[i]);
 
-                               if (fence->signalled) {
+                               if (device->ws->fence_wait(device->ws, fence->fence, false, 0)) {
                                        free(fences);
                                        return VK_SUCCESS;
                                }
@@ -3847,23 +3867,11 @@ VkResult radv_WaitForFences(
                        continue;
                }
 
-               if (fence->signalled)
-                       continue;
-
                if (fence->fence) {
-                       if (!fence->submitted) {
-                               while(radv_get_current_time() <= timeout &&
-                                     !fence->submitted)
+                       if (!device->ws->is_fence_waitable(fence->fence)) {
+                               while(!device->ws->is_fence_waitable(fence->fence) &&
+                                     radv_get_current_time() <= timeout)
                                        /* Do nothing */;
-
-                               if (!fence->submitted)
-                                       return VK_TIMEOUT;
-
-                               /* Recheck as it may have been set by
-                                * submitting operations. */
-
-                               if (fence->signalled)
-                                       continue;
                        }
 
                        expired = device->ws->fence_wait(device->ws,
@@ -3878,8 +3886,6 @@ VkResult radv_WaitForFences(
                        if (result != VK_SUCCESS)
                                return result;
                }
-
-               fence->signalled = true;
        }
 
        return VK_SUCCESS;
@@ -3893,7 +3899,8 @@ VkResult radv_ResetFences(VkDevice _device,
 
        for (unsigned i = 0; i < fenceCount; ++i) {
                RADV_FROM_HANDLE(radv_fence, fence, pFences[i]);
-               fence->submitted = fence->signalled = false;
+               if (fence->fence)
+                       device->ws->reset_fence(fence->fence);
 
                /* Per spec, we first restore the permanent payload, and then reset, so
                 * having a temp syncobj should not skip resetting the permanent syncobj. */
@@ -3925,10 +3932,6 @@ VkResult radv_GetFenceStatus(VkDevice _device, VkFence _fence)
                        return success ? VK_SUCCESS : VK_NOT_READY;
        }
 
-       if (fence->signalled)
-               return VK_SUCCESS;
-       if (!fence->submitted)
-               return VK_NOT_READY;
        if (fence->fence) {
                if (!device->ws->fence_wait(device->ws, fence->fence, false, 0))
                        return VK_NOT_READY;
@@ -4380,14 +4383,18 @@ radv_initialise_color_surface(struct radv_device *device,
        }
 
        if (device->physical_device->rad_info.chip_class >= GFX9) {
+               const struct vk_format_description *format_desc = vk_format_description(iview->image->vk_format);
+
                unsigned mip0_depth = iview->image->type == VK_IMAGE_TYPE_3D ?
                  (iview->extent.depth - 1) : (iview->image->info.array_size - 1);
+               unsigned width = iview->extent.width / (iview->plane_id ? format_desc->width_divisor : 1);
+               unsigned height = iview->extent.height / (iview->plane_id ? format_desc->height_divisor : 1);
 
                cb->cb_color_view |= S_028C6C_MIP_LEVEL(iview->base_mip);
                cb->cb_color_attrib |= S_028C74_MIP0_DEPTH(mip0_depth) |
                        S_028C74_RESOURCE_TYPE(surf->u.gfx9.resource_type);
-               cb->cb_color_attrib2 = S_028C68_MIP0_WIDTH(iview->extent.width - 1) |
-                       S_028C68_MIP0_HEIGHT(iview->extent.height - 1) |
+               cb->cb_color_attrib2 = S_028C68_MIP0_WIDTH(width - 1) |
+                       S_028C68_MIP0_HEIGHT(height - 1) |
                        S_028C68_MAX_MIP(iview->image->info.levels - 1);
        }
 }
@@ -4916,7 +4923,7 @@ vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t *pSupportedVersion)
        *          vkDestroySurfaceKHR(), and other API which uses VKSurfaceKHR,
        *          because the loader no longer does so.
        */
-       *pSupportedVersion = MIN2(*pSupportedVersion, 3u);
+       *pSupportedVersion = MIN2(*pSupportedVersion, 4u);
        return VK_SUCCESS;
 }