layers: Consolidate GetPhysicalDevice* accessors

Simplified core_validation->descriptor_sets/buffer_validation.

Change-Id: I6921ac458bce5899e8bd60145bfaa0e0f5e8a2ac

diff --git a/layers/buffer_validation.cpp b/layers/buffer_validation.cpp
index bb13fe8..1966faf 100644 (file)
--- a/layers/buffer_validation.cpp
+++ b/layers/buffer_validation.cpp
@@ -442,15 +442,12 @@ void TransitionFinalSubpassLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB,
 bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo *pCreateInfo,
                                 const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
     bool skip_call = false;
-    VkImageFormatProperties ImageFormatProperties;
-    const VkPhysicalDevice physical_device = core_validation::GetPhysicalDevice(device_data);
     const debug_report_data *report_data = core_validation::GetReportData(device_data);
 
     if (pCreateInfo->format != VK_FORMAT_UNDEFINED) {
-        VkFormatProperties properties;
-        core_validation::GetFormatPropertiesPointer(device_data)(physical_device, pCreateInfo->format, &properties);
+        const VkFormatProperties *properties = GetFormatProperties(device_data, pCreateInfo->format);
 
-        if ((pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR) && (properties.linearTilingFeatures == 0)) {
+        if ((pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR) && (properties->linearTilingFeatures == 0)) {
             std::stringstream ss;
             ss << "vkCreateImage format parameter (" << string_VkFormat(pCreateInfo->format) << ") is an unsupported format";
             skip_call |=
@@ -458,7 +455,7 @@ bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo
                         VALIDATION_ERROR_02150, "IMAGE", "%s. %s", ss.str().c_str(), validation_error_map[VALIDATION_ERROR_02150]);
         }
 
-        if ((pCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL) && (properties.optimalTilingFeatures == 0)) {
+        if ((pCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL) && (properties->optimalTilingFeatures == 0)) {
             std::stringstream ss;
             ss << "vkCreateImage format parameter (" << string_VkFormat(pCreateInfo->format) << ") is an unsupported format";
             skip_call |=
@@ -469,7 +466,7 @@ bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo
         // Validate that format supports usage as color attachment
         if (pCreateInfo->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
             if ((pCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL) &&
-                ((properties.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) == 0)) {
+                ((properties->optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) == 0)) {
                 std::stringstream ss;
                 ss << "vkCreateImage: VkFormat for TILING_OPTIMAL image (" << string_VkFormat(pCreateInfo->format)
                    << ") does not support requested Image usage type VK_IMAGE_USAGE_COLOR_ATTACHMENT";
@@ -478,7 +475,7 @@ bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo
                                      validation_error_map[VALIDATION_ERROR_02158]);
             }
             if ((pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR) &&
-                ((properties.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) == 0)) {
+                ((properties->linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) == 0)) {
                 std::stringstream ss;
                 ss << "vkCreateImage: VkFormat for TILING_LINEAR image (" << string_VkFormat(pCreateInfo->format)
                    << ") does not support requested Image usage type VK_IMAGE_USAGE_COLOR_ATTACHMENT";
@@ -490,7 +487,7 @@ bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo
         // Validate that format supports usage as depth/stencil attachment
         if (pCreateInfo->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
             if ((pCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL) &&
-                ((properties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0)) {
+                ((properties->optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0)) {
                 std::stringstream ss;
                 ss << "vkCreateImage: VkFormat for TILING_OPTIMAL image (" << string_VkFormat(pCreateInfo->format)
                    << ") does not support requested Image usage type VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT";
@@ -499,7 +496,7 @@ bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo
                                      validation_error_map[VALIDATION_ERROR_02159]);
             }
             if ((pCreateInfo->tiling == VK_IMAGE_TILING_LINEAR) &&
-                ((properties.linearTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0)) {
+                ((properties->linearTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0)) {
                 std::stringstream ss;
                 ss << "vkCreateImage: VkFormat for TILING_LINEAR image (" << string_VkFormat(pCreateInfo->format)
                    << ") does not support requested Image usage type VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT";
@@ -515,12 +512,10 @@ bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo
                     validation_error_map[VALIDATION_ERROR_00715]);
     }
 
-    // Internal call to get format info.  Still goes through layers, could potentially go directly to ICD.
-    core_validation::GetImageFormatPropertiesPointer(device_data)(physical_device, pCreateInfo->format, pCreateInfo->imageType,
-                                                                  pCreateInfo->tiling, pCreateInfo->usage, pCreateInfo->flags,
-                                                                  &ImageFormatProperties);
+    const VkImageFormatProperties *ImageFormatProperties = GetImageFormatProperties(
+        device_data, pCreateInfo->format, pCreateInfo->imageType, pCreateInfo->tiling, pCreateInfo->usage, pCreateInfo->flags);
 
-    VkDeviceSize imageGranularity = core_validation::GetPhysicalDeviceProperties(device_data)->limits.bufferImageGranularity;
+    VkDeviceSize imageGranularity = GetPhysicalDeviceProperties(device_data)->limits.bufferImageGranularity;
     imageGranularity = imageGranularity == 1 ? 0 : imageGranularity;
 
     if ((pCreateInfo->extent.width <= 0) || (pCreateInfo->extent.height <= 0) || (pCreateInfo->extent.depth <= 0)) {
@@ -534,16 +529,16 @@ bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo
 
     // TODO: VALIDATION_ERROR_02125 VALIDATION_ERROR_02126 VALIDATION_ERROR_02128 VALIDATION_ERROR_00720
     // All these extent-related VUs should be checked here
-    if ((pCreateInfo->extent.depth > ImageFormatProperties.maxExtent.depth) ||
-        (pCreateInfo->extent.width > ImageFormatProperties.maxExtent.width) ||
-        (pCreateInfo->extent.height > ImageFormatProperties.maxExtent.height)) {
+    if ((pCreateInfo->extent.depth > ImageFormatProperties->maxExtent.depth) ||
+        (pCreateInfo->extent.width > ImageFormatProperties->maxExtent.width) ||
+        (pCreateInfo->extent.height > ImageFormatProperties->maxExtent.height)) {
         skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0, __LINE__,
                              IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
                              "CreateImage extents exceed allowable limits for format: "
                              "Width = %d Height = %d Depth = %d:  Limits for Width = %d Height = %d Depth = %d for format %s.",
                              pCreateInfo->extent.width, pCreateInfo->extent.height, pCreateInfo->extent.depth,
-                             ImageFormatProperties.maxExtent.width, ImageFormatProperties.maxExtent.height,
-                             ImageFormatProperties.maxExtent.depth, string_VkFormat(pCreateInfo->format));
+                             ImageFormatProperties->maxExtent.width, ImageFormatProperties->maxExtent.height,
+                             ImageFormatProperties->maxExtent.depth, string_VkFormat(pCreateInfo->format));
     }
 
     uint64_t totalSize = ((uint64_t)pCreateInfo->extent.width * (uint64_t)pCreateInfo->extent.height *
@@ -552,33 +547,33 @@ bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo
                           (uint64_t)imageGranularity) &
                          ~(uint64_t)imageGranularity;
 
-    if (totalSize > ImageFormatProperties.maxResourceSize) {
+    if (totalSize > ImageFormatProperties->maxResourceSize) {
         skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0, __LINE__,
                              IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
                              "CreateImage resource size exceeds allowable maximum "
                              "Image resource size = 0x%" PRIxLEAST64 ", maximum resource size = 0x%" PRIxLEAST64 " ",
-                             totalSize, ImageFormatProperties.maxResourceSize);
+                             totalSize, ImageFormatProperties->maxResourceSize);
     }
 
     // TODO: VALIDATION_ERROR_02132
-    if (pCreateInfo->mipLevels > ImageFormatProperties.maxMipLevels) {
+    if (pCreateInfo->mipLevels > ImageFormatProperties->maxMipLevels) {
         skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0, __LINE__,
                              IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
                              "CreateImage mipLevels=%d exceeds allowable maximum supported by format of %d", pCreateInfo->mipLevels,
-                             ImageFormatProperties.maxMipLevels);
+                             ImageFormatProperties->maxMipLevels);
     }
 
-    if (pCreateInfo->arrayLayers > ImageFormatProperties.maxArrayLayers) {
+    if (pCreateInfo->arrayLayers > ImageFormatProperties->maxArrayLayers) {
         skip_call |= log_msg(
             report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0, __LINE__, VALIDATION_ERROR_02133,
             "Image", "CreateImage arrayLayers=%d exceeds allowable maximum supported by format of %d. %s", pCreateInfo->arrayLayers,
-            ImageFormatProperties.maxArrayLayers, validation_error_map[VALIDATION_ERROR_02133]);
+            ImageFormatProperties->maxArrayLayers, validation_error_map[VALIDATION_ERROR_02133]);
     }
 
-    if ((pCreateInfo->samples & ImageFormatProperties.sampleCounts) == 0) {
+    if ((pCreateInfo->samples & ImageFormatProperties->sampleCounts) == 0) {
         skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0, __LINE__,
                              VALIDATION_ERROR_02138, "Image", "CreateImage samples %s is not supported by format 0x%.8X. %s",
-                             string_VkSampleCountFlagBits(pCreateInfo->samples), ImageFormatProperties.sampleCounts,
+                             string_VkSampleCountFlagBits(pCreateInfo->samples), ImageFormatProperties->sampleCounts,
                              validation_error_map[VALIDATION_ERROR_02138]);
     }
 
@@ -2268,11 +2263,13 @@ bool PreCallValidateCreateImageView(layer_data *device_data, const VkImageViewCr
     return skip;
 }
 
-void PostCallRecordCreateImageView(layer_data *device_data, const VkImageViewCreateInfo *create_info,
-                                                 VkImageView view) {
-    (*GetImageViewMap(device_data))[view] = std::unique_ptr<IMAGE_VIEW_STATE>(new IMAGE_VIEW_STATE(view, create_info));
-    ResolveRemainingLevelsLayers(device_data, &(*GetImageViewMap(device_data))[view].get()->create_info.subresourceRange,
-                                 GetImageState(device_data, create_info->image));
+void PostCallRecordCreateImageView(layer_data *device_data, const VkImageViewCreateInfo *create_info, VkImageView view) {
+    auto image_view_map = GetImageViewMap(device_data);
+    (*image_view_map)[view] = std::unique_ptr<IMAGE_VIEW_STATE>(new IMAGE_VIEW_STATE(view, create_info));
+
+    auto image_state = GetImageState(device_data, create_info->image);
+    auto sub_res_range = (*image_view_map)[view].get()->create_info.subresourceRange;
+    ResolveRemainingLevelsLayers(device_data, &sub_res_range, image_state);
 }
 
 bool PreCallValidateCmdCopyBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buffer_state,

diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp
index 3080c26..3c84942 100644 (file)
--- a/layers/core_validation.cpp
+++ b/layers/core_validation.cpp
@@ -2073,10 +2073,6 @@ static PIPELINE_LAYOUT_NODE const *getPipelineLayout(layer_data const *dev_data,
     return &it->second;
 }
 
-VkPhysicalDeviceLimits GetPhysicalDeviceLimits(layer_data const *dev_data) {
-    return dev_data->phys_dev_properties.properties.limits;
-}
-
 // Return true if for a given PSO, the given state enum is dynamic, else return false
 static bool isDynamic(const PIPELINE_STATE *pPipeline, const VkDynamicState state) {
     if (pPipeline && pPipeline->graphicsPipelineCI.pDynamicState) {
@@ -6010,16 +6006,25 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferV
 }
 
 // Access helper functions for external modules
-PFN_vkGetPhysicalDeviceFormatProperties GetFormatPropertiesPointer(core_validation::layer_data *device_data) {
-    return device_data->instance_data->dispatch_table.GetPhysicalDeviceFormatProperties;
+const VkFormatProperties *GetFormatProperties(core_validation::layer_data *device_data, VkFormat format) {
+    VkFormatProperties *format_properties = new VkFormatProperties;
+    instance_layer_data *instance_data =
+        GetLayerDataPtr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map);
+    instance_data->dispatch_table.GetPhysicalDeviceFormatProperties(device_data->physical_device, format, format_properties);
+    return format_properties;
 }
 
-PFN_vkGetPhysicalDeviceImageFormatProperties GetImageFormatPropertiesPointer(core_validation::layer_data *device_data) {
-    return device_data->instance_data->dispatch_table.GetPhysicalDeviceImageFormatProperties;
+const VkImageFormatProperties *GetImageFormatProperties(core_validation::layer_data *device_data, VkFormat format,
+                                                        VkImageType image_type, VkImageTiling tiling, VkImageUsageFlags usage,
+                                                        VkImageCreateFlags flags) {
+    VkImageFormatProperties *image_format_properties = new VkImageFormatProperties;
+    instance_layer_data *instance_data =
+        GetLayerDataPtr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map);
+    instance_data->dispatch_table.GetPhysicalDeviceImageFormatProperties(device_data->physical_device, format, image_type, tiling,
+                                                                         usage, flags, image_format_properties);
+    return image_format_properties;
 }
 
-VkPhysicalDevice GetPhysicalDevice(core_validation::layer_data *device_data) { return device_data->physical_device; }
-
 const debug_report_data *GetReportData(core_validation::layer_data *device_data) { return device_data->report_data; }
 
 const VkPhysicalDeviceProperties *GetPhysicalDeviceProperties(core_validation::layer_data *device_data) {
@@ -6052,7 +6057,7 @@ std::unordered_map<VkImageView, std::unique_ptr<IMAGE_VIEW_STATE>> *GetImageView
     return &device_data->imageViewMap;
 }
 
-PHYS_DEV_PROPERTIES_NODE *GetPhysDevProperties(layer_data *device_data) {
+const PHYS_DEV_PROPERTIES_NODE *GetPhysDevProperties(const layer_data *device_data) {
     return &device_data->phys_dev_properties;
 }
 

diff --git a/layers/core_validation_types.h b/layers/core_validation_types.h
index f8cea97..a62e69a 100644 (file)
--- a/layers/core_validation_types.h
+++ b/layers/core_validation_types.h
@@ -758,7 +758,7 @@ GLOBAL_CB_NODE *GetCBNode(layer_data const *my_data, const VkCommandBuffer cb);
 RENDER_PASS_STATE *GetRenderPassState(layer_data const *my_data, VkRenderPass renderpass);
 FRAMEBUFFER_STATE *GetFramebufferState(const layer_data *my_data, VkFramebuffer framebuffer);
 COMMAND_POOL_NODE *GetCommandPoolNode(layer_data *dev_data, VkCommandPool pool);
-PHYS_DEV_PROPERTIES_NODE *GetPhysDevProperties(layer_data *device_data);
+const PHYS_DEV_PROPERTIES_NODE *GetPhysDevProperties(const layer_data *device_data);
 
 void invalidateCommandBuffers(const layer_data *, std::unordered_set<GLOBAL_CB_NODE *> const &, VK_OBJECT);
 bool ValidateMemoryIsBoundToBuffer(const layer_data *, const BUFFER_STATE *, const char *, UNIQUE_VALIDATION_ERROR_CODE);
@@ -779,7 +779,6 @@ void UpdateCmdBufferLastCmd(GLOBAL_CB_NODE *cb_state, const CMD_TYPE cmd);
 bool outsideRenderPass(const layer_data *my_data, GLOBAL_CB_NODE *pCB, const char *apiName, UNIQUE_VALIDATION_ERROR_CODE msgCode);
 void SetLayout(GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const IMAGE_CMD_BUF_LAYOUT_NODE &node);
 void SetLayout(GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const VkImageLayout &layout);
-VkPhysicalDeviceLimits GetPhysicalDeviceLimits(layer_data const *);
 bool ValidateImageMemoryIsValid(layer_data *dev_data, IMAGE_STATE *image_state, const char *functionName);
 bool ValidateImageSampleCount(layer_data *dev_data, IMAGE_STATE *image_state, VkSampleCountFlagBits sample_count,
                               const char *location, UNIQUE_VALIDATION_ERROR_CODE msgCode);
@@ -790,9 +789,10 @@ void SetBufferMemoryValid(layer_data *dev_data, BUFFER_STATE *buffer_state, bool
 
 
 // Prototypes for layer_data accessor functions.  These should be in their own header file at some point
-PFN_vkGetPhysicalDeviceFormatProperties GetFormatPropertiesPointer(layer_data *);
-PFN_vkGetPhysicalDeviceImageFormatProperties GetImageFormatPropertiesPointer(layer_data *);
-VkPhysicalDevice GetPhysicalDevice(layer_data *);
+const VkFormatProperties *GetFormatProperties(core_validation::layer_data *device_data, VkFormat format);
+const VkImageFormatProperties *GetImageFormatProperties(core_validation::layer_data *device_data, VkFormat format,
+                                                        VkImageType image_type, VkImageTiling tiling, VkImageUsageFlags usage,
+                                                        VkImageCreateFlags flags);
 const debug_report_data *GetReportData(layer_data *);
 const VkPhysicalDeviceProperties *GetPhysicalDeviceProperties(layer_data *);
 const CHECK_DISABLED *GetDisables(layer_data *);

diff --git a/layers/descriptor_sets.cpp b/layers/descriptor_sets.cpp
index 44769ce..ad3d720 100644 (file)
--- a/layers/descriptor_sets.cpp
+++ b/layers/descriptor_sets.cpp
@@ -309,7 +309,7 @@ cvdescriptorset::DescriptorSet::DescriptorSet(const VkDescriptorSet set, const V
       pool_state_(nullptr),
       p_layout_(layout),
       device_data_(dev_data),
-      limits_(GetPhysicalDeviceLimits(dev_data)) {
+      limits_(GetPhysDevProperties(dev_data)->properties.limits) {
     pool_state_ = GetDescriptorPoolState(dev_data, pool);
     // Foreach binding, create default descriptors of given type
     for (uint32_t i = 0; i < p_layout_->GetBindingCount(); ++i) {