Gitiles
Code Review Sign In
gerrit.openfyde.cn / chromium.googlesource.com / external / github.com / KhronosGroup / Vulkan-ValidationLayers / d14743a41000ce309a68cd78bdb6f7f23af73694 / . / layers / synchronization_validation.h
blob: 0155bce95e5ffd8400b932da659a7718354faca4 [file] [log] [blame]
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]1/*
2 * Copyright (c) 2019-2020 Valve Corporation
3 * Copyright (c) 2019-2020 LunarG, Inc.
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 * Author: John Zulauf <jzulauf@lunarg.com>
18 */
19
20#pragma once
21
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]22#include <limits>
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]23#include <map>
24#include <memory>
25#include <unordered_map>
26#include <vulkan/vulkan.h>
27
28#include "synchronization_validation_types.h"
29#include "state_tracker.h"
30
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]31class SyncValidator;
32
John Zulauf2f952d22020-02-10 11:34:51 -0700[diff] [blame]33enum SyncHazard {
34 NONE = 0,
35 READ_AFTER_WRITE,
36 WRITE_AFTER_READ,
37 WRITE_AFTER_WRITE,
38 READ_RACING_WRITE,
39 WRITE_RACING_WRITE,
40 WRITE_RACING_READ,
41};
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]42
43// Useful Utilites for manipulating StageAccess parameters, suitable as base class to save typing
44struct SyncStageAccess {
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]45 static inline SyncStageAccessFlagBits FlagBit(SyncStageAccessIndex stage_access) {
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]46 return syncStageAccessInfoByStageAccessIndex[stage_access].stage_access_bit;
47 }
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]48 static inline SyncStageAccessFlags Flags(SyncStageAccessIndex stage_access) {
49 return static_cast<SyncStageAccessFlags>(FlagBit(stage_access));
50 }
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]51
52 static bool IsRead(SyncStageAccessFlagBits stage_access_bit) { return 0 != (stage_access_bit & syncStageAccessReadMask); }
53 static bool IsRead(SyncStageAccessIndex stage_access_index) { return IsRead(FlagBit(stage_access_index)); }
54
55 static bool IsWrite(SyncStageAccessFlagBits stage_access_bit) { return 0 != (stage_access_bit & syncStageAccessWriteMask); }
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]56 static bool HasWrite(SyncStageAccessFlags stage_access_mask) { return 0 != (stage_access_mask & syncStageAccessWriteMask); }
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]57 static bool IsWrite(SyncStageAccessIndex stage_access_index) { return IsWrite(FlagBit(stage_access_index)); }
58 static VkPipelineStageFlagBits PipelineStageBit(SyncStageAccessIndex stage_access_index) {
59 return syncStageAccessInfoByStageAccessIndex[stage_access_index].stage_mask;
60 }
61 static SyncStageAccessFlags AccessScopeByStage(VkPipelineStageFlags stages);
62 static SyncStageAccessFlags AccessScopeByAccess(VkAccessFlags access);
63 static SyncStageAccessFlags AccessScope(VkPipelineStageFlags stages, VkAccessFlags access);
64 static SyncStageAccessFlags AccessScope(SyncStageAccessFlags stage_scope, VkAccessFlags accesses) {
65 return stage_scope & AccessScopeByAccess(accesses);
66 }
67};
68
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]69struct ResourceUsageTag {
70 uint64_t index;
John Zulaufcc6fecb2020-06-17 15:24:54 -0600[diff] [blame]71 CMD_TYPE command;
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]72 const static uint64_t kMaxIndex = std::numeric_limits<uint64_t>::max();
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]73 ResourceUsageTag &operator++() {
74 index++;
75 return *this;
76 }
77 bool IsBefore(const ResourceUsageTag &rhs) const { return index < rhs.index; }
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]78 bool operator==(const ResourceUsageTag &rhs) const { return (index == rhs.index); }
79 bool operator!=(const ResourceUsageTag &rhs) const { return !(*this == rhs); }
John Zulaufcc6fecb2020-06-17 15:24:54 -0600[diff] [blame]80 ResourceUsageTag() : index(0), command(CMD_NONE) {}
81 ResourceUsageTag(uint64_t index_, CMD_TYPE command_) : index(index_), command(command_) {}
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]82};
83
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]84struct HazardResult {
85 SyncHazard hazard = NONE;
86 ResourceUsageTag tag = ResourceUsageTag();
87 void Set(SyncHazard hazard_, const ResourceUsageTag &tag_) {
88 hazard = hazard_;
89 tag = tag_;
90 }
91};
92
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]93struct SyncBarrier {
94 VkPipelineStageFlags src_exec_scope;
95 SyncStageAccessFlags src_access_scope;
96 VkPipelineStageFlags dst_exec_scope;
97 SyncStageAccessFlags dst_access_scope;
98 SyncBarrier() = default;
99 SyncBarrier &operator=(const SyncBarrier &) = default;
100 SyncBarrier(VkQueueFlags gueue_flags, const VkSubpassDependency2 &sub_pass_barrier);
101};
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]102
103// To represent ordering guarantees such as rasterization and store
104struct SyncOrderingBarrier {
105 VkPipelineStageFlags exec_scope;
106 SyncStageAccessFlags access_scope;
107 SyncOrderingBarrier() = default;
108 SyncOrderingBarrier &operator=(const SyncOrderingBarrier &) = default;
109};
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]110
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]111class ResourceAccessState : public SyncStageAccess {
112 protected:
113 // Mutliple read operations can be simlutaneously (and independently) synchronized,
114 // given the only the second execution scope creates a dependency chain, we have to track each,
115 // but only up to one per pipeline stage (as another read from the *same* stage become more recent,
116 // and applicable one for hazard detection
117 struct ReadState {
118 VkPipelineStageFlagBits stage; // The stage of this read
119 VkPipelineStageFlags barriers; // all applicable barriered stages
120 ResourceUsageTag tag;
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]121 bool operator==(const ReadState &rhs) const {
122 bool same = (stage == rhs.stage) && (barriers == rhs.barriers) && (tag == rhs.tag);
123 return same;
124 }
125 bool operator!=(const ReadState &rhs) const { return !(*this == rhs); }
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]126 };
127
128 public:
129 HazardResult DetectHazard(SyncStageAccessIndex usage_index) const;
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]130 HazardResult DetectHazard(SyncStageAccessIndex usage_index, const SyncOrderingBarrier &ordering) const;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]131
John Zulaufc9201222020-05-13 15:13:03 -0600[diff] [blame]132 HazardResult DetectBarrierHazard(SyncStageAccessIndex usage_index, VkPipelineStageFlags source_exec_scope,
133 SyncStageAccessFlags source_access_scope) const;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]134 HazardResult DetectAsyncHazard(SyncStageAccessIndex usage_index) const;
135
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]136 void Update(SyncStageAccessIndex usage_index, const ResourceUsageTag &tag);
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]137 void Resolve(const ResourceAccessState &other);
138 void ApplyBarrier(const SyncBarrier &barrier);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]139 void ApplyExecutionBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask);
140 void ApplyMemoryAccessBarrier(VkPipelineStageFlags src_stage_mask, SyncStageAccessFlags src_scope,
141 VkPipelineStageFlags dst_stage_mask, SyncStageAccessFlags dst_scope);
142
143 ResourceAccessState()
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]144 : write_barriers(~SyncStageAccessFlags(0)),
145 write_dependency_chain(0),
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]146 write_tag(),
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame^]147 last_write(0),
148 input_attachment_barriers(kNoAttachmentRead),
149 input_attachment_tag(),
150 last_read_count(0),
151 last_read_stages(0) {}
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]152
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]153 bool HasWriteOp() const { return last_write != 0; }
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]154 bool operator==(const ResourceAccessState &rhs) const {
155 bool same = (write_barriers == rhs.write_barriers) && (write_dependency_chain == rhs.write_dependency_chain) &&
156 (last_read_count == rhs.last_read_count) && (last_read_stages == rhs.last_read_stages) &&
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame^]157 (write_tag == rhs.write_tag) && (input_attachment_barriers == rhs.input_attachment_barriers) &&
158 ((input_attachment_barriers == kNoAttachmentRead) || input_attachment_tag == rhs.input_attachment_tag);
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]159 for (uint32_t i = 0; same && i < last_read_count; i++) {
160 same |= last_reads[i] == rhs.last_reads[i];
161 }
162 return same;
163 }
164 bool operator!=(const ResourceAccessState &rhs) const { return !(*this == rhs); }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]165
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]166 private:
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame^]167 static constexpr VkPipelineStageFlags kNoAttachmentRead = ~VkPipelineStageFlags(0);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]168 bool IsWriteHazard(SyncStageAccessFlagBits usage) const { return 0 != (usage & ~write_barriers); }
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame^]169
170 static bool IsReadHazard(VkPipelineStageFlagBits stage, const VkPipelineStageFlags barriers) {
171 return 0 != (stage & ~barriers);
172 }
173 static bool IsReadHazard(VkPipelineStageFlags stage_mask, const VkPipelineStageFlags barriers) {
174 return stage_mask != (stage_mask & barriers);
175 }
176
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]177 bool IsReadHazard(VkPipelineStageFlagBits stage, const ReadState &read_access) const {
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame^]178 return IsReadHazard(stage, read_access.barriers);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]179 }
John Zulauf0cb5be22020-01-23 12:18:22 -0700[diff] [blame]180 bool IsReadHazard(VkPipelineStageFlags stage_mask, const ReadState &read_access) const {
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame^]181 return IsReadHazard(stage_mask, read_access.barriers);
John Zulauf0cb5be22020-01-23 12:18:22 -0700[diff] [blame]182 }
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame^]183
184 // TODO: Add a NONE (zero) enum to SyncStageAccessFlagBits for input_attachment_read and last_write
185
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]186 // With reads, each must be "safe" relative to it's prior write, so we need only
187 // save the most recent write operation (as anything *transitively* unsafe would arleady
188 // be included
189 SyncStageAccessFlags write_barriers; // union of applicable barrier masks since last write
190 VkPipelineStageFlags write_dependency_chain; // intiially zero, but accumulating the dstStages of barriers if they chain.
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]191 ResourceUsageTag write_tag;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]192 SyncStageAccessFlags last_write; // only the most recent write
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]193
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame^]194 // This is special as it's a framebuffer-local read from a framebuffer-global pipeline stage
195 // As the only possible state for the input attachment stage/access is SYNC_FRAGMENT_SHADER_INPUT_ATTACHMENT_READ_BIT,
196 // encode the presence with the barriers mask, ~0 denotes no pending input attachment. Zero -- is the no-barrier state,
197 // otherwise reflects the barrier/dependency chain information.
198 VkPipelineStageFlags input_attachment_barriers;
199 ResourceUsageTag input_attachment_tag;
200
201 uint32_t last_read_count;
202 VkPipelineStageFlags last_read_stages;
203 static constexpr size_t kStageCount = 32; // TODO: The manual count was 28 real stages. Add stage count to codegen
204 std::array<ReadState, kStageCount> last_reads;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]205};
206
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]207using ResourceAccessRangeMap = sparse_container::range_map<VkDeviceSize, ResourceAccessState>;
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]208using ResourceAccessRange = typename ResourceAccessRangeMap::key_type;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]209using ResourceRangeMergeIterator = sparse_container::parallel_iterator<ResourceAccessRangeMap, const ResourceAccessRangeMap>;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]210
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]211class AccessContext {
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]212 public:
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]213 enum AddressType : int { kLinearAddress = 0, kIdealizedAddress = 1, kMaxAddressType = 1 };
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]214 enum DetectOptions : uint32_t {
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]215 kDetectPrevious = 1U << 0,
216 kDetectAsync = 1U << 1,
217 kDetectAll = (kDetectPrevious | kDetectAsync)
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]218 };
219
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]220 struct TrackBack {
221 SyncBarrier barrier;
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]222 const AccessContext *context;
223 TrackBack(const AccessContext *context_, VkQueueFlags queue_flags_, const VkSubpassDependency2 &subpass_barrier_)
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]224 : barrier(queue_flags_, subpass_barrier_), context(context_) {}
225 TrackBack &operator=(const TrackBack &) = default;
226 TrackBack() = default;
227 };
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]228
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]229 HazardResult DetectHazard(const BUFFER_STATE &buffer, SyncStageAccessIndex usage_index, const ResourceAccessRange &range) const;
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]230 HazardResult DetectHazard(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]231 const VkImageSubresourceLayers &subresource, const VkOffset3D &offset,
232 const VkExtent3D &extent) const;
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]233 template <typename Detector>
234 HazardResult DetectHazard(Detector &detector, const IMAGE_STATE &image, const VkImageSubresourceRange &subresource_range,
235 const VkOffset3D &offset, const VkExtent3D &extent, DetectOptions options) const;
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]236 HazardResult DetectHazard(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
237 const VkImageSubresourceRange &subresource_range, const VkOffset3D &offset,
238 const VkExtent3D &extent) const;
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]239 HazardResult DetectHazard(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
240 const VkImageSubresourceRange &subresource_range, const SyncOrderingBarrier &ordering,
241 const VkOffset3D &offset, const VkExtent3D &extent) const;
John Zulaufb027cdb2020-05-21 14:25:22 -0600[diff] [blame]242 HazardResult DetectHazard(const IMAGE_VIEW_STATE *view, SyncStageAccessIndex current_usage, const SyncOrderingBarrier &ordering,
243 const VkOffset3D &offset, const VkExtent3D &extent, VkImageAspectFlags aspect_mask = 0U) const;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]244 HazardResult DetectImageBarrierHazard(const IMAGE_STATE &image, VkPipelineStageFlags src_exec_scope,
245 SyncStageAccessFlags src_access_scope, const VkImageSubresourceRange &subresource_range,
246 DetectOptions options) const;
247 HazardResult DetectImageBarrierHazard(const IMAGE_STATE &image, VkPipelineStageFlags src_exec_scope,
248 SyncStageAccessFlags src_stage_accesses, const VkImageMemoryBarrier &barrier) const;
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]249 HazardResult DetectSubpassTransitionHazard(const TrackBack &track_back, const IMAGE_VIEW_STATE *attach_view) const;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]250
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]251 const TrackBack &GetDstExternalTrackBack() const { return dst_external_; }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]252 void Reset() {
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]253 prev_.clear();
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]254 prev_by_subpass_.clear();
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]255 async_.clear();
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]256 src_external_ = TrackBack();
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]257 for (auto &map : access_state_maps_) {
258 map.clear();
259 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]260 }
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]261 // TODO: See if returning the lower_bound would be useful from a performance POV -- look at the lower_bound overhead
262 // Would need to add a "hint" overload to parallel_iterator::invalidate_[AB] call, if so.
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]263 void ResolvePreviousAccess(AddressType type, const ResourceAccessRange &range, ResourceAccessRangeMap *descent_map,
264 const ResourceAccessState *infill_state) const;
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]265 void ResolvePreviousAccess(const IMAGE_STATE &image_state, const VkImageSubresourceRange &subresource_range,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]266 AddressType address_type, ResourceAccessRangeMap *descent_map,
267 const ResourceAccessState *infill_state) const;
268 void ResolveAccessRange(AddressType type, const ResourceAccessRange &range, const SyncBarrier *barrier,
269 ResourceAccessRangeMap *resolve_map, const ResourceAccessState *infill_state,
270 bool recur_to_infill = true) const;
271 void UpdateAccessState(const BUFFER_STATE &buffer, SyncStageAccessIndex current_usage, const ResourceAccessRange &range,
272 const ResourceUsageTag &tag);
273 void UpdateAccessState(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
274 const VkImageSubresourceRange &subresource_range, const VkOffset3D &offset, const VkExtent3D &extent,
275 const ResourceUsageTag &tag);
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]276 void UpdateAccessState(const IMAGE_VIEW_STATE *view, SyncStageAccessIndex current_usage, const VkOffset3D &offset,
277 const VkExtent3D &extent, VkImageAspectFlags aspect_mask, const ResourceUsageTag &tag);
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]278 void UpdateAccessState(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]279 const VkImageSubresourceLayers &subresource, const VkOffset3D &offset, const VkExtent3D &extent,
280 const ResourceUsageTag &tag);
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]281 void UpdateAttachmentResolveAccess(const RENDER_PASS_STATE &rp_state, const VkRect2D &render_area,
282 const std::vector<const IMAGE_VIEW_STATE *> &attachment_views, uint32_t subpass,
283 const ResourceUsageTag &tag);
John Zulaufaff20662020-06-01 14:07:58 -0600[diff] [blame]284 void UpdateAttachmentStoreAccess(const RENDER_PASS_STATE &rp_state, const VkRect2D &render_area,
285 const std::vector<const IMAGE_VIEW_STATE *> &attachment_views, uint32_t subpass,
286 const ResourceUsageTag &tag);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]287
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]288 void ResolveChildContexts(const std::vector<AccessContext> &contexts);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]289
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]290 void ApplyImageBarrier(const IMAGE_STATE &image, VkPipelineStageFlags src_exec_scope, SyncStageAccessFlags src_access_scope,
291 VkPipelineStageFlags dst_exec_scope, SyncStageAccessFlags dst_accesse_scope,
292 const VkImageSubresourceRange &subresource_range);
293
294 void ApplyImageBarrier(const IMAGE_STATE &image, VkPipelineStageFlags src_exec_scope, SyncStageAccessFlags src_access_scope,
295 VkPipelineStageFlags dst_exec_scope, SyncStageAccessFlags dst_access_scope,
296 const VkImageSubresourceRange &subresource_range, bool layout_transition, const ResourceUsageTag &tag);
297 void ApplyImageBarrier(const IMAGE_STATE &image, const SyncBarrier &barrier, const VkImageSubresourceRange &subresource_range,
298 bool layout_transition, const ResourceUsageTag &tag);
299
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]300 template <typename Action>
301 void UpdateMemoryAccess(const BUFFER_STATE &buffer, const ResourceAccessRange &range, const Action action);
302 template <typename Action>
303 void UpdateMemoryAccess(const IMAGE_STATE &image, const VkImageSubresourceRange &subresource_range, const Action action);
304
305 template <typename Action>
306 void ApplyGlobalBarriers(const Action &barrier_action);
307
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]308 static AddressType ImageAddressType(const IMAGE_STATE &image);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]309 static VkDeviceSize ResourceBaseAddress(const BINDABLE &bindable);
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]310
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]311 AccessContext(uint32_t subpass, VkQueueFlags queue_flags, const std::vector<SubpassDependencyGraphNode> &dependencies,
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]312 const std::vector<AccessContext> &contexts, const AccessContext *external_context);
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]313
314 AccessContext() { Reset(); }
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]315 AccessContext(const AccessContext &copy_from) = default;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]316
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]317 ResourceAccessRangeMap &GetAccessStateMap(AddressType type) { return access_state_maps_[type]; }
318 const ResourceAccessRangeMap &GetAccessStateMap(AddressType type) const { return access_state_maps_[type]; }
319 ResourceAccessRangeMap &GetLinearMap() { return GetAccessStateMap(AddressType::kLinearAddress); }
320 const ResourceAccessRangeMap &GetLinearMap() const { return GetAccessStateMap(AddressType::kLinearAddress); }
321 ResourceAccessRangeMap &GetIdealizedMap() { return GetAccessStateMap(AddressType::kIdealizedAddress); }
322 const ResourceAccessRangeMap &GetIdealizedMap() const { return GetAccessStateMap(AddressType::kIdealizedAddress); }
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]323 const TrackBack *GetTrackBackFromSubpass(uint32_t subpass) const {
324 if (subpass == VK_SUBPASS_EXTERNAL) {
325 return &src_external_;
326 } else {
327 assert(subpass < prev_by_subpass_.size());
328 return prev_by_subpass_[subpass];
329 }
330 }
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]331
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]332 bool ValidateLayoutTransitions(const SyncValidator &sync_state,
333
334 const RENDER_PASS_STATE &rp_state,
335
336 const VkRect2D &render_area,
337
338 uint32_t subpass, const std::vector<const IMAGE_VIEW_STATE *> &attachment_views,
339 const char *func_name) const;
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]340 bool ValidateLoadOperation(const SyncValidator &sync_state, const RENDER_PASS_STATE &rp_state, const VkRect2D &render_area,
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]341 uint32_t subpass, const std::vector<const IMAGE_VIEW_STATE *> &attachment_views,
342 const char *func_name) const;
John Zulaufaff20662020-06-01 14:07:58 -0600[diff] [blame]343 bool ValidateStoreOperation(const SyncValidator &sync_state, const RENDER_PASS_STATE &rp_state, const VkRect2D &render_area,
344 uint32_t subpass, const std::vector<const IMAGE_VIEW_STATE *> &attachment_views,
345 const char *func_name) const;
John Zulaufb027cdb2020-05-21 14:25:22 -0600[diff] [blame]346 bool ValidateResolveOperations(const SyncValidator &sync_state, const RENDER_PASS_STATE &rp_state, const VkRect2D &render_area,
347 const std::vector<const IMAGE_VIEW_STATE *> &attachment_views, const char *func_name,
348 uint32_t subpass) const;
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]349
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]350 private:
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]351 HazardResult DetectHazard(AddressType type, SyncStageAccessIndex usage_index, const ResourceAccessRange &range) const;
352 HazardResult DetectBarrierHazard(AddressType type, SyncStageAccessIndex current_usage, VkPipelineStageFlags src_exec_scope,
353 SyncStageAccessFlags src_access_scope, const ResourceAccessRange &range,
354 DetectOptions options) const;
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]355
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]356 template <typename Detector>
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]357 HazardResult DetectHazard(AddressType type, const Detector &detector, const ResourceAccessRange &range,
358 DetectOptions options) const;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]359 template <typename Detector>
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]360 HazardResult DetectAsyncHazard(AddressType type, const Detector &detector, const ResourceAccessRange &range) const;
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]361 template <typename Detector>
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]362 HazardResult DetectPreviousHazard(AddressType type, const Detector &detector, const ResourceAccessRange &range) const;
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]363 void UpdateAccessState(AddressType type, SyncStageAccessIndex current_usage, const ResourceAccessRange &range,
364 const ResourceUsageTag &tag);
365 constexpr static int kAddressTypeCount = AddressType::kMaxAddressType + 1;
366 static const std::array<AddressType, kAddressTypeCount> kAddressTypes;
367 std::array<ResourceAccessRangeMap, kAddressTypeCount> access_state_maps_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]368 std::vector<TrackBack> prev_;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]369 std::vector<TrackBack *> prev_by_subpass_;
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]370 std::vector<AccessContext *> async_;
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]371 TrackBack src_external_;
372 TrackBack dst_external_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]373};
374
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]375class RenderPassAccessContext {
376 public:
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]377 RenderPassAccessContext() : rp_state_(nullptr), current_subpass_(0) {}
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]378
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]379 bool ValidateDrawSubpassAttachment(const SyncValidator &sync_state, const CMD_BUFFER_STATE &cmd, const VkRect2D &render_area,
380 const char *func_name) const;
locke-lunarg96dc9632020-06-10 17:22:18 -0600[diff] [blame]381 void RecordDrawSubpassAttachment(const CMD_BUFFER_STATE &cmd, const VkRect2D &render_area, const ResourceUsageTag &tag);
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]382 bool ValidateNextSubpass(const SyncValidator &sync_state, const VkRect2D &render_area, const char *command_name) const;
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]383 bool ValidateEndRenderPass(const SyncValidator &sync_state, const VkRect2D &render_area, const char *func_name) const;
384 bool ValidateFinalSubpassLayoutTransitions(const SyncValidator &sync_state, const VkRect2D &render_area,
385 const char *func_name) const;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]386
387 void RecordLayoutTransitions(const ResourceUsageTag &tag);
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]388 void RecordLoadOperations(const VkRect2D &render_area, const ResourceUsageTag &tag);
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]389 void RecordBeginRenderPass(const SyncValidator &state, const CMD_BUFFER_STATE &cb_state, const AccessContext *external_context,
390 VkQueueFlags queue_flags, const ResourceUsageTag &tag);
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]391 void RecordNextSubpass(const VkRect2D &render_area, const ResourceUsageTag &tag);
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]392 void RecordEndRenderPass(AccessContext *external_context, const VkRect2D &render_area, const ResourceUsageTag &tag);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]393
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]394 AccessContext &CurrentContext() { return subpass_contexts_[current_subpass_]; }
395 const AccessContext &CurrentContext() const { return subpass_contexts_[current_subpass_]; }
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]396 const std::vector<AccessContext> &GetContexts() const { return subpass_contexts_; }
397 uint32_t GetCurrentSubpass() const { return current_subpass_; }
398 const RENDER_PASS_STATE *GetRenderPassState() const { return rp_state_; }
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]399 AccessContext *CreateStoreResolveProxy(const VkRect2D &render_area) const;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]400
401 private:
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]402 const RENDER_PASS_STATE *rp_state_;
403 uint32_t current_subpass_;
404 std::vector<AccessContext> subpass_contexts_;
405 std::vector<const IMAGE_VIEW_STATE *> attachment_views_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]406};
407
408class CommandBufferAccessContext {
409 public:
410 CommandBufferAccessContext()
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]411 : command_number_(0),
412 reset_count_(0),
413 render_pass_contexts_(),
414 cb_access_context_(),
415 current_context_(&cb_access_context_),
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]416 current_renderpass_context_(),
417 cb_state_(),
418 queue_flags_() {}
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]419 CommandBufferAccessContext(SyncValidator &sync_validator, std::shared_ptr<CMD_BUFFER_STATE> &cb_state, VkQueueFlags queue_flags)
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]420 : CommandBufferAccessContext() {
421 cb_state_ = cb_state;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]422 sync_state_ = &sync_validator;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]423 queue_flags_ = queue_flags;
424 }
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]425
426 void Reset() {
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]427 command_number_ = 0;
428 reset_count_++;
429 cb_access_context_.Reset();
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]430 render_pass_contexts_.clear();
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]431 current_context_ = &cb_access_context_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]432 current_renderpass_context_ = nullptr;
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]433 }
434
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]435 AccessContext *GetCurrentAccessContext() { return current_context_; }
436 const AccessContext *GetCurrentAccessContext() const { return current_context_; }
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]437 void RecordBeginRenderPass(const ResourceUsageTag &tag);
438 bool ValidateBeginRenderPass(const RENDER_PASS_STATE &render_pass, const VkRenderPassBeginInfo *pRenderPassBegin,
439 const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const char *func_name) const;
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]440 bool ValidateDispatchDrawDescriptorSet(VkPipelineBindPoint pipelineBindPoint, const char *func_name) const;
441 void RecordDispatchDrawDescriptorSet(VkPipelineBindPoint pipelineBindPoint, const ResourceUsageTag &tag);
442 bool ValidateDrawVertex(uint32_t vertexCount, uint32_t firstVertex, const char *func_name) const;
443 void RecordDrawVertex(uint32_t vertexCount, uint32_t firstVertex, const ResourceUsageTag &tag);
444 bool ValidateDrawVertexIndex(uint32_t indexCount, uint32_t firstIndex, const char *func_name) const;
445 void RecordDrawVertexIndex(uint32_t indexCount, uint32_t firstIndex, const ResourceUsageTag &tag);
446 bool ValidateDrawSubpassAttachment(const char *func_name) const;
447 void RecordDrawSubpassAttachment(const ResourceUsageTag &tag);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]448 bool ValidateNextSubpass(const char *func_name) const;
449 bool ValidateEndRenderpass(const char *func_name) const;
450 void RecordNextSubpass(const RENDER_PASS_STATE &render_pass, const ResourceUsageTag &tag);
451 void RecordEndRenderPass(const RENDER_PASS_STATE &render_pass, const ResourceUsageTag &tag);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]452 CMD_BUFFER_STATE *GetCommandBufferState() { return cb_state_.get(); }
453 const CMD_BUFFER_STATE *GetCommandBufferState() const { return cb_state_.get(); }
454 VkQueueFlags GetQueueFlags() const { return queue_flags_; }
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]455 inline ResourceUsageTag NextCommandTag(CMD_TYPE command) {
456 // TODO: add command encoding to ResourceUsageTag.
457 // What else we what to include. Do we want some sort of "parent" or global sequence number
458 command_number_++;
John Zulaufcc6fecb2020-06-17 15:24:54 -0600[diff] [blame]459 const auto index = (static_cast<uint64_t>(reset_count_) << 32) | command_number_;
460 ResourceUsageTag next(index, command);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]461 return next;
462 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]463
464 private:
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]465 uint32_t command_number_;
466 uint32_t reset_count_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]467 std::vector<RenderPassAccessContext> render_pass_contexts_;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]468 AccessContext cb_access_context_;
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]469 AccessContext *current_context_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]470 RenderPassAccessContext *current_renderpass_context_;
471 std::shared_ptr<CMD_BUFFER_STATE> cb_state_;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]472 SyncValidator *sync_state_;
473
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]474 VkQueueFlags queue_flags_;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]475};
476
477class SyncValidator : public ValidationStateTracker, public SyncStageAccess {
478 public:
479 SyncValidator() { container_type = LayerObjectTypeSyncValidation; }
480 using StateTracker = ValidationStateTracker;
481
482 using StateTracker::AccessorTraitsTypes;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]483 std::unordered_map<VkCommandBuffer, std::unique_ptr<CommandBufferAccessContext>> cb_access_state;
484 CommandBufferAccessContext *GetAccessContextImpl(VkCommandBuffer command_buffer, bool do_insert) {
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]485 auto found_it = cb_access_state.find(command_buffer);
486 if (found_it == cb_access_state.end()) {
487 if (!do_insert) return nullptr;
488 // If we don't have one, make it.
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]489 auto cb_state = GetShared<CMD_BUFFER_STATE>(command_buffer);
490 assert(cb_state.get());
491 auto queue_flags = GetQueueFlags(*cb_state);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]492 std::unique_ptr<CommandBufferAccessContext> context(new CommandBufferAccessContext(*this, cb_state, queue_flags));
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]493 auto insert_pair = cb_access_state.insert(std::make_pair(command_buffer, std::move(context)));
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]494 found_it = insert_pair.first;
495 }
496 return found_it->second.get();
497 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]498 CommandBufferAccessContext *GetAccessContext(VkCommandBuffer command_buffer) {
499 return GetAccessContextImpl(command_buffer, true); // true -> do_insert on not found
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]500 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]501 CommandBufferAccessContext *GetAccessContextNoInsert(VkCommandBuffer command_buffer) {
502 return GetAccessContextImpl(command_buffer, false); // false -> don't do_insert on not found
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]503 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]504
505 const CommandBufferAccessContext *GetAccessContext(VkCommandBuffer command_buffer) const {
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]506 const auto found_it = cb_access_state.find(command_buffer);
507 if (found_it == cb_access_state.end()) {
508 return nullptr;
509 }
510 return found_it->second.get();
511 }
512
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]513 void ApplyGlobalBarriers(AccessContext *context, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]514 SyncStageAccessFlags src_stage_scope, SyncStageAccessFlags dst_stage_scope,
515 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers);
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]516 void ApplyBufferBarriers(AccessContext *context, VkPipelineStageFlags src_stage_mask, SyncStageAccessFlags src_stage_scope,
517 VkPipelineStageFlags dst_stage_mask, SyncStageAccessFlags dst_stage_scope, uint32_t barrier_count,
518 const VkBufferMemoryBarrier *barriers);
519 void ApplyImageBarriers(AccessContext *context, VkPipelineStageFlags src_stage_mask, SyncStageAccessFlags src_stage_scope,
520 VkPipelineStageFlags dst_stage_mask, SyncStageAccessFlags dst_stage_scope, uint32_t barrier_count,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]521 const VkImageMemoryBarrier *barriers, const ResourceUsageTag &tag);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]522
John Zulaufd1f85d42020-04-15 12:23:15 -0600[diff] [blame]523 void ResetCommandBufferCallback(VkCommandBuffer command_buffer);
524 void FreeCommandBufferCallback(VkCommandBuffer command_buffer);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]525 void RecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]526 const VkSubpassBeginInfo *pSubpassBeginInfo, CMD_TYPE command);
527 void RecordCmdNextSubpass(VkCommandBuffer commandBuffer,
528
529 const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo,
530 CMD_TYPE command);
531 void RecordCmdEndRenderPass(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo, CMD_TYPE command);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]532
533 void PostCallRecordCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
534 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, VkResult result);
535
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]536 bool ValidateBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
537 const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const char *func_name) const;
538
539 bool PreCallValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
540 VkSubpassContents contents) const;
541
542 bool PreCallValidateCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
543 const VkSubpassBeginInfoKHR *pSubpassBeginInfo) const;
544
545 bool PreCallValidateCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
546 const VkSubpassBeginInfoKHR *pSubpassBeginInfo) const;
547
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]548 bool PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount,
549 const VkBufferCopy *pRegions) const;
550
551 void PreCallRecordCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount,
552 const VkBufferCopy *pRegions);
553
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]554 bool PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
555 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
556 const VkImageCopy *pRegions) const;
557
558 void PreCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
559 VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions);
560
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]561 bool PreCallValidateCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
562 VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
563 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
564 uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
565 uint32_t imageMemoryBarrierCount,
566 const VkImageMemoryBarrier *pImageMemoryBarriers) const;
567
568 void PreCallRecordCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
569 VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
570 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
571 uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
572 uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]573
574 void PostCallRecordBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo,
575 VkResult result);
576
577 void PostCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
578 VkSubpassContents contents);
579 void PostCallRecordCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
580 const VkSubpassBeginInfo *pSubpassBeginInfo);
581 void PostCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
582 const VkSubpassBeginInfo *pSubpassBeginInfo);
583
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]584 bool ValidateCmdNextSubpass(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
585 const VkSubpassEndInfoKHR *pSubpassEndInfo, const char *func_name) const;
586 bool PreCallValidateCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const;
587 bool PreCallValidateCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
588 const VkSubpassEndInfoKHR *pSubpassEndInfo) const;
589 bool PreCallValidateCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
590 const VkSubpassEndInfoKHR *pSubpassEndInfo) const;
591
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]592 void PostCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
593 void PostCallRecordCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo,
594 const VkSubpassEndInfo *pSubpassEndInfo);
595 void PostCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo,
596 const VkSubpassEndInfo *pSubpassEndInfo);
597
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]598 bool ValidateCmdEndRenderPass(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo,
599 const char *func_name) const;
600 bool PreCallValidateCmdEndRenderPass(VkCommandBuffer commandBuffer) const;
601 bool PreCallValidateCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo) const;
602 bool PreCallValidateCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo) const;
603
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]604 void PostCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer);
605 void PostCallRecordCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo);
606 void PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo);
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]607 bool PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
608 VkImageLayout dstImageLayout, uint32_t regionCount,
609 const VkBufferImageCopy *pRegions) const;
610
611 void PreCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
612 VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions);
613
614 bool PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
615 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) const;
616
617 void PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
618 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions);
619
620 bool PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
621 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
622 const VkImageBlit *pRegions, VkFilter filter) const;
623
624 void PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
625 VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions,
626 VkFilter filter);
locke-lunarg36ba2592020-04-03 09:42:04 -0600[diff] [blame]627
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]628 bool ValidateIndirectBuffer(const AccessContext &context, VkCommandBuffer commandBuffer, const VkDeviceSize struct_size,
629 const VkBuffer buffer, const VkDeviceSize offset, const uint32_t drawCount, const uint32_t stride,
630 const char *function) const;
631 void RecordIndirectBuffer(AccessContext &context, const ResourceUsageTag &tag, const VkDeviceSize struct_size,
632 const VkBuffer buffer, const VkDeviceSize offset, const uint32_t drawCount, uint32_t stride);
locke-lunarg36ba2592020-04-03 09:42:04 -0600[diff] [blame]633
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]634 bool ValidateCountBuffer(const AccessContext &context, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
635 const char *function) const;
636 void RecordCountBuffer(AccessContext &context, const ResourceUsageTag &tag, VkBuffer buffer, VkDeviceSize offset);
locke-lunarg93d68af2020-05-12 17:18:03 -0600[diff] [blame]637
locke-lunarg36ba2592020-04-03 09:42:04 -0600[diff] [blame]638 bool PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) const;
639 void PreCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]640
641 bool PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const;
642 void PreCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
643
644 bool PreCallValidateCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
645 uint32_t firstInstance) const;
646 void PreCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
647 uint32_t firstInstance);
648
649 bool PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
650 uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const;
651 void PreCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
652 uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
653
654 bool PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
655 uint32_t stride) const;
656 void PreCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
657 uint32_t stride);
658
659 bool PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
660 uint32_t drawCount, uint32_t stride) const;
661 void PreCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
662 uint32_t drawCount, uint32_t stride);
663
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]664 bool ValidateCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer,
665 VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride,
666 const char *function) const;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]667 bool PreCallValidateCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
668 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
669 uint32_t stride) const;
670 void PreCallRecordCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
671 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
672 uint32_t stride);
673 bool PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
674 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
675 uint32_t stride) const;
676 void PreCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
677 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
678 uint32_t stride);
679 bool PreCallValidateCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
680 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
681 uint32_t stride) const;
682 void PreCallRecordCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
683 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
684 uint32_t stride);
685
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]686 bool ValidateCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
687 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
688 uint32_t stride, const char *function) const;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]689 bool PreCallValidateCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
690 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
691 uint32_t stride) const;
692 void PreCallRecordCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
693 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
694 uint32_t stride);
695 bool PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
696 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
697 uint32_t stride) const;
698 void PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
699 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
700 uint32_t stride);
701 bool PreCallValidateCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
702 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
703 uint32_t stride) const;
704 void PreCallRecordCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
705 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
706 uint32_t stride);
707
708 bool PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
709 const VkClearColorValue *pColor, uint32_t rangeCount,
710 const VkImageSubresourceRange *pRanges) const;
711 void PreCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
712 const VkClearColorValue *pColor, uint32_t rangeCount,
713 const VkImageSubresourceRange *pRanges);
714
715 bool PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
716 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
717 const VkImageSubresourceRange *pRanges) const;
718 void PreCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
719 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
720 const VkImageSubresourceRange *pRanges);
721
722 bool PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
723 uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
724 VkDeviceSize stride, VkQueryResultFlags flags) const;
725 void PreCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
726 uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride,
727 VkQueryResultFlags flags);
728
729 bool PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size,
730 uint32_t data) const;
731 void PreCallRecordCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size,
732 uint32_t data);
733
734 bool PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
735 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
736 const VkImageResolve *pRegions) const;
737 void PreCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
738 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
739 const VkImageResolve *pRegions);
740
741 bool PreCallValidateCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
742 VkDeviceSize dataSize, const void *pData) const;
743 void PreCallRecordCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
744 VkDeviceSize dataSize, const void *pData);
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]745
746 bool PreCallValidateCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
747 VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const;
748 void PreCallRecordCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
749 VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]750};