/* Copyright (c) 2019-2023 The Khronos Group Inc. * Copyright (c) 2019-2023 Valve Corporation * Copyright (c) 2019-2023 LunarG, Inc. * Copyright (C) 2019-2023 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 * */ #include "state_tracker/image_layout_map.h" #ifndef SPARSE_CONTAINER_UNIT_TEST #include "state_tracker/image_state.h" #include "state_tracker/cmd_buffer_state.h" #endif namespace image_layout_map { using InitialLayoutStates = ImageSubresourceLayoutMap::InitialLayoutStates; using LayoutEntry = ImageSubresourceLayoutMap::LayoutEntry; template 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; 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 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 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); } } // TODO: make sure this paranoia check is sufficient and not too much. uintptr_t ImageSubresourceLayoutMap::CompatibilityKey() const { return (reinterpret_cast(&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