layers/descriptor_sets.h

   1 /* Copyright (c) 2015-2016 The Khronos Group Inc.
   2  * Copyright (c) 2015-2016 Valve Corporation
   3  * Copyright (c) 2015-2016 LunarG, Inc.
   4  * Copyright (C) 2015-2016 Google Inc.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * Author: Tobin Ehlis <tobine@google.com>
  19  *         John Zulauf <jzulauf@lunarg.com>
  20  */
  21 #ifndef CORE_VALIDATION_DESCRIPTOR_SETS_H_
  22 #define CORE_VALIDATION_DESCRIPTOR_SETS_H_
  23
  24 #include "core_validation_error_enums.h"
  25 #include "vk_validation_error_messages.h"
  26 #include "core_validation_types.h"
  27 #include "hash_vk_types.h"
  28 #include "vk_layer_logging.h"
  29 #include "vk_layer_utils.h"
  30 #include "vk_safe_struct.h"
  31 #include "vulkan/vk_layer.h"
  32 #include "vk_object_types.h"
  33 #include <map>
  34 #include <memory>
  35 #include <set>
  36 #include <unordered_map>
  37 #include <unordered_set>
  38 #include <vector>
  39
  40 using core_validation::layer_data;
  41
  42 // Descriptor Data structures
  43 namespace cvdescriptorset {
  44
  45 // Utility structs/classes/types
  46 // Index range for global indices below, end is exclusive, i.e. [start,end)
  47 struct IndexRange {
  48     IndexRange(uint32_t start_in, uint32_t end_in) : start(start_in), end(end_in) {}
  49     IndexRange() = default;
  50     uint32_t start;
  51     uint32_t end;
  52 };
  53 typedef std::map<uint32_t, descriptor_req> BindingReqMap;
  54
  55 /*
  56  * DescriptorSetLayoutDef/DescriptorSetLayout classes
  57  *
  58  * Overview - These two classes encapsulate the Vulkan VkDescriptorSetLayout data (layout).
  59  *   A layout consists of some number of bindings, each of which has a binding#, a
  60  *   type, descriptor count, stage flags, and pImmutableSamplers.
  61
  62  *   The DescriptorSetLayoutDef represents a canonicalization of the input data and contains
  63  *   neither per handle or per device state.  It is possible for different handles on
  64  *   different devices to share a common def.  This is used and useful for quick compatibiltiy
  65  *   validation.  The DescriptorSetLayout refers to a DescriptorSetLayoutDef and contains
  66  *   all per handle state.
  67  *
  68  * Index vs Binding - A layout is created with an array of VkDescriptorSetLayoutBinding
  69  *  where each array index will have a corresponding binding# that is defined in that struct.
  70  *  The binding#, then, is decoupled from VkDescriptorSetLayoutBinding index, which allows
  71  *  bindings to be defined out-of-order. This DescriptorSetLayout class, however, stores
  72  *  the bindings internally in-order. This is useful for operations which may "roll over"
  73  *  from a single binding to the next consecutive binding.
  74  *
  75  *  Note that although the bindings are stored in-order, there still may be "gaps" in the
  76  *  binding#. For example, if the binding creation order is 8, 7, 10, 3, 4, then the
  77  *  internal binding array will have five entries stored in binding order 3, 4, 7, 8, 10.
  78  *  To process all of the bindings in a layout you can iterate from 0 to GetBindingCount()
  79  *  and use the Get*FromIndex() functions for each index. To just process a single binding,
  80  *  use the Get*FromBinding() functions.
  81  *
  82  * Global Index - The binding vector index has as many indices as there are bindings.
  83  *  This class also has the concept of a Global Index. For the global index functions,
  84  *  there are as many global indices as there are descriptors in the layout.
  85  *  For the global index, consider all of the bindings to be a flat array where
  86  *  descriptor 0 of of the lowest binding# is index 0 and each descriptor in the layout
  87  *  increments from there. So if the lowest binding# in this example had descriptorCount of
  88  *  10, then the GlobalStartIndex of the 2nd lowest binding# will be 10 where 0-9 are the
  89  *  global indices for the lowest binding#.
  90  */
  91 class DescriptorSetLayoutDef {
  92    public:
  93     // Constructors and destructor
  94     DescriptorSetLayoutDef(const VkDescriptorSetLayoutCreateInfo *p_create_info);
  95     size_t hash() const;
  96
  97     uint32_t GetTotalDescriptorCount() const { return descriptor_count_; };
  98     uint32_t GetDynamicDescriptorCount() const { return dynamic_descriptor_count_; };
  99     VkDescriptorSetLayoutCreateFlags GetCreateFlags() const { return flags_; }
 100     // For a given binding, return the number of descriptors in that binding and all successive bindings
 101     uint32_t GetBindingCount() const { return binding_count_; };
 102     // Non-empty binding numbers in order
 103     const std::set<uint32_t> &GetSortedBindingSet() const { return non_empty_bindings_; }
 104     // Return true if given binding is present in this layout
 105     bool HasBinding(const uint32_t binding) const { return binding_to_index_map_.count(binding) > 0; };
 106     // Return true if this DSL Def (referenced by the 1st layout) is compatible with another DSL Def (ref'd from the 2nd layout)
 107     // else return false and update error_msg with description of incompatibility
 108     bool IsCompatible(VkDescriptorSetLayout, VkDescriptorSetLayout, DescriptorSetLayoutDef const *const, std::string *) const;
 109     // Return true if binding 1 beyond given exists and has same type, stageFlags & immutable sampler use
 110     bool IsNextBindingConsistent(const uint32_t) const;
 111     uint32_t GetIndexFromBinding(uint32_t binding) const;
 112     // Various Get functions that can either be passed a binding#, which will
 113     //  be automatically translated into the appropriate index, or the index# can be passed in directly
 114     uint32_t GetMaxBinding() const { return bindings_[bindings_.size() - 1].binding; }
 115     VkDescriptorSetLayoutBinding const *GetDescriptorSetLayoutBindingPtrFromIndex(const uint32_t) const;
 116     VkDescriptorSetLayoutBinding const *GetDescriptorSetLayoutBindingPtrFromBinding(uint32_t binding) const {
 117         return GetDescriptorSetLayoutBindingPtrFromIndex(GetIndexFromBinding(binding));
 118     }
 119     const std::vector<safe_VkDescriptorSetLayoutBinding> &GetBindings() const { return bindings_; }
 120     uint32_t GetDescriptorCountFromIndex(const uint32_t) const;
 121     uint32_t GetDescriptorCountFromBinding(const uint32_t binding) const {
 122         return GetDescriptorCountFromIndex(GetIndexFromBinding(binding));
 123     }
 124     VkDescriptorType GetTypeFromIndex(const uint32_t) const;
 125     VkDescriptorType GetTypeFromBinding(const uint32_t binding) const { return GetTypeFromIndex(GetIndexFromBinding(binding)); }
 126     VkShaderStageFlags GetStageFlagsFromIndex(const uint32_t) const;
 127     VkShaderStageFlags GetStageFlagsFromBinding(const uint32_t binding) const {
 128         return GetStageFlagsFromIndex(GetIndexFromBinding(binding));
 129     }
 130     VkDescriptorBindingFlagsEXT GetDescriptorBindingFlagsFromIndex(const uint32_t) const;
 131     VkDescriptorBindingFlagsEXT GetDescriptorBindingFlagsFromBinding(const uint32_t binding) const {
 132         return GetDescriptorBindingFlagsFromIndex(GetIndexFromBinding(binding));
 133     }
 134     uint32_t GetIndexFromGlobalIndex(const uint32_t global_index) const;
 135     VkDescriptorType GetTypeFromGlobalIndex(const uint32_t global_index) const {
 136         return GetTypeFromIndex(GetIndexFromGlobalIndex(global_index));
 137     }
 138     VkSampler const *GetImmutableSamplerPtrFromBinding(const uint32_t) const;
 139     VkSampler const *GetImmutableSamplerPtrFromIndex(const uint32_t) const;
 140     // For a given binding and array index, return the corresponding index into the dynamic offset array
 141     int32_t GetDynamicOffsetIndexFromBinding(uint32_t binding) const {
 142         auto dyn_off = binding_to_dynamic_array_idx_map_.find(binding);
 143         if (dyn_off == binding_to_dynamic_array_idx_map_.end()) {
 144             assert(0);  // Requesting dyn offset for invalid binding/array idx pair
 145             return -1;
 146         }
 147         return dyn_off->second;
 148     }
 149     // For a particular binding, get the global index range
 150     //  This call should be guarded by a call to "HasBinding(binding)" to verify that the given binding exists
 151     const IndexRange &GetGlobalIndexRangeFromBinding(const uint32_t) const;
 152
 153     // Helper function to get the next valid binding for a descriptor
 154     uint32_t GetNextValidBinding(const uint32_t) const;
 155     // For a particular binding starting at offset and having update_count descriptors
 156     //  updated, verify that for any binding boundaries crossed, the update is consistent
 157     bool VerifyUpdateConsistency(uint32_t, uint32_t, uint32_t, const char *, const VkDescriptorSet, std::string *) const;
 158     bool IsPushDescriptor() const { return GetCreateFlags() & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR; };
 159
 160     struct BindingTypeStats {
 161         uint32_t dynamic_buffer_count;
 162         uint32_t non_dynamic_buffer_count;
 163         uint32_t image_sampler_count;
 164     };
 165     const BindingTypeStats &GetBindingTypeStats() const { return binding_type_stats_; }
 166
 167    private:
 168     // Only the first two data members are used for hash and equality checks, the other members are derived from them, and are used
 169     // to speed up the various lookups/queries/validations
 170     VkDescriptorSetLayoutCreateFlags flags_;
 171     std::vector<safe_VkDescriptorSetLayoutBinding> bindings_;
 172     std::vector<VkDescriptorBindingFlagsEXT> binding_flags_;
 173
 174     // Convenience data structures for rapid lookup of various descriptor set layout properties
 175     std::set<uint32_t> non_empty_bindings_;  // Containing non-emtpy bindings in numerical order
 176     std::unordered_map<uint32_t, uint32_t> binding_to_index_map_;
 177     // The following map allows an non-iterative lookup of a binding from a global index...
 178     std::map<uint32_t, uint32_t> global_start_to_index_map_;  // The index corresponding for a starting global (descriptor) index
 179     std::unordered_map<uint32_t, IndexRange> binding_to_global_index_range_map_;  // range is exclusive of .end
 180     // For a given binding map to associated index in the dynamic offset array
 181     std::unordered_map<uint32_t, uint32_t> binding_to_dynamic_array_idx_map_;
 182
 183     uint32_t binding_count_;     // # of bindings in this layout
 184     uint32_t descriptor_count_;  // total # descriptors in this layout
 185     uint32_t dynamic_descriptor_count_;
 186     BindingTypeStats binding_type_stats_;
 187 };
 188
 189 static bool operator==(const DescriptorSetLayoutDef &lhs, const DescriptorSetLayoutDef &rhs) {
 190     return (lhs.GetCreateFlags() == rhs.GetCreateFlags()) && (lhs.GetBindings() == rhs.GetBindings());
 191 }
 192
 193 // Canonical dictionary of DSL definitions -- independent of device or handle
 194 using DescriptorSetLayoutDict = hash_util::Dictionary<DescriptorSetLayoutDef, hash_util::HasHashMember<DescriptorSetLayoutDef>>;
 195 using DescriptorSetLayoutId = DescriptorSetLayoutDict::Id;
 196
 197 class DescriptorSetLayout {
 198    public:
 199     // Constructors and destructor
 200     DescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo *p_create_info, const VkDescriptorSetLayout layout);
 201     // Validate create info - should be called prior to creation
 202     static bool ValidateCreateInfo(const debug_report_data *, const VkDescriptorSetLayoutCreateInfo *, const bool, const uint32_t,
 203                                    const bool, const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *descriptor_indexing_features);
 204     bool HasBinding(const uint32_t binding) const { return layout_id_->HasBinding(binding); }
 205     // Return true if this layout is compatible with passed in layout from a pipelineLayout,
 206     //   else return false and update error_msg with description of incompatibility
 207     bool IsCompatible(DescriptorSetLayout const *const, std::string *) const;
 208     // Straightforward Get functions
 209     VkDescriptorSetLayout GetDescriptorSetLayout() const { return layout_; };
 210     bool IsDestroyed() const { return layout_destroyed_; }
 211     void MarkDestroyed() { layout_destroyed_ = true; }
 212     const DescriptorSetLayoutDef *get_layout_def() const { return layout_id_.get(); }
 213     DescriptorSetLayoutId get_layout_id() const { return layout_id_; }
 214     uint32_t GetTotalDescriptorCount() const { return layout_id_->GetTotalDescriptorCount(); };
 215     uint32_t GetDynamicDescriptorCount() const { return layout_id_->GetDynamicDescriptorCount(); };
 216     uint32_t GetBindingCount() const { return layout_id_->GetBindingCount(); };
 217     VkDescriptorSetLayoutCreateFlags GetCreateFlags() const { return layout_id_->GetCreateFlags(); }
 218     bool IsNextBindingConsistent(const uint32_t) const;
 219     uint32_t GetIndexFromBinding(uint32_t binding) const { return layout_id_->GetIndexFromBinding(binding); }
 220     // Various Get functions that can either be passed a binding#, which will
 221     //  be automatically translated into the appropriate index, or the index# can be passed in directly
 222     uint32_t GetMaxBinding() const { return layout_id_->GetMaxBinding(); }
 223     VkDescriptorSetLayoutBinding const *GetDescriptorSetLayoutBindingPtrFromIndex(const uint32_t index) const {
 224         return layout_id_->GetDescriptorSetLayoutBindingPtrFromIndex(index);
 225     }
 226     VkDescriptorSetLayoutBinding const *GetDescriptorSetLayoutBindingPtrFromBinding(uint32_t binding) const {
 227         return layout_id_->GetDescriptorSetLayoutBindingPtrFromBinding(binding);
 228     }
 229     const std::vector<safe_VkDescriptorSetLayoutBinding> &GetBindings() const { return layout_id_->GetBindings(); }
 230     uint32_t GetDescriptorCountFromIndex(const uint32_t index) const { return layout_id_->GetDescriptorCountFromIndex(index); }
 231     uint32_t GetDescriptorCountFromBinding(const uint32_t binding) const {
 232         return layout_id_->GetDescriptorCountFromBinding(binding);
 233     }
 234     VkDescriptorType GetTypeFromIndex(const uint32_t index) const { return layout_id_->GetTypeFromIndex(index); }
 235     VkDescriptorType GetTypeFromBinding(const uint32_t binding) const { return layout_id_->GetTypeFromBinding(binding); }
 236     VkShaderStageFlags GetStageFlagsFromIndex(const uint32_t index) const { return layout_id_->GetStageFlagsFromIndex(index); }
 237     VkShaderStageFlags GetStageFlagsFromBinding(const uint32_t binding) const {
 238         return layout_id_->GetStageFlagsFromBinding(binding);
 239     }
 240     VkDescriptorBindingFlagsEXT GetDescriptorBindingFlagsFromIndex(const uint32_t index) const {
 241         return layout_id_->GetDescriptorBindingFlagsFromIndex(index);
 242     }
 243     VkDescriptorBindingFlagsEXT GetDescriptorBindingFlagsFromBinding(const uint32_t binding) const {
 244         return layout_id_->GetDescriptorBindingFlagsFromBinding(binding);
 245     }
 246     uint32_t GetIndexFromGlobalIndex(const uint32_t global_index) const {
 247         return layout_id_->GetIndexFromGlobalIndex(global_index);
 248     }
 249     VkDescriptorType GetTypeFromGlobalIndex(const uint32_t global_index) const {
 250         return GetTypeFromIndex(GetIndexFromGlobalIndex(global_index));
 251     }
 252     VkSampler const *GetImmutableSamplerPtrFromBinding(const uint32_t binding) const {
 253         return layout_id_->GetImmutableSamplerPtrFromBinding(binding);
 254     }
 255     VkSampler const *GetImmutableSamplerPtrFromIndex(const uint32_t index) const {
 256         return layout_id_->GetImmutableSamplerPtrFromIndex(index);
 257     }
 258     // For a given binding and array index, return the corresponding index into the dynamic offset array
 259     int32_t GetDynamicOffsetIndexFromBinding(uint32_t binding) const {
 260         return layout_id_->GetDynamicOffsetIndexFromBinding(binding);
 261     }
 262     // For a particular binding, get the global index range
 263     //  This call should be guarded by a call to "HasBinding(binding)" to verify that the given binding exists
 264     const IndexRange &GetGlobalIndexRangeFromBinding(const uint32_t binding) const {
 265         return layout_id_->GetGlobalIndexRangeFromBinding(binding);
 266     }
 267     // Helper function to get the next valid binding for a descriptor
 268     uint32_t GetNextValidBinding(const uint32_t binding) const { return layout_id_->GetNextValidBinding(binding); }
 269     // For a particular binding starting at offset and having update_count descriptors
 270     //  updated, verify that for any binding boundaries crossed, the update is consistent
 271     bool VerifyUpdateConsistency(uint32_t current_binding, uint32_t offset, uint32_t update_count, const char *type,
 272                                  const VkDescriptorSet set, std::string *error_msg) const {
 273         return layout_id_->VerifyUpdateConsistency(current_binding, offset, update_count, type, set, error_msg);
 274     }
 275     bool IsPushDescriptor() const { return layout_id_->IsPushDescriptor(); }
 276
 277     using BindingTypeStats = DescriptorSetLayoutDef::BindingTypeStats;
 278     const BindingTypeStats &GetBindingTypeStats() const { return layout_id_->GetBindingTypeStats(); }
 279
 280    private:
 281     VkDescriptorSetLayout layout_;
 282     bool layout_destroyed_;
 283     DescriptorSetLayoutId layout_id_;
 284 };
 285
 286 /*
 287  * Descriptor classes
 288  *  Descriptor is an abstract base class from which 5 separate descriptor types are derived.
 289  *   This allows the WriteUpdate() and CopyUpdate() operations to be specialized per
 290  *   descriptor type, but all descriptors in a set can be accessed via the common Descriptor*.
 291  */
 292
 293 // Slightly broader than type, each c++ "class" will has a corresponding "DescriptorClass"
 294 enum DescriptorClass { PlainSampler, ImageSampler, Image, TexelBuffer, GeneralBuffer };
 295
 296 class Descriptor {
 297    public:
 298     virtual ~Descriptor(){};
 299     virtual void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) = 0;
 300     virtual void CopyUpdate(const Descriptor *) = 0;
 301     // Create binding between resources of this descriptor and given cb_node
 302     virtual void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) = 0;
 303     virtual DescriptorClass GetClass() const { return descriptor_class; };
 304     // Special fast-path check for SamplerDescriptors that are immutable
 305     virtual bool IsImmutableSampler() const { return false; };
 306     // Check for dynamic descriptor type
 307     virtual bool IsDynamic() const { return false; };
 308     // Check for storage descriptor type
 309     virtual bool IsStorage() const { return false; };
 310     bool updated;  // Has descriptor been updated?
 311     DescriptorClass descriptor_class;
 312 };
 313 // Shared helper functions - These are useful because the shared sampler image descriptor type
 314 //  performs common functions with both sampler and image descriptors so they can share their common functions
 315 bool ValidateSampler(const VkSampler, const core_validation::layer_data *);
 316 bool ValidateImageUpdate(VkImageView, VkImageLayout, VkDescriptorType, const core_validation::layer_data *,
 317                          UNIQUE_VALIDATION_ERROR_CODE *, std::string *);
 318
 319 class SamplerDescriptor : public Descriptor {
 320    public:
 321     SamplerDescriptor(const VkSampler *);
 322     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
 323     void CopyUpdate(const Descriptor *) override;
 324     void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override;
 325     virtual bool IsImmutableSampler() const override { return immutable_; };
 326     VkSampler GetSampler() const { return sampler_; }
 327
 328    private:
 329     // bool ValidateSampler(const VkSampler) const;
 330     VkSampler sampler_;
 331     bool immutable_;
 332 };
 333
 334 class ImageSamplerDescriptor : public Descriptor {
 335    public:
 336     ImageSamplerDescriptor(const VkSampler *);
 337     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
 338     void CopyUpdate(const Descriptor *) override;
 339     void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override;
 340     virtual bool IsImmutableSampler() const override { return immutable_; };
 341     VkSampler GetSampler() const { return sampler_; }
 342     VkImageView GetImageView() const { return image_view_; }
 343     VkImageLayout GetImageLayout() const { return image_layout_; }
 344
 345    private:
 346     VkSampler sampler_;
 347     bool immutable_;
 348     VkImageView image_view_;
 349     VkImageLayout image_layout_;
 350 };
 351
 352 class ImageDescriptor : public Descriptor {
 353    public:
 354     ImageDescriptor(const VkDescriptorType);
 355     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
 356     void CopyUpdate(const Descriptor *) override;
 357     void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override;
 358     virtual bool IsStorage() const override { return storage_; }
 359     VkImageView GetImageView() const { return image_view_; }
 360     VkImageLayout GetImageLayout() const { return image_layout_; }
 361
 362    private:
 363     bool storage_;
 364     VkImageView image_view_;
 365     VkImageLayout image_layout_;
 366 };
 367
 368 class TexelDescriptor : public Descriptor {
 369    public:
 370     TexelDescriptor(const VkDescriptorType);
 371     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
 372     void CopyUpdate(const Descriptor *) override;
 373     void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override;
 374     virtual bool IsStorage() const override { return storage_; }
 375     VkBufferView GetBufferView() const { return buffer_view_; }
 376
 377    private:
 378     VkBufferView buffer_view_;
 379     bool storage_;
 380 };
 381
 382 class BufferDescriptor : public Descriptor {
 383    public:
 384     BufferDescriptor(const VkDescriptorType);
 385     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
 386     void CopyUpdate(const Descriptor *) override;
 387     void BindCommandBuffer(const core_validation::layer_data *, GLOBAL_CB_NODE *) override;
 388     virtual bool IsDynamic() const override { return dynamic_; }
 389     virtual bool IsStorage() const override { return storage_; }
 390     VkBuffer GetBuffer() const { return buffer_; }
 391     VkDeviceSize GetOffset() const { return offset_; }
 392     VkDeviceSize GetRange() const { return range_; }
 393
 394    private:
 395     bool storage_;
 396     bool dynamic_;
 397     VkBuffer buffer_;
 398     VkDeviceSize offset_;
 399     VkDeviceSize range_;
 400 };
 401 // Structs to contain common elements that need to be shared between Validate* and Perform* calls below
 402 struct AllocateDescriptorSetsData {
 403     uint32_t required_descriptors_by_type[VK_DESCRIPTOR_TYPE_RANGE_SIZE];
 404     std::vector<std::shared_ptr<DescriptorSetLayout const>> layout_nodes;
 405     AllocateDescriptorSetsData(uint32_t);
 406 };
 407 // Helper functions for descriptor set functions that cross multiple sets
 408 // "Validate" will make sure an update is ok without actually performing it
 409 bool ValidateUpdateDescriptorSets(const debug_report_data *, const core_validation::layer_data *, uint32_t,
 410                                   const VkWriteDescriptorSet *, uint32_t, const VkCopyDescriptorSet *);
 411 // "Perform" does the update with the assumption that ValidateUpdateDescriptorSets() has passed for the given update
 412 void PerformUpdateDescriptorSets(const core_validation::layer_data *, uint32_t, const VkWriteDescriptorSet *, uint32_t,
 413                                  const VkCopyDescriptorSet *);
 414 // Similar to PerformUpdateDescriptorSets, this function will do the same for updating via templates
 415 void PerformUpdateDescriptorSetsWithTemplateKHR(layer_data *, VkDescriptorSet, std::unique_ptr<TEMPLATE_STATE> const &,
 416                                                 const void *);
 417 // Update the common AllocateDescriptorSetsData struct which can then be shared between Validate* and Perform* funcs below
 418 void UpdateAllocateDescriptorSetsData(const layer_data *dev_data, const VkDescriptorSetAllocateInfo *,
 419                                       AllocateDescriptorSetsData *);
 420 // Validate that Allocation state is ok
 421 bool ValidateAllocateDescriptorSets(const core_validation::layer_data *, const VkDescriptorSetAllocateInfo *,
 422                                     const AllocateDescriptorSetsData *);
 423 // Update state based on allocating new descriptorsets
 424 void PerformAllocateDescriptorSets(const VkDescriptorSetAllocateInfo *, const VkDescriptorSet *, const AllocateDescriptorSetsData *,
 425                                    std::unordered_map<VkDescriptorPool, DESCRIPTOR_POOL_STATE *> *,
 426                                    std::unordered_map<VkDescriptorSet, cvdescriptorset::DescriptorSet *> *,
 427                                    core_validation::layer_data *);
 428
 429 /*
 430  * DescriptorSet class
 431  *
 432  * Overview - This class encapsulates the Vulkan VkDescriptorSet data (set).
 433  *   A set has an underlying layout which defines the bindings in the set and the
 434  *   types and numbers of descriptors in each descriptor slot. Most of the layout
 435  *   interfaces are exposed through identically-named functions in the set class.
 436  *   Please refer to the DescriptorSetLayout comment above for a description of
 437  *   index, binding, and global index.
 438  *
 439  * At construction a vector of Descriptor* is created with types corresponding to the
 440  *   layout. The primary operation performed on the descriptors is to update them
 441  *   via write or copy updates, and validate that the update contents are correct.
 442  *   In order to validate update contents, the DescriptorSet stores a bunch of ptrs
 443  *   to data maps where various Vulkan objects can be looked up. The management of
 444  *   those maps is performed externally. The set class relies on their contents to
 445  *   be correct at the time of update.
 446  */
 447 class DescriptorSet : public BASE_NODE {
 448    public:
 449     DescriptorSet(const VkDescriptorSet, const VkDescriptorPool, const std::shared_ptr<DescriptorSetLayout const> &,
 450                   uint32_t variable_count, core_validation::layer_data *);
 451     ~DescriptorSet();
 452     // A number of common Get* functions that return data based on layout from which this set was created
 453     uint32_t GetTotalDescriptorCount() const { return p_layout_->GetTotalDescriptorCount(); };
 454     uint32_t GetDynamicDescriptorCount() const { return p_layout_->GetDynamicDescriptorCount(); };
 455     uint32_t GetBindingCount() const { return p_layout_->GetBindingCount(); };
 456     VkDescriptorType GetTypeFromIndex(const uint32_t index) const { return p_layout_->GetTypeFromIndex(index); };
 457     VkDescriptorType GetTypeFromGlobalIndex(const uint32_t index) const { return p_layout_->GetTypeFromGlobalIndex(index); };
 458     VkDescriptorType GetTypeFromBinding(const uint32_t binding) const { return p_layout_->GetTypeFromBinding(binding); };
 459     uint32_t GetDescriptorCountFromIndex(const uint32_t index) const { return p_layout_->GetDescriptorCountFromIndex(index); };
 460     uint32_t GetDescriptorCountFromBinding(const uint32_t binding) const {
 461         return p_layout_->GetDescriptorCountFromBinding(binding);
 462     };
 463     // Return index into dynamic offset array for given binding
 464     int32_t GetDynamicOffsetIndexFromBinding(uint32_t binding) const {
 465         return p_layout_->GetDynamicOffsetIndexFromBinding(binding);
 466     }
 467     // Return true if given binding is present in this set
 468     bool HasBinding(const uint32_t binding) const { return p_layout_->HasBinding(binding); };
 469     // Is this set compatible with the given layout?
 470     bool IsCompatible(DescriptorSetLayout const *const, std::string *) const;
 471     // For given bindings validate state at time of draw is correct, returning false on error and writing error details into string*
 472     bool ValidateDrawState(const std::map<uint32_t, descriptor_req> &, const std::vector<uint32_t> &, GLOBAL_CB_NODE *,
 473                            const char *caller, std::string *) const;
 474     // For given set of bindings, add any buffers and images that will be updated to their respective unordered_sets & return number
 475     // of objects inserted
 476     uint32_t GetStorageUpdates(const std::map<uint32_t, descriptor_req> &, std::unordered_set<VkBuffer> *,
 477                                std::unordered_set<VkImageView> *) const;
 478
 479     // Descriptor Update functions. These functions validate state and perform update separately
 480     // Validate contents of a WriteUpdate
 481     bool ValidateWriteUpdate(const debug_report_data *, const VkWriteDescriptorSet *, UNIQUE_VALIDATION_ERROR_CODE *,
 482                              std::string *);
 483     // Perform a WriteUpdate whose contents were just validated using ValidateWriteUpdate
 484     void PerformWriteUpdate(const VkWriteDescriptorSet *);
 485     // Validate contents of a CopyUpdate
 486     bool ValidateCopyUpdate(const debug_report_data *, const VkCopyDescriptorSet *, const DescriptorSet *,
 487                             UNIQUE_VALIDATION_ERROR_CODE *, std::string *);
 488     // Perform a CopyUpdate whose contents were just validated using ValidateCopyUpdate
 489     void PerformCopyUpdate(const VkCopyDescriptorSet *, const DescriptorSet *);
 490
 491     const std::shared_ptr<DescriptorSetLayout const> GetLayout() const { return p_layout_; };
 492     VkDescriptorSet GetSet() const { return set_; };
 493     // Return unordered_set of all command buffers that this set is bound to
 494     std::unordered_set<GLOBAL_CB_NODE *> GetBoundCmdBuffers() const { return cb_bindings; }
 495     // Bind given cmd_buffer to this descriptor set
 496     void BindCommandBuffer(GLOBAL_CB_NODE *, const std::map<uint32_t, descriptor_req> &);
 497
 498     // Track work that has been bound or validated to avoid duplicate work, important when large descriptor arrays
 499     // are present
 500     typedef std::unordered_set<uint32_t> TrackedBindings;
 501     static void FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair, const BindingReqMap &in_req,
 502                                             BindingReqMap *out_req, TrackedBindings *set);
 503     static void FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair, const BindingReqMap &in_req,
 504                                             BindingReqMap *out_req, TrackedBindings *set, uint32_t limit);
 505     void FilterAndTrackBindingReqs(GLOBAL_CB_NODE *, const BindingReqMap &in_req, BindingReqMap *out_req);
 506     void FilterAndTrackBindingReqs(GLOBAL_CB_NODE *, PIPELINE_STATE *, const BindingReqMap &in_req, BindingReqMap *out_req);
 507     void ClearCachedDynamicDescriptorValidation(GLOBAL_CB_NODE *cb_state) { cached_validation_[cb_state].dynamic_buffers.clear(); }
 508     void ClearCachedValidation(GLOBAL_CB_NODE *cb_state) { cached_validation_.erase(cb_state); }
 509     // If given cmd_buffer is in the cb_bindings set, remove it
 510     void RemoveBoundCommandBuffer(GLOBAL_CB_NODE *cb_node) {
 511         cb_bindings.erase(cb_node);
 512         ClearCachedValidation(cb_node);
 513     }
 514     VkSampler const *GetImmutableSamplerPtrFromBinding(const uint32_t index) const {
 515         return p_layout_->GetImmutableSamplerPtrFromBinding(index);
 516     };
 517     // For a particular binding, get the global index
 518     const IndexRange &GetGlobalIndexRangeFromBinding(const uint32_t binding) const {
 519         return p_layout_->GetGlobalIndexRangeFromBinding(binding);
 520     };
 521     // Return true if any part of set has ever been updated
 522     bool IsUpdated() const { return some_update_; };
 523     bool IsPushDescriptor() const { return p_layout_->IsPushDescriptor(); };
 524     bool IsVariableDescriptorCount(uint32_t binding) const {
 525         return !!(p_layout_->GetDescriptorBindingFlagsFromBinding(binding) &
 526                   VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT);
 527     }
 528     uint32_t GetVariableDescriptorCount() const { return variable_count_; }
 529     DESCRIPTOR_POOL_STATE *GetPoolState() const { return pool_state_; }
 530
 531    private:
 532     bool VerifyWriteUpdateContents(const VkWriteDescriptorSet *, const uint32_t, UNIQUE_VALIDATION_ERROR_CODE *,
 533                                    std::string *) const;
 534     bool VerifyCopyUpdateContents(const VkCopyDescriptorSet *, const DescriptorSet *, VkDescriptorType, uint32_t,
 535                                   UNIQUE_VALIDATION_ERROR_CODE *, std::string *) const;
 536     bool ValidateBufferUsage(BUFFER_STATE const *, VkDescriptorType, UNIQUE_VALIDATION_ERROR_CODE *, std::string *) const;
 537     bool ValidateBufferUpdate(VkDescriptorBufferInfo const *, VkDescriptorType, UNIQUE_VALIDATION_ERROR_CODE *,
 538                               std::string *) const;
 539     // Private helper to set all bound cmd buffers to INVALID state
 540     void InvalidateBoundCmdBuffers();
 541     bool some_update_;  // has any part of the set ever been updated?
 542     VkDescriptorSet set_;
 543     DESCRIPTOR_POOL_STATE *pool_state_;
 544     const std::shared_ptr<DescriptorSetLayout const> p_layout_;
 545     std::vector<std::unique_ptr<Descriptor>> descriptors_;
 546     // Ptr to device data used for various data look-ups
 547     core_validation::layer_data *const device_data_;
 548     const VkPhysicalDeviceLimits limits_;
 549     uint32_t variable_count_;
 550
 551     // Cached binding and validation support:
 552     //
 553     // For the lifespan of a given command buffer recording, do lazy evaluation, caching, and dirtying of
 554     // expensive validation operation (typically per-draw)
 555     typedef std::unordered_map<GLOBAL_CB_NODE *, TrackedBindings> TrackedBindingMap;
 556     typedef std::unordered_map<PIPELINE_STATE *, TrackedBindingMap> ValidatedBindings;
 557     // Track the validation caching of bindings vs. the command buffer and draw state
 558     typedef std::unordered_map<uint32_t, GLOBAL_CB_NODE::ImageLayoutUpdateCount> VersionedBindings;
 559     struct CachedValidation {
 560         TrackedBindings command_binding_and_usage;                               // Persistent for the life of the recording
 561         TrackedBindings non_dynamic_buffers;                                     // Persistent for the life of the recording
 562         TrackedBindings dynamic_buffers;                                         // Dirtied (flushed) each BindDescriptorSet
 563         std::unordered_map<PIPELINE_STATE *, VersionedBindings> image_samplers;  // Tested vs. changes to CB's ImageLayout
 564     };
 565     typedef std::unordered_map<GLOBAL_CB_NODE *, CachedValidation> CachedValidationMap;
 566     // Image and ImageView bindings are validated per pipeline and not invalidate by repeated binding
 567     CachedValidationMap cached_validation_;
 568 };
 569 // For the "bindless" style resource usage with many descriptors, need to optimize binding and validation
 570 class PrefilterBindRequestMap {
 571    public:
 572     static const uint32_t kManyDescriptors_ = 64;  // TODO base this number on measured data
 573     std::unique_ptr<BindingReqMap> filtered_map_;
 574     const BindingReqMap &orig_map_;
 575
 576     PrefilterBindRequestMap(DescriptorSet &ds, const BindingReqMap &in_map, GLOBAL_CB_NODE *cb_state);
 577     PrefilterBindRequestMap(DescriptorSet &ds, const BindingReqMap &in_map, GLOBAL_CB_NODE *cb_state, PIPELINE_STATE *);
 578     const BindingReqMap &Map() const { return (filtered_map_) ? *filtered_map_ : orig_map_; }
 579 };
 580 }  // namespace cvdescriptorset
 581 #endif  // CORE_VALIDATION_DESCRIPTOR_SETS_H_