Gitiles
Code Review Sign In
gerrit.openfyde.cn / chromium.googlesource.com / external / github.com / KhronosGroup / Vulkan-ValidationLayers / 2df089125e5fa943560c1af348ba4fd0ba1a4aa8 / . / layers / synchronization_validation.h
blob: fc95de0516066e6eec577c68f3801f69f5f87fbc [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,
Mike Schuchardt2df08912020-12-15 16:28:09 -0800[diff] [blame^]504 const VkSubpassBeginInfo *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_++;
Jeremy Gebben6ea9d9e2020-12-11 09:41:01 -0700[diff] [blame]524 // The lowest bit is a sub-command number used to separate operations at the end of the previous renderpass
525 // from the start of the new one in VkCmdNextRenderpass().
526 const auto index = (static_cast<uint64_t>(reset_count_) << 33) | (command_number_ << 1) | 0;
John Zulaufcc6fecb2020-06-17 15:24:54 -0600[diff] [blame]527 ResourceUsageTag next(index, command);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]528 return next;
529 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]530
531 private:
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]532 uint32_t command_number_;
533 uint32_t reset_count_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]534 std::vector<RenderPassAccessContext> render_pass_contexts_;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]535 AccessContext cb_access_context_;
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]536 AccessContext *current_context_;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]537 RenderPassAccessContext *current_renderpass_context_;
538 std::shared_ptr<CMD_BUFFER_STATE> cb_state_;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]539 SyncValidator *sync_state_;
540
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]541 VkQueueFlags queue_flags_;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]542};
543
544class SyncValidator : public ValidationStateTracker, public SyncStageAccess {
545 public:
546 SyncValidator() { container_type = LayerObjectTypeSyncValidation; }
547 using StateTracker = ValidationStateTracker;
548
549 using StateTracker::AccessorTraitsTypes;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]550 std::unordered_map<VkCommandBuffer, std::unique_ptr<CommandBufferAccessContext>> cb_access_state;
551 CommandBufferAccessContext *GetAccessContextImpl(VkCommandBuffer command_buffer, bool do_insert) {
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]552 auto found_it = cb_access_state.find(command_buffer);
553 if (found_it == cb_access_state.end()) {
554 if (!do_insert) return nullptr;
555 // If we don't have one, make it.
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]556 auto cb_state = GetShared<CMD_BUFFER_STATE>(command_buffer);
557 assert(cb_state.get());
558 auto queue_flags = GetQueueFlags(*cb_state);
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]559 std::unique_ptr<CommandBufferAccessContext> context(new CommandBufferAccessContext(*this, cb_state, queue_flags));
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]560 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]561 found_it = insert_pair.first;
562 }
563 return found_it->second.get();
564 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]565 CommandBufferAccessContext *GetAccessContext(VkCommandBuffer command_buffer) {
566 return GetAccessContextImpl(command_buffer, true); // true -> do_insert on not found
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]567 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]568 CommandBufferAccessContext *GetAccessContextNoInsert(VkCommandBuffer command_buffer) {
569 return GetAccessContextImpl(command_buffer, false); // false -> don't do_insert on not found
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]570 }
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]571
572 const CommandBufferAccessContext *GetAccessContext(VkCommandBuffer command_buffer) const {
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]573 const auto found_it = cb_access_state.find(command_buffer);
574 if (found_it == cb_access_state.end()) {
575 return nullptr;
576 }
577 return found_it->second.get();
578 }
579
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]580 void ApplyGlobalBarriers(AccessContext *context, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]581 SyncStageAccessFlags src_stage_scope, SyncStageAccessFlags dst_stage_scope,
John Zulauf89311b42020-09-29 16:28:47 -0600[diff] [blame]582 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, const ResourceUsageTag &tag);
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]583 void ApplyBufferBarriers(AccessContext *context, VkPipelineStageFlags src_stage_mask,
584 const SyncStageAccessFlags &src_stage_scope, VkPipelineStageFlags dst_stage_mask,
585 const SyncStageAccessFlags &dst_stage_scope, uint32_t barrier_count,
John Zulauf540266b2020-04-06 18:54:53 -0600[diff] [blame]586 const VkBufferMemoryBarrier *barriers);
Jeremy Gebbend0de1f82020-11-09 08:21:07 -0700[diff] [blame]587 void ApplyImageBarriers(AccessContext *context, VkPipelineStageFlags src_stage_mask,
588 const SyncStageAccessFlags &src_stage_scope, VkPipelineStageFlags dst_stage_mask,
589 const SyncStageAccessFlags &dst_stage_scope, uint32_t barrier_count,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]590 const VkImageMemoryBarrier *barriers, const ResourceUsageTag &tag);
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]591
John Zulaufd1f85d42020-04-15 12:23:15 -0600[diff] [blame]592 void ResetCommandBufferCallback(VkCommandBuffer command_buffer);
593 void FreeCommandBufferCallback(VkCommandBuffer command_buffer);
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]594 void RecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]595 const VkSubpassBeginInfo *pSubpassBeginInfo, CMD_TYPE command);
596 void RecordCmdNextSubpass(VkCommandBuffer commandBuffer,
597
598 const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo,
599 CMD_TYPE command);
600 void RecordCmdEndRenderPass(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo, CMD_TYPE command);
John Zulauf33fc1d52020-07-17 11:01:10 -0600[diff] [blame]601 bool SupressedBoundDescriptorWAW(const HazardResult &hazard) const;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]602
603 void PostCallRecordCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]604 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, VkResult result) override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]605
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]606 bool ValidateBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Mike Schuchardt2df08912020-12-15 16:28:09 -0800[diff] [blame^]607 const VkSubpassBeginInfo *pSubpassBeginInfo, const char *func_name) const;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]608
609 bool PreCallValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]610 VkSubpassContents contents) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]611
612 bool PreCallValidateCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Mike Schuchardt2df08912020-12-15 16:28:09 -0800[diff] [blame^]613 const VkSubpassBeginInfo *pSubpassBeginInfo) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]614
615 bool PreCallValidateCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Mike Schuchardt2df08912020-12-15 16:28:09 -0800[diff] [blame^]616 const VkSubpassBeginInfo *pSubpassBeginInfo) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]617
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]618 bool PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]619 const VkBufferCopy *pRegions) const override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]620
621 void PreCallRecordCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]622 const VkBufferCopy *pRegions) override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]623
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]624 bool PreCallValidateCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfos) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]625
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]626 void PreCallRecordCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfos) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]627
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]628 bool PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
629 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]630 const VkImageCopy *pRegions) const override;
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]631
632 void PreCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]633 VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) override;
John Zulauf5c5e88d2019-12-26 11:22:02 -0700[diff] [blame]634
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]635 bool PreCallValidateCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]636
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]637 void PreCallRecordCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]638
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]639 bool PreCallValidateCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
640 VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
641 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
642 uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
643 uint32_t imageMemoryBarrierCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]644 const VkImageMemoryBarrier *pImageMemoryBarriers) const override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]645
646 void PreCallRecordCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
647 VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
648 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
649 uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]650 uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]651
652 void PostCallRecordBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]653 VkResult result) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]654
655 void PostCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]656 VkSubpassContents contents) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]657 void PostCallRecordCmdBeginRenderPass2(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 void PostCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]660 const VkSubpassBeginInfo *pSubpassBeginInfo) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]661
Mike Schuchardt2df08912020-12-15 16:28:09 -0800[diff] [blame^]662 bool ValidateCmdNextSubpass(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo,
663 const VkSubpassEndInfo *pSubpassEndInfo, const char *func_name) const;
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]664 bool PreCallValidateCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const override;
Mike Schuchardt2df08912020-12-15 16:28:09 -0800[diff] [blame^]665 bool PreCallValidateCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo,
666 const VkSubpassEndInfo *pSubpassEndInfo) const override;
667 bool PreCallValidateCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo,
668 const VkSubpassEndInfo *pSubpassEndInfo) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]669
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]670 void PostCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]671 void PostCallRecordCmdNextSubpass2(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 void PostCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]674 const VkSubpassEndInfo *pSubpassEndInfo) override;
John Zulauf3d84f1b2020-03-09 13:33:25 -0600[diff] [blame]675
Mike Schuchardt2df08912020-12-15 16:28:09 -0800[diff] [blame^]676 bool ValidateCmdEndRenderPass(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo,
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]677 const char *func_name) const;
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]678 bool PreCallValidateCmdEndRenderPass(VkCommandBuffer commandBuffer) const override;
Mike Schuchardt2df08912020-12-15 16:28:09 -0800[diff] [blame^]679 bool PreCallValidateCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const override;
680 bool PreCallValidateCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const override;
John Zulauf355e49b2020-04-24 15:11:15 -0600[diff] [blame]681
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]682 void PostCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer) override;
683 void PostCallRecordCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) override;
684 void PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]685
686 template <typename BufferImageCopyRegionType>
687 bool ValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
688 VkImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopyRegionType *pRegions,
689 CopyCommandVersion version) const;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]690 bool PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
691 VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]692 const VkBufferImageCopy *pRegions) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]693 bool PreCallValidateCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]694 const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo) const override;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]695
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]696 template <typename BufferImageCopyRegionType>
697 void RecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
698 VkImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopyRegionType *pRegions,
699 CopyCommandVersion version);
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]700 void PreCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]701 VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]702 void PreCallRecordCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]703 const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo) override;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]704
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]705 template <typename BufferImageCopyRegionType>
706 bool ValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
707 VkBuffer dstBuffer, uint32_t regionCount, const BufferImageCopyRegionType *pRegions,
708 CopyCommandVersion version) const;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]709 bool PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]710 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]711 bool PreCallValidateCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]712 const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo) const override;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]713
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]714 template <typename BufferImageCopyRegionType>
715 void RecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
716 VkBuffer dstBuffer, uint32_t regionCount, const BufferImageCopyRegionType *pRegions,
717 CopyCommandVersion version);
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]718 void PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]719 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]720 void PreCallRecordCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]721 const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]722
723 template <typename RegionType>
724 bool ValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
725 VkImageLayout dstImageLayout, uint32_t regionCount, const RegionType *pRegions, VkFilter filter,
726 const char *apiName) const;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]727
728 bool PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
729 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]730 const VkImageBlit *pRegions, VkFilter filter) const override;
731 bool PreCallValidateCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo) const override;
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]732
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]733 template <typename RegionType>
734 void RecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
735 VkImageLayout dstImageLayout, uint32_t regionCount, const RegionType *pRegions, VkFilter filter,
736 ResourceUsageTag tag);
locke-lunarga19c71d2020-03-02 18:17:04 -0700[diff] [blame]737 void PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
738 VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]739 VkFilter filter) override;
740 void PreCallRecordCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo) override;
locke-lunarg36ba2592020-04-03 09:42:04 -0600[diff] [blame]741
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]742 bool ValidateIndirectBuffer(const AccessContext &context, VkCommandBuffer commandBuffer, const VkDeviceSize struct_size,
743 const VkBuffer buffer, const VkDeviceSize offset, const uint32_t drawCount, const uint32_t stride,
744 const char *function) const;
745 void RecordIndirectBuffer(AccessContext &context, const ResourceUsageTag &tag, const VkDeviceSize struct_size,
746 const VkBuffer buffer, const VkDeviceSize offset, const uint32_t drawCount, uint32_t stride);
locke-lunarg36ba2592020-04-03 09:42:04 -0600[diff] [blame]747
locke-lunarg61870c22020-06-09 14:51:50 -0600[diff] [blame]748 bool ValidateCountBuffer(const AccessContext &context, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
749 const char *function) const;
750 void RecordCountBuffer(AccessContext &context, const ResourceUsageTag &tag, VkBuffer buffer, VkDeviceSize offset);
locke-lunarg93d68af2020-05-12 17:18:03 -0600[diff] [blame]751
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]752 bool PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) const override;
753 void PreCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]754
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]755 bool PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const override;
756 void PreCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]757
758 bool PreCallValidateCmdDraw(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) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]760 void PreCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]761 uint32_t firstInstance) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]762
763 bool PreCallValidateCmdDrawIndexed(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) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]765 void PreCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]766 uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]767
768 bool PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]769 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]770 void PreCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]771 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]772
773 bool PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]774 uint32_t drawCount, uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]775 void PreCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]776 uint32_t drawCount, uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]777
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]778 bool ValidateCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer,
779 VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride,
780 const char *function) const;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]781 bool PreCallValidateCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
782 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]783 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]784 void PreCallRecordCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
785 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]786 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]787 bool PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
788 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]789 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]790 void PreCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
791 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]792 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]793 bool PreCallValidateCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
794 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]795 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]796 void PreCallRecordCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
797 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]798 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]799
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]800 bool ValidateCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
801 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
802 uint32_t stride, const char *function) const;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]803 bool PreCallValidateCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
804 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]805 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]806 void PreCallRecordCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
807 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]808 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]809 bool PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
810 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]811 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]812 void PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
813 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]814 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]815 bool PreCallValidateCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
816 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]817 uint32_t stride) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]818 void PreCallRecordCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
819 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]820 uint32_t stride) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]821
822 bool PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
823 const VkClearColorValue *pColor, uint32_t rangeCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]824 const VkImageSubresourceRange *pRanges) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]825 void PreCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
826 const VkClearColorValue *pColor, uint32_t rangeCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]827 const VkImageSubresourceRange *pRanges) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]828
829 bool PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
830 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]831 const VkImageSubresourceRange *pRanges) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]832 void PreCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
833 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]834 const VkImageSubresourceRange *pRanges) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]835
836 bool PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
837 uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]838 VkDeviceSize stride, VkQueryResultFlags flags) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]839 void PreCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
840 uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]841 VkQueryResultFlags flags) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]842
843 bool PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]844 uint32_t data) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]845 void PreCallRecordCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]846 uint32_t data) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]847
848 bool PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
849 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]850 const VkImageResolve *pRegions) const override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]851
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]852 void PreCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
853 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]854 const VkImageResolve *pRegions) override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]855
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]856 bool PreCallValidateCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo) const override;
857 void PreCallRecordCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo) override;
Jeff Leger178b1e52020-10-05 12:22:23 -0400[diff] [blame]858
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]859 bool PreCallValidateCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]860 VkDeviceSize dataSize, const void *pData) const override;
locke-lunarge1a67022020-04-29 00:15:36 -0600[diff] [blame]861 void PreCallRecordCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]862 VkDeviceSize dataSize, const void *pData) override;
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]863
864 bool PreCallValidateCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]865 VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const override;
locke-lunargff255f92020-05-13 18:53:52 -0600[diff] [blame]866 void PreCallRecordCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
Jeremy Gebbenf8924692020-10-28 16:27:14 -0600[diff] [blame]867 VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) override;
John Zulauf9cb530d2019-09-30 14:14:10 -0600[diff] [blame]868};