1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/* Copyright (c) 2019-2022 The Khronos Group Inc.
* Copyright (c) 2019-2022 Valve Corporation
* Copyright (c) 2019-2022 LunarG, Inc.
* Copyright (C) 2019-2022 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* John Zulauf <jzulauf@lunarg.com>
*
*/
#include "image_layout_map.h"
#ifndef SPARSE_CONTAINER_UNIT_TEST
#include "image_state.h"
#include "cmd_buffer_state.h"
#endif
namespace image_layout_map {
using InitialLayoutStates = ImageSubresourceLayoutMap::InitialLayoutStates;
using LayoutEntry = ImageSubresourceLayoutMap::LayoutEntry;
template <typename LayoutsMap>
static bool UpdateLayoutStateImpl(LayoutsMap& layouts, InitialLayoutStates& initial_layout_states, const IndexRange& range,
LayoutEntry& new_entry, const CMD_BUFFER_STATE& cb_state, const IMAGE_VIEW_STATE* view_state) {
using CachedLowerBound = typename sparse_container::cached_lower_bound_impl<LayoutsMap>;
CachedLowerBound pos(layouts, range.begin);
if (!range.includes(pos->index)) {
return false;
}
bool updated_current = false;
while (range.includes(pos->index)) {
if (!pos->valid) {
// Fill in the leading space (or in the case of pos at end the trailing space
const auto start = pos->index;
auto it = pos->lower_bound;
const auto limit = (it != layouts.end()) ? std::min(it->first.begin, range.end) : range.end;
if (new_entry.state == nullptr) {
// Allocate on demand... initial_layout_states_ holds ownership, while
// each subresource has a non-owning copy of the plain pointer.
initial_layout_states.emplace_back(cb_state, view_state);
new_entry.state = &initial_layout_states.back();
}
auto insert_result = layouts.insert(it, std::make_pair(IndexRange(start, limit), new_entry));
pos.invalidate(insert_result, start);
pos.seek(limit);
updated_current = true;
}
// Note that after the "fill" operation pos may have become valid so we check again
if (pos->valid) {
auto intersected_range = pos->lower_bound->first & range;
if (!intersected_range.empty() && pos->lower_bound->second.CurrentWillChange(new_entry.current_layout)) {
LayoutEntry orig_entry = pos->lower_bound->second; // intentional copy
assert(orig_entry.state != nullptr);
updated_current |= orig_entry.Update(new_entry);
auto overwrite_result = layouts.overwrite_range(pos->lower_bound, std::make_pair(intersected_range, orig_entry));
// If we didn't cover the whole range, we'll need to go around again
pos.invalidate(overwrite_result, intersected_range.begin);
pos.seek(intersected_range.end);
} else {
// Point just past the end of this section, if it's within the given range, it will get filled next iteration
// ++pos could move us past the end of range (which would exit the loop) so we don't use it.
pos.seek(pos->lower_bound->first.end);
}
}
}
return updated_current;
}
InitialLayoutState::InitialLayoutState(const CMD_BUFFER_STATE& cb_state_, const IMAGE_VIEW_STATE* view_state_)
: image_view(VK_NULL_HANDLE), aspect_mask(0), label(cb_state_.debug_label) {
if (view_state_) {
image_view = view_state_->image_view();
aspect_mask = view_state_->normalized_subresource_range.aspectMask;
}
}
bool ImageSubresourceLayoutMap::SubresourceLayout::operator==(const ImageSubresourceLayoutMap::SubresourceLayout& rhs) const {
bool is_equal =
(current_layout == rhs.current_layout) && (initial_layout == rhs.initial_layout) && (subresource == rhs.subresource);
return is_equal;
}
ImageSubresourceLayoutMap::ImageSubresourceLayoutMap(const IMAGE_STATE& image_state)
: image_state_(image_state),
encoder_(image_state.subresource_encoder),
layouts_(encoder_.SubresourceCount()),
initial_layout_states_() {}
// Use the unwrapped maps from the BothMap in the actual implementation
template <typename LayoutMap>
static bool SetSubresourceRangeLayoutImpl(LayoutMap& layouts, InitialLayoutStates& initial_layout_states, RangeGenerator& range_gen,
const CMD_BUFFER_STATE& cb_state, VkImageLayout layout, VkImageLayout expected_layout) {
bool updated = false;
LayoutEntry entry(expected_layout, layout);
for (; range_gen->non_empty(); ++range_gen) {
updated |= UpdateLayoutStateImpl(layouts, initial_layout_states, *range_gen, entry, cb_state, nullptr);
}
return updated;
}
bool ImageSubresourceLayoutMap::SetSubresourceRangeLayout(const CMD_BUFFER_STATE& cb_state, const VkImageSubresourceRange& range,
VkImageLayout layout, VkImageLayout expected_layout) {
if (expected_layout == kInvalidLayout) {
// Set the initial layout to the set layout as we had no other layout to reference
expected_layout = layout;
}
if (!InRange(range)) return false; // Don't even try to track bogus subreources
RangeGenerator range_gen(encoder_, range);
if (layouts_.SmallMode()) {
return SetSubresourceRangeLayoutImpl(layouts_.GetSmallMap(), initial_layout_states_, range_gen, cb_state, layout,
expected_layout);
} else {
assert(!layouts_.Tristate());
return SetSubresourceRangeLayoutImpl(layouts_.GetBigMap(), initial_layout_states_, range_gen, cb_state, layout,
expected_layout);
}
}
// Use the unwrapped maps from the BothMap in the actual implementation
template <typename LayoutMap>
static void SetSubresourceRangeInitialLayoutImpl(LayoutMap& layouts, InitialLayoutStates& initial_layout_states,
RangeGenerator& range_gen, const CMD_BUFFER_STATE& cb_state, VkImageLayout layout,
const IMAGE_VIEW_STATE* view_state) {
LayoutEntry entry(layout);
for (; range_gen->non_empty(); ++range_gen) {
UpdateLayoutStateImpl(layouts, initial_layout_states, *range_gen, entry, cb_state, view_state);
}
}
// Unwrap the BothMaps entry here as this is a performance hotspot.
void ImageSubresourceLayoutMap::SetSubresourceRangeInitialLayout(const CMD_BUFFER_STATE& cb_state,
const VkImageSubresourceRange& range, VkImageLayout layout) {
if (!InRange(range)) return; // Don't even try to track bogus subreources
RangeGenerator range_gen(encoder_, range);
if (layouts_.SmallMode()) {
SetSubresourceRangeInitialLayoutImpl(layouts_.GetSmallMap(), initial_layout_states_, range_gen, cb_state, layout, nullptr);
} else {
assert(!layouts_.Tristate());
SetSubresourceRangeInitialLayoutImpl(layouts_.GetBigMap(), initial_layout_states_, range_gen, cb_state, layout, nullptr);
}
}
// Unwrap the BothMaps entry here as this is a performance hotspot.
void ImageSubresourceLayoutMap::SetSubresourceRangeInitialLayout(const CMD_BUFFER_STATE& cb_state, VkImageLayout layout,
const IMAGE_VIEW_STATE& view_state) {
RangeGenerator range_gen(view_state.range_generator);
if (layouts_.SmallMode()) {
SetSubresourceRangeInitialLayoutImpl(layouts_.GetSmallMap(), initial_layout_states_, range_gen, cb_state, layout,
&view_state);
} else {
assert(!layouts_.Tristate());
SetSubresourceRangeInitialLayoutImpl(layouts_.GetBigMap(), initial_layout_states_, range_gen, cb_state, layout,
&view_state);
}
}
// Saves an encode to fetch both in the same call
const ImageSubresourceLayoutMap::LayoutEntry* ImageSubresourceLayoutMap::GetSubresourceLayouts(
const VkImageSubresource& subresource) const {
IndexType index = encoder_.Encode(subresource);
auto found = layouts_.find(index);
if (found != layouts_.end()) {
return &found->second;
}
return nullptr;
}
// TODO: make sure this paranoia check is sufficient and not too much.
uintptr_t ImageSubresourceLayoutMap::CompatibilityKey() const {
return (reinterpret_cast<uintptr_t>(&image_state_) ^ encoder_.AspectMask());
}
bool ImageSubresourceLayoutMap::UpdateFrom(const ImageSubresourceLayoutMap& other) {
// Must be from matching images for the reinterpret cast to be valid
assert(CompatibilityKey() == other.CompatibilityKey());
if (CompatibilityKey() != other.CompatibilityKey()) return false;
// NOTE -- we are copying plain state pointers from 'other' which owns them in a vector. This works because
// currently this function is only used to import from secondary command buffers, destruction of which
// invalidate the referencing primary command buffer, meaning that the dangling pointer will either be
// cleaned up in invalidation, on not referenced by validation code.
return sparse_container::splice(layouts_, other.layouts_, LayoutEntry::Updater());
}
} // namespace image_layout_map
|
