Gitiles
Code Review Sign In
gerrit.openfyde.cn / chromium.googlesource.com / external / github.com / KhronosGroup / Vulkan-ValidationLayers / c4b78c57f8dd0de3503e891af66b1a1225142edd / . / layers / synchronization_validation.h
blob: a77b0f4c15653b271151634554a2183e4cc3988e [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;
John Zulauf59e25072020-07-17 10:55:21 -0600[diff] [blame]32class ResourceAccessState;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]33
John Zulauf2f952d22020-02-10 11:34:51 -0700[diff] [blame]34enum SyncHazard {
35 NONE = 0,
36 READ_AFTER_WRITE,
37 WRITE_AFTER_READ,
38 WRITE_AFTER_WRITE,
39 READ_RACING_WRITE,
40 WRITE_RACING_WRITE,
41 WRITE_RACING_READ,
42};
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]43
44// Useful Utilites for manipulating StageAccess parameters, suitable as base class to save typing
45struct SyncStageAccess {
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]46 static inline SyncStageAccessFlags FlagBit(SyncStageAccessIndex stage_access) {
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]47 return syncStageAccessInfoByStageAccessIndex[stage_access].stage_access_bit;
48 }
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]49 static inline SyncStageAccessFlags Flags(SyncStageAccessIndex stage_access) {
50 return static_cast<SyncStageAccessFlags>(FlagBit(stage_access));
51 }
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]52
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]53 static bool IsRead(const SyncStageAccessFlags &stage_access_bit) { return (stage_access_bit & syncStageAccessReadMask).any(); }
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]54 static bool IsRead(SyncStageAccessIndex stage_access_index) { return IsRead(FlagBit(stage_access_index)); }
55
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]56 static bool IsWrite(const SyncStageAccessFlags &stage_access_bit) {
57 return (stage_access_bit & syncStageAccessWriteMask).any();
58 }
59 static bool HasWrite(const SyncStageAccessFlags &stage_access_mask) {
60 return (stage_access_mask & syncStageAccessWriteMask).any();
61 }
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]62 static bool IsWrite(SyncStageAccessIndex stage_access_index) { return IsWrite(FlagBit(stage_access_index)); }
63 static VkPipelineStageFlagBits PipelineStageBit(SyncStageAccessIndex stage_access_index) {
64 return syncStageAccessInfoByStageAccessIndex[stage_access_index].stage_mask;
65 }
66 static SyncStageAccessFlags AccessScopeByStage(VkPipelineStageFlags stages);
67 static SyncStageAccessFlags AccessScopeByAccess(VkAccessFlags access);
68 static SyncStageAccessFlags AccessScope(VkPipelineStageFlags stages, VkAccessFlags access);
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]69 static SyncStageAccessFlags AccessScope(const SyncStageAccessFlags &stage_scope, VkAccessFlags accesses) {
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]70 return stage_scope & AccessScopeByAccess(accesses);
71 }
72};
73
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]74struct ResourceUsageTag {
75 uint64_t index;
John Zulaufcc6fecb2020-06-17 15:24:54 -0600[diff] [blame]76 CMD_TYPE command;
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]77 const static uint64_t kMaxIndex = std::numeric_limits<uint64_t>::max();
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]78 ResourceUsageTag &operator++() {
79 index++;
80 return *this;
81 }
82 bool IsBefore(const ResourceUsageTag &rhs) const { return index < rhs.index; }
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]83 bool operator==(const ResourceUsageTag &rhs) const { return (index == rhs.index); }
84 bool operator!=(const ResourceUsageTag &rhs) const { return !(*this == rhs); }
John Zulaufcc6fecb2020-06-17 15:24:54 -0600[diff] [blame]85 ResourceUsageTag() : index(0), command(CMD_NONE) {}
86 ResourceUsageTag(uint64_t index_, CMD_TYPE command_) : index(index_), command(command_) {}
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]87};
88
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]89struct HazardResult {
John Zulauf59e25072020-07-17 10:55:21 -0600[diff] [blame]90 std::unique_ptr<const ResourceAccessState> access_state;
91 SyncStageAccessIndex usage_index = std::numeric_limits<SyncStageAccessIndex>::max();
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]92 SyncHazard hazard = NONE;
John Zulauf37ceaed2020-07-03 16:18:15 -0600[diff] [blame]93 SyncStageAccessFlags prior_access = 0U; // TODO -- change to a NONE enum in ...Bits
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]94 ResourceUsageTag tag = ResourceUsageTag();
John Zulauf59e25072020-07-17 10:55:21 -0600[diff] [blame]95 void Set(const ResourceAccessState *access_state_, SyncStageAccessIndex usage_index_, SyncHazard hazard_,
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]96 const SyncStageAccessFlags &prior_, const ResourceUsageTag &tag_);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]97};
98
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]99struct SyncBarrier {
100 VkPipelineStageFlags src_exec_scope;
101 SyncStageAccessFlags src_access_scope;
102 VkPipelineStageFlags dst_exec_scope;
103 SyncStageAccessFlags dst_access_scope;
104 SyncBarrier() = default;
105 SyncBarrier &operator=(const SyncBarrier &) = default;
106 SyncBarrier(VkQueueFlags gueue_flags, const VkSubpassDependency2 &sub_pass_barrier);
John Zulaufa0a98292020-09-18 09:30:10 -0600[diff] [blame]107 void Merge(const SyncBarrier &other) {
108 src_exec_scope |= other.src_exec_scope;
109 src_access_scope |= other.src_access_scope;
110 dst_exec_scope |= other.dst_exec_scope;
111 dst_access_scope |= other.dst_access_scope;
112 }
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]113 SyncBarrier(VkPipelineStageFlags src_exec_scope_, const SyncStageAccessFlags &src_access_scope_,
114 VkPipelineStageFlags dst_exec_scope_, const SyncStageAccessFlags &dst_access_scope_)
John Zulaufa0a98292020-09-18 09:30:10 -0600[diff] [blame]115 : src_exec_scope(src_exec_scope_),
116 src_access_scope(src_access_scope_),
117 dst_exec_scope(dst_exec_scope_),
118 dst_access_scope(dst_access_scope_) {}
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]119 SyncBarrier(const SyncBarrier &other) = default;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]120};
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]121
122// To represent ordering guarantees such as rasterization and store
123struct SyncOrderingBarrier {
124 VkPipelineStageFlags exec_scope;
125 SyncStageAccessFlags access_scope;
126 SyncOrderingBarrier() = default;
127 SyncOrderingBarrier &operator=(const SyncOrderingBarrier &) = default;
128};
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]129
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]130class ResourceAccessState : public SyncStageAccess {
131 protected:
132 // Mutliple read operations can be simlutaneously (and independently) synchronized,
133 // given the only the second execution scope creates a dependency chain, we have to track each,
134 // but only up to one per pipeline stage (as another read from the *same* stage become more recent,
135 // and applicable one for hazard detection
136 struct ReadState {
137 VkPipelineStageFlagBits stage; // The stage of this read
John Zulauf37ceaed2020-07-03 16:18:15 -0600[diff] [blame]138 SyncStageAccessFlags access; // TODO: Change to FlagBits when we have a None bit enum
John Zulauff51fbb62020-10-02 14:43:24 -0600[diff] [blame]139 // TODO: Revisit whether this needs to support multiple reads per stage
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]140 VkPipelineStageFlags barriers; // all applicable barriered stages
141 ResourceUsageTag tag;
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]142 VkPipelineStageFlags pending_dep_chain; // Should be zero except during barrier application
143 // Excluded from comparison
144 ReadState() = default;
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]145 bool operator==(const ReadState &rhs) const {
John Zulauf37ceaed2020-07-03 16:18:15 -0600[diff] [blame]146 bool same = (stage == rhs.stage) && (access == rhs.access) && (barriers == rhs.barriers) && (tag == rhs.tag);
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]147 return same;
148 }
149 bool operator!=(const ReadState &rhs) const { return !(*this == rhs); }
John Zulauf4285ee92020-09-23 10:20:52 -0600[diff] [blame]150 inline void Set(VkPipelineStageFlagBits stage_, SyncStageAccessFlags access_, VkPipelineStageFlags barriers_,
151 const ResourceUsageTag &tag_) {
152 stage = stage_;
153 access = access_;
154 barriers = barriers_;
155 tag = tag_;
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]156 pending_dep_chain = 0; // If this is a new read, we aren't applying a barrier set.
John Zulauf4285ee92020-09-23 10:20:52 -0600[diff] [blame]157 }
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]158 };
159
160 public:
161 HazardResult DetectHazard(SyncStageAccessIndex usage_index) const;
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]162 HazardResult DetectHazard(SyncStageAccessIndex usage_index, const SyncOrderingBarrier &ordering) const;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]163
John Zulaufc9201222020-05-13 15:13:03 -0600[diff] [blame]164 HazardResult DetectBarrierHazard(SyncStageAccessIndex usage_index, VkPipelineStageFlags source_exec_scope,
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]165 const SyncStageAccessFlags &source_access_scope) const;
Jeremy Gebbenc4b78c52020-12-11 09:39:47 -0700[diff] [blame^]166 HazardResult DetectAsyncHazard(SyncStageAccessIndex usage_index, const ResourceUsageTag &start_tag) const;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]167
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]168 void Update(SyncStageAccessIndex usage_index, const ResourceUsageTag &tag);
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]169 void SetWrite(const SyncStageAccessFlags &usage_bit, const ResourceUsageTag &tag);
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]170 void Resolve(const ResourceAccessState &other);
John Zulaufb02c1eb2020-10-06 16:33:36 -0600[diff] [blame]171 void ApplyBarriers(const std::vector<SyncBarrier> &barriers, bool layout_transition);
172 void ApplyBarriers(const std::vector<SyncBarrier> &barriers, const ResourceUsageTag &tag);
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]173 void ApplyBarrier(const SyncBarrier &barrier, bool layout_transition);
174 void ApplyPendingBarriers(const ResourceUsageTag &tag);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]175
176 ResourceAccessState()
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]177 : write_barriers(~SyncStageAccessFlags(0)),
178 write_dependency_chain(0),
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]179 write_tag(),
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame]180 last_write(0),
John Zulauff51fbb62020-10-02 14:43:24 -0600[diff] [blame]181 input_attachment_read(false),
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame]182 last_read_count(0),
John Zulauf361fb532020-07-22 10:45:39 -0600[diff] [blame]183 last_read_stages(0),
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]184 read_execution_barriers(0),
185 pending_write_dep_chain(0),
186 pending_layout_transition(false),
187 pending_write_barriers(0) {}
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]188
John Zulaufb02c1eb2020-10-06 16:33:36 -0600[diff] [blame]189 bool HasPendingState() const {
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]190 return (0 != pending_layout_transition) || pending_write_barriers.any() || (0 != pending_write_dep_chain);
John Zulaufb02c1eb2020-10-06 16:33:36 -0600[diff] [blame]191 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]192 bool HasWriteOp() const { return last_write != 0; }
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]193 bool operator==(const ResourceAccessState &rhs) const {
194 bool same = (write_barriers == rhs.write_barriers) && (write_dependency_chain == rhs.write_dependency_chain) &&
195 (last_read_count == rhs.last_read_count) && (last_read_stages == rhs.last_read_stages) &&
John Zulauff51fbb62020-10-02 14:43:24 -0600[diff] [blame]196 (write_tag == rhs.write_tag) && (input_attachment_read == rhs.input_attachment_read) &&
John Zulauf361fb532020-07-22 10:45:39 -0600[diff] [blame]197 (read_execution_barriers == rhs.read_execution_barriers);
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]198 for (uint32_t i = 0; same && i < last_read_count; i++) {
John Zulauf4285ee92020-09-23 10:20:52 -0600[diff] [blame]199 same &= last_reads[i] == rhs.last_reads[i];
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]200 }
201 return same;
202 }
203 bool operator!=(const ResourceAccessState &rhs) const { return !(*this == rhs); }
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]204 VkPipelineStageFlags GetReadBarriers(const SyncStageAccessFlags &usage) const;
John Zulauf59e25072020-07-17 10:55:21 -0600[diff] [blame]205 SyncStageAccessFlags GetWriteBarriers() const { return write_barriers; }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]206
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]207 private:
John Zulauf4285ee92020-09-23 10:20:52 -0600[diff] [blame]208 static constexpr VkPipelineStageFlags kInvalidAttachmentStage = ~VkPipelineStageFlags(0);
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]209 bool IsWriteHazard(SyncStageAccessFlags usage) const { return (usage & ~write_barriers).any(); }
210 bool IsRAWHazard(VkPipelineStageFlagBits usage_stage, const SyncStageAccessFlags &usage) const;
John Zulaufa0a98292020-09-18 09:30:10 -0600[diff] [blame]211 bool InSourceScopeOrChain(VkPipelineStageFlags src_exec_scope, SyncStageAccessFlags src_access_scope) const {
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]212 return (src_access_scope & last_write).any() || (write_dependency_chain & src_exec_scope);
John Zulaufa0a98292020-09-18 09:30:10 -0600[diff] [blame]213 }
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame]214
215 static bool IsReadHazard(VkPipelineStageFlagBits stage, const VkPipelineStageFlags barriers) {
216 return 0 != (stage & ~barriers);
217 }
218 static bool IsReadHazard(VkPipelineStageFlags stage_mask, const VkPipelineStageFlags barriers) {
219 return stage_mask != (stage_mask & barriers);
220 }
221
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]222 bool IsReadHazard(VkPipelineStageFlagBits stage, const ReadState &read_access) const {
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame]223 return IsReadHazard(stage, read_access.barriers);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]224 }
John Zulauf0cb5be22020-01-23 12:18:22 -0700[diff] [blame]225 bool IsReadHazard(VkPipelineStageFlags stage_mask, const ReadState &read_access) const {
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame]226 return IsReadHazard(stage_mask, read_access.barriers);
John Zulauf0cb5be22020-01-23 12:18:22 -0700[diff] [blame]227 }
John Zulauf4285ee92020-09-23 10:20:52 -0600[diff] [blame]228 VkPipelineStageFlags GetOrderedStages(const SyncOrderingBarrier &ordering) const;
229 ReadState *GetReadStateForStage(VkPipelineStageFlagBits stage, uint32_t search_limit = kStageCount);
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame]230
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]231 // TODO: Add a NONE (zero) enum to SyncStageAccessFlags for input_attachment_read and last_write
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame]232
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]233 // With reads, each must be "safe" relative to it's prior write, so we need only
234 // save the most recent write operation (as anything *transitively* unsafe would arleady
235 // be included
236 SyncStageAccessFlags write_barriers; // union of applicable barrier masks since last write
237 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]238 ResourceUsageTag write_tag;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]239 SyncStageAccessFlags last_write; // only the most recent write
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]240
John Zulauff51fbb62020-10-02 14:43:24 -0600[diff] [blame]241 // TODO Input Attachment cleanup for multiple reads in a given stage
242 // Tracks whether the fragment shader read is input attachment read
243 bool input_attachment_read;
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame]244
245 uint32_t last_read_count;
246 VkPipelineStageFlags last_read_stages;
John Zulauf361fb532020-07-22 10:45:39 -0600[diff] [blame]247 VkPipelineStageFlags read_execution_barriers;
John Zulaufd14743a2020-07-03 09:42:39 -0600[diff] [blame]248 static constexpr size_t kStageCount = 32; // TODO: The manual count was 28 real stages. Add stage count to codegen
249 std::array<ReadState, kStageCount> last_reads;
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]250
251 // Pending execution state to support independent parallel barriers
252 VkPipelineStageFlags pending_write_dep_chain;
253 bool pending_layout_transition;
254 SyncStageAccessFlags pending_write_barriers;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]255};
256
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]257using ResourceAccessRangeMap = sparse_container::range_map<VkDeviceSize, ResourceAccessState>;
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]258using ResourceAccessRange = typename ResourceAccessRangeMap::key_type;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]259using ResourceRangeMergeIterator = sparse_container::parallel_iterator<ResourceAccessRangeMap, const ResourceAccessRangeMap>;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]260
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]261class AccessContext {
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]262 public:
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]263 enum AddressType : int { kLinearAddress = 0, kIdealizedAddress = 1, kMaxAddressType = 1 };
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]264 enum DetectOptions : uint32_t {
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]265 kDetectPrevious = 1U << 0,
266 kDetectAsync = 1U << 1,
267 kDetectAll = (kDetectPrevious | kDetectAsync)
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]268 };
John Zulaufb02c1eb2020-10-06 16:33:36 -0600[diff] [blame]269 constexpr static int kAddressTypeCount = AddressType::kMaxAddressType + 1;
270 static const std::array<AddressType, kAddressTypeCount> kAddressTypes;
271 using MapArray = std::array<ResourceAccessRangeMap, kAddressTypeCount>;
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]272
John Zulaufbaea94f2020-09-15 17:55:16 -0600[diff] [blame]273 // WIP TODO WIP Multi-dep -- change track back to support barrier vector, not just last.
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]274 struct TrackBack {
John Zulaufa0a98292020-09-18 09:30:10 -0600[diff] [blame]275 std::vector<SyncBarrier> barriers;
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]276 const AccessContext *context;
John Zulaufbaea94f2020-09-15 17:55:16 -0600[diff] [blame]277 TrackBack(const AccessContext *context_, VkQueueFlags queue_flags_,
John Zulaufa0a98292020-09-18 09:30:10 -0600[diff] [blame]278 const std::vector<const VkSubpassDependency2 *> &subpass_dependencies_)
279 : barriers(), context(context_) {
280 barriers.reserve(subpass_dependencies_.size());
281 for (const VkSubpassDependency2 *dependency : subpass_dependencies_) {
282 assert(dependency);
283 barriers.emplace_back(queue_flags_, *dependency);
284 }
285 }
286
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]287 TrackBack &operator=(const TrackBack &) = default;
288 TrackBack() = default;
289 };
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]290
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]291 HazardResult DetectHazard(const BUFFER_STATE &buffer, SyncStageAccessIndex usage_index, const ResourceAccessRange &range) const;
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]292 HazardResult DetectHazard(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]293 const VkImageSubresourceLayers &subresource, const VkOffset3D &offset,
294 const VkExtent3D &extent) const;
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]295 template <typename Detector>
296 HazardResult DetectHazard(Detector &detector, const IMAGE_STATE &image, const VkImageSubresourceRange &subresource_range,
297 const VkOffset3D &offset, const VkExtent3D &extent, DetectOptions options) const;
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]298 HazardResult DetectHazard(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
299 const VkImageSubresourceRange &subresource_range, const VkOffset3D &offset,
300 const VkExtent3D &extent) const;
John Zulauf69133422020-05-20 14:55:53 -0600[diff] [blame]301 HazardResult DetectHazard(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
302 const VkImageSubresourceRange &subresource_range, const SyncOrderingBarrier &ordering,
303 const VkOffset3D &offset, const VkExtent3D &extent) const;
John Zulaufb027cdb2020-05-21 14:25:22 -0600[diff] [blame]304 HazardResult DetectHazard(const IMAGE_VIEW_STATE *view, SyncStageAccessIndex current_usage, const SyncOrderingBarrier &ordering,
305 const VkOffset3D &offset, const VkExtent3D &extent, VkImageAspectFlags aspect_mask = 0U) const;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]306 HazardResult DetectImageBarrierHazard(const IMAGE_STATE &image, VkPipelineStageFlags src_exec_scope,
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]307 const SyncStageAccessFlags &src_access_scope,
308 const VkImageSubresourceRange &subresource_range, DetectOptions options) const;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]309 HazardResult DetectImageBarrierHazard(const IMAGE_STATE &image, VkPipelineStageFlags src_exec_scope,
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]310 const SyncStageAccessFlags &src_stage_accesses,
311 const VkImageMemoryBarrier &barrier) const;
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]312 HazardResult DetectSubpassTransitionHazard(const TrackBack &track_back, const IMAGE_VIEW_STATE *attach_view) const;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]313
John Zulaufb02c1eb2020-10-06 16:33:36 -0600[diff] [blame]314 void RecordLayoutTransitions(const RENDER_PASS_STATE &rp_state, uint32_t subpass,
315 const std::vector<const IMAGE_VIEW_STATE *> &attachment_views, const ResourceUsageTag &tag);
316
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]317 const TrackBack &GetDstExternalTrackBack() const { return dst_external_; }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]318 void Reset() {
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]319 prev_.clear();
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]320 prev_by_subpass_.clear();
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]321 async_.clear();
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]322 src_external_ = TrackBack();
John Zulaufa0a98292020-09-18 09:30:10 -0600[diff] [blame]323 dst_external_ = TrackBack();
Jeremy Gebbenc4b78c52020-12-11 09:39:47 -0700[diff] [blame^]324 start_tag_ = ResourceUsageTag();
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]325 for (auto &map : access_state_maps_) {
326 map.clear();
327 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]328 }
John Zulaufb02c1eb2020-10-06 16:33:36 -0600[diff] [blame]329
330 // Follow the context previous to access the access state, supporting "lazy" import into the context. Not intended for
331 // subpass layout transition, as the pending state handling is more complex
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]332 // TODO: See if returning the lower_bound would be useful from a performance POV -- look at the lower_bound overhead
333 // 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]334 void ResolvePreviousAccess(AddressType type, const ResourceAccessRange &range, ResourceAccessRangeMap *descent_map,
335 const ResourceAccessState *infill_state) const;
John Zulaufb02c1eb2020-10-06 16:33:36 -0600[diff] [blame]336 template <typename BarrierAction>
337 void ResolveAccessRange(const IMAGE_STATE &image_state, const VkImageSubresourceRange &subresource_range,
338 BarrierAction &barrier_action, AddressType address_type, ResourceAccessRangeMap *descent_map,
339 const ResourceAccessState *infill_state) const;
340 template <typename BarrierAction>
341 void ResolveAccessRange(AddressType type, const ResourceAccessRange &range, BarrierAction &barrier_action,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]342 ResourceAccessRangeMap *resolve_map, const ResourceAccessState *infill_state,
343 bool recur_to_infill = true) const;
John Zulaufb02c1eb2020-10-06 16:33:36 -0600[diff] [blame]344
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]345 void UpdateAccessState(const BUFFER_STATE &buffer, SyncStageAccessIndex current_usage, const ResourceAccessRange &range,
346 const ResourceUsageTag &tag);
347 void UpdateAccessState(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
348 const VkImageSubresourceRange &subresource_range, const VkOffset3D &offset, const VkExtent3D &extent,
349 const ResourceUsageTag &tag);
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]350 void UpdateAccessState(const IMAGE_VIEW_STATE *view, SyncStageAccessIndex current_usage, const VkOffset3D &offset,
351 const VkExtent3D &extent, VkImageAspectFlags aspect_mask, const ResourceUsageTag &tag);
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]352 void UpdateAccessState(const IMAGE_STATE &image, SyncStageAccessIndex current_usage,
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]353 const VkImageSubresourceLayers &subresource, const VkOffset3D &offset, const VkExtent3D &extent,
354 const ResourceUsageTag &tag);
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]355 void UpdateAttachmentResolveAccess(const RENDER_PASS_STATE &rp_state, const VkRect2D &render_area,
356 const std::vector<const IMAGE_VIEW_STATE *> &attachment_views, uint32_t subpass,
357 const ResourceUsageTag &tag);
John Zulaufaff20662020-06-01 14:07:58 -0600[diff] [blame]358 void UpdateAttachmentStoreAccess(const RENDER_PASS_STATE &rp_state, const VkRect2D &render_area,
359 const std::vector<const IMAGE_VIEW_STATE *> &attachment_views, uint32_t subpass,
360 const ResourceUsageTag &tag);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]361
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]362 void ResolveChildContexts(const std::vector<AccessContext> &contexts);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]363
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]364 template <typename Action>
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]365 void UpdateResourceAccess(const BUFFER_STATE &buffer, const ResourceAccessRange &range, const Action action);
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]366 template <typename Action>
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]367 void UpdateResourceAccess(const IMAGE_STATE &image, const VkImageSubresourceRange &subresource_range, const Action action);
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]368
369 template <typename Action>
370 void ApplyGlobalBarriers(const Action &barrier_action);
371
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]372 static AddressType ImageAddressType(const IMAGE_STATE &image);
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]373
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]374 AccessContext(uint32_t subpass, VkQueueFlags queue_flags, const std::vector<SubpassDependencyGraphNode> &dependencies,
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]375 const std::vector<AccessContext> &contexts, const AccessContext *external_context);
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]376
377 AccessContext() { Reset(); }
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]378 AccessContext(const AccessContext &copy_from) = default;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]379
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]380 ResourceAccessRangeMap &GetAccessStateMap(AddressType type) { return access_state_maps_[type]; }
381 const ResourceAccessRangeMap &GetAccessStateMap(AddressType type) const { return access_state_maps_[type]; }
382 ResourceAccessRangeMap &GetLinearMap() { return GetAccessStateMap(AddressType::kLinearAddress); }
383 const ResourceAccessRangeMap &GetLinearMap() const { return GetAccessStateMap(AddressType::kLinearAddress); }
384 ResourceAccessRangeMap &GetIdealizedMap() { return GetAccessStateMap(AddressType::kIdealizedAddress); }
385 const ResourceAccessRangeMap &GetIdealizedMap() const { return GetAccessStateMap(AddressType::kIdealizedAddress); }
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]386 const TrackBack *GetTrackBackFromSubpass(uint32_t subpass) const {
387 if (subpass == VK_SUBPASS_EXTERNAL) {
388 return &src_external_;
389 } else {
390 assert(subpass < prev_by_subpass_.size());
391 return prev_by_subpass_[subpass];
392 }
393 }
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]394
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]395 bool ValidateLayoutTransitions(const SyncValidator &sync_state,
396
397 const RENDER_PASS_STATE &rp_state,
398
399 const VkRect2D &render_area,
400
401 uint32_t subpass, const std::vector<const IMAGE_VIEW_STATE *> &attachment_views,
402 const char *func_name) const;
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]403 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]404 uint32_t subpass, const std::vector<const IMAGE_VIEW_STATE *> &attachment_views,
405 const char *func_name) const;
John Zulaufaff20662020-06-01 14:07:58 -0600[diff] [blame]406 bool ValidateStoreOperation(const SyncValidator &sync_state, const RENDER_PASS_STATE &rp_state, const VkRect2D &render_area,
407 uint32_t subpass, const std::vector<const IMAGE_VIEW_STATE *> &attachment_views,
408 const char *func_name) const;
John Zulaufb027cdb2020-05-21 14:25:22 -0600[diff] [blame]409 bool ValidateResolveOperations(const SyncValidator &sync_state, const RENDER_PASS_STATE &rp_state, const VkRect2D &render_area,
410 const std::vector<const IMAGE_VIEW_STATE *> &attachment_views, const char *func_name,
411 uint32_t subpass) const;
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]412
Jeremy Gebbenc4b78c52020-12-11 09:39:47 -0700[diff] [blame^]413 void SetStartTag(const ResourceUsageTag &tag) { start_tag_ = tag; }
414
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]415 private:
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]416 HazardResult DetectHazard(AddressType type, SyncStageAccessIndex usage_index, const ResourceAccessRange &range) const;
417 HazardResult DetectBarrierHazard(AddressType type, SyncStageAccessIndex current_usage, VkPipelineStageFlags src_exec_scope,
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]418 const SyncStageAccessFlags &src_access_scope, const ResourceAccessRange &range,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]419 DetectOptions options) const;
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]420
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]421 template <typename Detector>
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]422 HazardResult DetectHazard(AddressType type, const Detector &detector, const ResourceAccessRange &range,
423 DetectOptions options) const;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]424 template <typename Detector>
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]425 HazardResult DetectAsyncHazard(AddressType type, const Detector &detector, const ResourceAccessRange &range) const;
John Zulauf5f13a792020-03-10 07:31:21 -0600[diff] [blame]426 template <typename Detector>
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]427 HazardResult DetectPreviousHazard(AddressType type, const Detector &detector, const ResourceAccessRange &range) const;
John Zulauf16adfc92020-04-08 10:28:33 -0600[diff] [blame]428 void UpdateAccessState(AddressType type, SyncStageAccessIndex current_usage, const ResourceAccessRange &range,
429 const ResourceUsageTag &tag);
John Zulaufb02c1eb2020-10-06 16:33:36 -0600[diff] [blame]430
431 MapArray access_state_maps_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]432 std::vector<TrackBack> prev_;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]433 std::vector<TrackBack *> prev_by_subpass_;
Jeremy Gebbenc4b78c52020-12-11 09:39:47 -0700[diff] [blame^]434 std::vector<const AccessContext *> async_;
John Zulaufe5da6e52020-03-18 15:32:18 -0600[diff] [blame]435 TrackBack src_external_;
436 TrackBack dst_external_;
Jeremy Gebbenc4b78c52020-12-11 09:39:47 -0700[diff] [blame^]437 ResourceUsageTag start_tag_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]438};
439
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]440class RenderPassAccessContext {
441 public:
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]442 RenderPassAccessContext() : rp_state_(nullptr), current_subpass_(0) {}
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]443
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]444 bool ValidateDrawSubpassAttachment(const SyncValidator &sync_state, const CMD_BUFFER_STATE &cmd, const VkRect2D &render_area,
445 const char *func_name) const;
locke-lunarg96dc9632020-06-10 17:22:18 -0600[diff] [blame]446 void RecordDrawSubpassAttachment(const CMD_BUFFER_STATE &cmd, const VkRect2D &render_area, const ResourceUsageTag &tag);
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]447 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]448 bool ValidateEndRenderPass(const SyncValidator &sync_state, const VkRect2D &render_area, const char *func_name) const;
449 bool ValidateFinalSubpassLayoutTransitions(const SyncValidator &sync_state, const VkRect2D &render_area,
450 const char *func_name) const;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]451
452 void RecordLayoutTransitions(const ResourceUsageTag &tag);
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]453 void RecordLoadOperations(const VkRect2D &render_area, const ResourceUsageTag &tag);
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]454 void RecordBeginRenderPass(const SyncValidator &state, const CMD_BUFFER_STATE &cb_state, const AccessContext *external_context,
455 VkQueueFlags queue_flags, const ResourceUsageTag &tag);
John Zulauf1507ee42020-05-18 11:33:09 -0600[diff] [blame]456 void RecordNextSubpass(const VkRect2D &render_area, const ResourceUsageTag &tag);
John Zulauf1a224292020-06-30 14:52:13 -0600[diff] [blame]457 void RecordEndRenderPass(AccessContext *external_context, const VkRect2D &render_area, const ResourceUsageTag &tag);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]458
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]459 AccessContext &CurrentContext() { return subpass_contexts_[current_subpass_]; }
460 const AccessContext &CurrentContext() const { return subpass_contexts_[current_subpass_]; }
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]461 const std::vector<AccessContext> &GetContexts() const { return subpass_contexts_; }
462 uint32_t GetCurrentSubpass() const { return current_subpass_; }
463 const RENDER_PASS_STATE *GetRenderPassState() const { return rp_state_; }
John Zulauf7635de32020-05-29 17:14:15 -0600[diff] [blame]464 AccessContext *CreateStoreResolveProxy(const VkRect2D &render_area) const;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]465
466 private:
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]467 const RENDER_PASS_STATE *rp_state_;
468 uint32_t current_subpass_;
469 std::vector<AccessContext> subpass_contexts_;
470 std::vector<const IMAGE_VIEW_STATE *> attachment_views_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]471};
472
473class CommandBufferAccessContext {
474 public:
475 CommandBufferAccessContext()
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]476 : command_number_(0),
477 reset_count_(0),
478 render_pass_contexts_(),
479 cb_access_context_(),
480 current_context_(&cb_access_context_),
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]481 current_renderpass_context_(),
482 cb_state_(),
483 queue_flags_() {}
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]484 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]485 : CommandBufferAccessContext() {
486 cb_state_ = cb_state;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]487 sync_state_ = &sync_validator;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]488 queue_flags_ = queue_flags;
489 }
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]490
491 void Reset() {
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]492 command_number_ = 0;
493 reset_count_++;
494 cb_access_context_.Reset();
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]495 render_pass_contexts_.clear();
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]496 current_context_ = &cb_access_context_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]497 current_renderpass_context_ = nullptr;
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]498 }
499
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]500 AccessContext *GetCurrentAccessContext() { return current_context_; }
501 const AccessContext *GetCurrentAccessContext() const { return current_context_; }
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]502 void RecordBeginRenderPass(const ResourceUsageTag &tag);
503 bool ValidateBeginRenderPass(const RENDER_PASS_STATE &render_pass, const VkRenderPassBeginInfo *pRenderPassBegin,
504 const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const char *func_name) const;
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]505 bool ValidateDispatchDrawDescriptorSet(VkPipelineBindPoint pipelineBindPoint, const char *func_name) const;
506 void RecordDispatchDrawDescriptorSet(VkPipelineBindPoint pipelineBindPoint, const ResourceUsageTag &tag);
507 bool ValidateDrawVertex(uint32_t vertexCount, uint32_t firstVertex, const char *func_name) const;
508 void RecordDrawVertex(uint32_t vertexCount, uint32_t firstVertex, const ResourceUsageTag &tag);
509 bool ValidateDrawVertexIndex(uint32_t indexCount, uint32_t firstIndex, const char *func_name) const;
510 void RecordDrawVertexIndex(uint32_t indexCount, uint32_t firstIndex, const ResourceUsageTag &tag);
511 bool ValidateDrawSubpassAttachment(const char *func_name) const;
512 void RecordDrawSubpassAttachment(const ResourceUsageTag &tag);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]513 bool ValidateNextSubpass(const char *func_name) const;
514 bool ValidateEndRenderpass(const char *func_name) const;
515 void RecordNextSubpass(const RENDER_PASS_STATE &render_pass, const ResourceUsageTag &tag);
516 void RecordEndRenderPass(const RENDER_PASS_STATE &render_pass, const ResourceUsageTag &tag);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]517 CMD_BUFFER_STATE *GetCommandBufferState() { return cb_state_.get(); }
518 const CMD_BUFFER_STATE *GetCommandBufferState() const { return cb_state_.get(); }
519 VkQueueFlags GetQueueFlags() const { return queue_flags_; }
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]520 inline ResourceUsageTag NextCommandTag(CMD_TYPE command) {
521 // TODO: add command encoding to ResourceUsageTag.
522 // What else we what to include. Do we want some sort of "parent" or global sequence number
523 command_number_++;
John Zulaufcc6fecb2020-06-17 15:24:54 -0600[diff] [blame]524 const auto index = (static_cast<uint64_t>(reset_count_) << 32) | command_number_;
525 ResourceUsageTag next(index, command);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]526 return next;
527 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]528
529 private:
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]530 uint32_t command_number_;
531 uint32_t reset_count_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]532 std::vector<RenderPassAccessContext> render_pass_contexts_;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]533 AccessContext cb_access_context_;
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]534 AccessContext *current_context_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]535 RenderPassAccessContext *current_renderpass_context_;
536 std::shared_ptr<CMD_BUFFER_STATE> cb_state_;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]537 SyncValidator *sync_state_;
538
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]539 VkQueueFlags queue_flags_;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]540};
541
542class SyncValidator : public ValidationStateTracker, public SyncStageAccess {
543 public:
544 SyncValidator() { container_type = LayerObjectTypeSyncValidation; }
545 using StateTracker = ValidationStateTracker;
546
547 using StateTracker::AccessorTraitsTypes;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]548 std::unordered_map<VkCommandBuffer, std::unique_ptr<CommandBufferAccessContext>> cb_access_state;
549 CommandBufferAccessContext *GetAccessContextImpl(VkCommandBuffer command_buffer, bool do_insert) {
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]550 auto found_it = cb_access_state.find(command_buffer);
551 if (found_it == cb_access_state.end()) {
552 if (!do_insert) return nullptr;
553 // If we don't have one, make it.
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]554 auto cb_state = GetShared<CMD_BUFFER_STATE>(command_buffer);
555 assert(cb_state.get());
556 auto queue_flags = GetQueueFlags(*cb_state);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]557 std::unique_ptr<CommandBufferAccessContext> context(new CommandBufferAccessContext(*this, cb_state, queue_flags));
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]558 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]559 found_it = insert_pair.first;
560 }
561 return found_it->second.get();
562 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]563 CommandBufferAccessContext *GetAccessContext(VkCommandBuffer command_buffer) {
564 return GetAccessContextImpl(command_buffer, true); // true -> do_insert on not found
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]565 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]566 CommandBufferAccessContext *GetAccessContextNoInsert(VkCommandBuffer command_buffer) {
567 return GetAccessContextImpl(command_buffer, false); // false -> don't do_insert on not found
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]568 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]569
570 const CommandBufferAccessContext *GetAccessContext(VkCommandBuffer command_buffer) const {
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]571 const auto found_it = cb_access_state.find(command_buffer);
572 if (found_it == cb_access_state.end()) {
573 return nullptr;
574 }
575 return found_it->second.get();
576 }
577
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]578 void ApplyGlobalBarriers(AccessContext *context, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]579 SyncStageAccessFlags src_stage_scope, SyncStageAccessFlags dst_stage_scope,
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]580 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, const ResourceUsageTag &tag);
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]581 void ApplyBufferBarriers(AccessContext *context, VkPipelineStageFlags src_stage_mask,
582 const SyncStageAccessFlags &src_stage_scope, VkPipelineStageFlags dst_stage_mask,
583 const SyncStageAccessFlags &dst_stage_scope, uint32_t barrier_count,
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]584 const VkBufferMemoryBarrier *barriers);
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]585 void ApplyImageBarriers(AccessContext *context, VkPipelineStageFlags src_stage_mask,
586 const SyncStageAccessFlags &src_stage_scope, VkPipelineStageFlags dst_stage_mask,
587 const SyncStageAccessFlags &dst_stage_scope, uint32_t barrier_count,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]588 const VkImageMemoryBarrier *barriers, const ResourceUsageTag &tag);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]589
John Zulaufd1f85d42020-04-15 12:23:15 -0600[diff] [blame]590 void ResetCommandBufferCallback(VkCommandBuffer command_buffer);
591 void FreeCommandBufferCallback(VkCommandBuffer command_buffer);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]592 void RecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]593 const VkSubpassBeginInfo *pSubpassBeginInfo, CMD_TYPE command);
594 void RecordCmdNextSubpass(VkCommandBuffer commandBuffer,
595
596 const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo,
597 CMD_TYPE command);
598 void RecordCmdEndRenderPass(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo, CMD_TYPE command);
John Zulauf33fc1d52020-07-17 11:01:10 -0600[diff] [blame]599 bool SupressedBoundDescriptorWAW(const HazardResult &hazard) const;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]600
601 void PostCallRecordCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]602 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, VkResult result) override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]603
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]604 bool ValidateBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
605 const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const char *func_name) const;
606
607 bool PreCallValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]608 VkSubpassContents contents) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]609
610 bool PreCallValidateCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]611 const VkSubpassBeginInfoKHR *pSubpassBeginInfo) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]612
613 bool PreCallValidateCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]614 const VkSubpassBeginInfoKHR *pSubpassBeginInfo) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]615
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]616 bool PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]617 const VkBufferCopy *pRegions) const override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]618
619 void PreCallRecordCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]620 const VkBufferCopy *pRegions) override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]621
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]622 bool PreCallValidateCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfos) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]623
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]624 void PreCallRecordCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfos) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]625
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]626 bool PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
627 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]628 const VkImageCopy *pRegions) const override;
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]629
630 void PreCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]631 VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) override;
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]632
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]633 bool PreCallValidateCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]634
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]635 void PreCallRecordCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]636
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]637 bool PreCallValidateCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
638 VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
639 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
640 uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
641 uint32_t imageMemoryBarrierCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]642 const VkImageMemoryBarrier *pImageMemoryBarriers) const override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]643
644 void PreCallRecordCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
645 VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
646 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
647 uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]648 uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]649
650 void PostCallRecordBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]651 VkResult result) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]652
653 void PostCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]654 VkSubpassContents contents) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]655 void PostCallRecordCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]656 const VkSubpassBeginInfo *pSubpassBeginInfo) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]657 void PostCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]658 const VkSubpassBeginInfo *pSubpassBeginInfo) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]659
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]660 bool ValidateCmdNextSubpass(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
661 const VkSubpassEndInfoKHR *pSubpassEndInfo, const char *func_name) const;
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]662 bool PreCallValidateCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]663 bool PreCallValidateCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]664 const VkSubpassEndInfoKHR *pSubpassEndInfo) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]665 bool PreCallValidateCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]666 const VkSubpassEndInfoKHR *pSubpassEndInfo) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]667
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]668 void PostCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]669 void PostCallRecordCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]670 const VkSubpassEndInfo *pSubpassEndInfo) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]671 void PostCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]672 const VkSubpassEndInfo *pSubpassEndInfo) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]673
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]674 bool ValidateCmdEndRenderPass(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo,
675 const char *func_name) const;
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]676 bool PreCallValidateCmdEndRenderPass(VkCommandBuffer commandBuffer) const override;
677 bool PreCallValidateCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo) const override;
678 bool PreCallValidateCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]679
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]680 void PostCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer) override;
681 void PostCallRecordCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) override;
682 void PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]683
684 template <typename BufferImageCopyRegionType>
685 bool ValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
686 VkImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopyRegionType *pRegions,
687 CopyCommandVersion version) const;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]688 bool PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
689 VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]690 const VkBufferImageCopy *pRegions) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]691 bool PreCallValidateCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]692 const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo) const override;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]693
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]694 template <typename BufferImageCopyRegionType>
695 void RecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
696 VkImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopyRegionType *pRegions,
697 CopyCommandVersion version);
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]698 void PreCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]699 VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]700 void PreCallRecordCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]701 const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo) override;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]702
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]703 template <typename BufferImageCopyRegionType>
704 bool ValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
705 VkBuffer dstBuffer, uint32_t regionCount, const BufferImageCopyRegionType *pRegions,
706 CopyCommandVersion version) const;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]707 bool PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]708 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]709 bool PreCallValidateCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]710 const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo) const override;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]711
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]712 template <typename BufferImageCopyRegionType>
713 void RecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
714 VkBuffer dstBuffer, uint32_t regionCount, const BufferImageCopyRegionType *pRegions,
715 CopyCommandVersion version);
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]716 void PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]717 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]718 void PreCallRecordCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]719 const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]720
721 template <typename RegionType>
722 bool ValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
723 VkImageLayout dstImageLayout, uint32_t regionCount, const RegionType *pRegions, VkFilter filter,
724 const char *apiName) const;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]725
726 bool PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
727 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]728 const VkImageBlit *pRegions, VkFilter filter) const override;
729 bool PreCallValidateCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo) const override;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]730
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]731 template <typename RegionType>
732 void RecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
733 VkImageLayout dstImageLayout, uint32_t regionCount, const RegionType *pRegions, VkFilter filter,
734 ResourceUsageTag tag);
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]735 void PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
736 VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]737 VkFilter filter) override;
738 void PreCallRecordCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo) override;
locke-lunarg36ba2592020-04-03 09:42:04 -0600[diff] [blame]739
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]740 bool ValidateIndirectBuffer(const AccessContext &context, VkCommandBuffer commandBuffer, const VkDeviceSize struct_size,
741 const VkBuffer buffer, const VkDeviceSize offset, const uint32_t drawCount, const uint32_t stride,
742 const char *function) const;
743 void RecordIndirectBuffer(AccessContext &context, const ResourceUsageTag &tag, const VkDeviceSize struct_size,
744 const VkBuffer buffer, const VkDeviceSize offset, const uint32_t drawCount, uint32_t stride);
locke-lunarg36ba2592020-04-03 09:42:04 -0600[diff] [blame]745
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]746 bool ValidateCountBuffer(const AccessContext &context, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
747 const char *function) const;
748 void RecordCountBuffer(AccessContext &context, const ResourceUsageTag &tag, VkBuffer buffer, VkDeviceSize offset);
locke-lunarg93d68af2020-05-12 17:18:03 -0600[diff] [blame]749
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]750 bool PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) const override;
751 void PreCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]752
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]753 bool PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const override;
754 void PreCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]755
756 bool PreCallValidateCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]757 uint32_t firstInstance) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]758 void PreCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]759 uint32_t firstInstance) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]760
761 bool PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]762 uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]763 void PreCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]764 uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]765
766 bool PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]767 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]768 void PreCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]769 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]770
771 bool PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]772 uint32_t drawCount, uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]773 void PreCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]774 uint32_t drawCount, uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]775
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]776 bool ValidateCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer,
777 VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride,
778 const char *function) const;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]779 bool PreCallValidateCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
780 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]781 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]782 void PreCallRecordCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
783 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]784 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]785 bool PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
786 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]787 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]788 void PreCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
789 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]790 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]791 bool PreCallValidateCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
792 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]793 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]794 void PreCallRecordCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
795 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]796 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]797
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]798 bool ValidateCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
799 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
800 uint32_t stride, const char *function) const;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]801 bool PreCallValidateCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
802 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]803 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]804 void PreCallRecordCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
805 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]806 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]807 bool PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
808 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]809 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]810 void PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
811 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]812 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]813 bool PreCallValidateCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
814 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]815 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]816 void PreCallRecordCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
817 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]818 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]819
820 bool PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
821 const VkClearColorValue *pColor, uint32_t rangeCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]822 const VkImageSubresourceRange *pRanges) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]823 void PreCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
824 const VkClearColorValue *pColor, uint32_t rangeCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]825 const VkImageSubresourceRange *pRanges) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]826
827 bool PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
828 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]829 const VkImageSubresourceRange *pRanges) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]830 void PreCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
831 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]832 const VkImageSubresourceRange *pRanges) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]833
834 bool PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
835 uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]836 VkDeviceSize stride, VkQueryResultFlags flags) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]837 void PreCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
838 uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]839 VkQueryResultFlags flags) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]840
841 bool PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]842 uint32_t data) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]843 void PreCallRecordCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]844 uint32_t data) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]845
846 bool PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
847 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]848 const VkImageResolve *pRegions) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]849
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]850 void PreCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
851 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]852 const VkImageResolve *pRegions) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]853
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]854 bool PreCallValidateCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo) const override;
855 void PreCallRecordCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]856
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]857 bool PreCallValidateCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]858 VkDeviceSize dataSize, const void *pData) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]859 void PreCallRecordCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]860 VkDeviceSize dataSize, const void *pData) override;
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]861
862 bool PreCallValidateCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]863 VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const override;
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]864 void PreCallRecordCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]865 VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]866};