Blender V5.3
vk_scheduler.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <sstream>
10
11#include "vk_render_graph.hh"
12#include "vk_scheduler.hh"
13
14#include "BLI_index_range.hh"
15#include "BLI_set.hh"
16
18
20{
21 result_.clear();
22 for (NodeHandle node_handle : render_graph.nodes_.index_range()) {
23 result_.append(node_handle);
24 }
25 reorder_nodes(render_graph);
26 return result_;
27}
28
29/* -------------------------------------------------------------------- */
32
33void VKScheduler::reorder_nodes(const VKRenderGraph &render_graph)
34{
35 move_initial_transfer_to_start(render_graph);
36 move_transfer_and_dispatch_outside_rendering_scope(render_graph);
37}
38
39std::optional<std::pair<int64_t, int64_t>> VKScheduler::find_rendering_scope(
40 const VKRenderGraph &render_graph, IndexRange search_range) const
41{
42 int64_t rendering_start = -1;
43
44 for (int64_t index : search_range) {
45 NodeHandle node_handle = result_[index];
46 const VKRenderGraphNode &node = render_graph.nodes_[node_handle];
48 rendering_start = index;
49 }
50 if (node.type == VKNodeType::END_RENDERING && rendering_start != -1) {
51 return std::pair(rendering_start, index);
52 }
53 }
54 /* When using VK_EXT_dynamic_rendering_local_read, rendering scopes can be suspended and
55 * resumed without explicit END_RENDERING (see VKFrameBuffer::subpass_transition_impl).
56 * This can leave a BEGIN_RENDERING node without a matching END_RENDERING at the end of
57 * the search range. Orphaned nodes don't need reordering.
58 * When NOT using local read, an unmatched BEGIN_RENDERING is a bug. */
59 BLI_assert(rendering_start == -1 || render_graph.resources_.use_dynamic_rendering_local_read);
60 return std::nullopt;
61}
62
64
65/* -------------------------------------------------------------------- */
68
69void VKScheduler::move_initial_transfer_to_start(const VKRenderGraph &render_graph)
70{
71 Vector<NodeHandle> data_transfers;
72 Vector<NodeHandle> other_nodes;
73
74 data_transfers.reserve(result_.size());
75 other_nodes.reserve(result_.size());
76
77 for (const int64_t index : result_.index_range()) {
78 NodeHandle node_handle = result_[index];
79 const VKRenderGraphNode &node = render_graph.nodes_[node_handle];
80 Span<VKRenderGraphBuffer> node_buffers = render_graph.linked_buffers(node);
81 Span<VKRenderGraphImage> node_images = render_graph.linked_images(node);
83 if (node_buffers[0].resource.stamp == 0 && node_buffers[1].resource.stamp == 0) {
84 data_transfers.append(index);
85 continue;
86 }
87 }
89 if (node_buffers[0].resource.stamp == 0 && node_images[0].resource.stamp == 0) {
90 data_transfers.append(index);
91 continue;
92 }
93 }
95 if (node_buffers[0].resource.stamp == 0) {
96 data_transfers.append(index);
97 continue;
98 }
99 }
100
101 other_nodes.append(index);
102 }
103
104 MutableSpan<NodeHandle> store_data_transfers = result_.as_mutable_span().slice(
105 0, data_transfers.size());
106 MutableSpan<NodeHandle> store_other = result_.as_mutable_span().slice(data_transfers.size(),
107 other_nodes.size());
108 store_data_transfers.copy_from(data_transfers);
109 store_other.copy_from(other_nodes);
110}
111
113
114/* -------------------------------------------------------------------- */
117
118void VKScheduler::move_transfer_and_dispatch_outside_rendering_scope(
119 const VKRenderGraph &render_graph)
120{
121 Vector<NodeHandle> pre_rendering_scope;
122 Vector<NodeHandle> rendering_scope;
123 Set<ResourceHandle> used_buffers;
124
125 foreach_rendering_scope(render_graph, [&](int64_t start_index, int64_t end_index) {
126 /* Move end_rendering right after the last graphics node. */
127 for (int index = end_index - 1; index >= start_index; index--) {
128 NodeHandle node_handle = result_[index];
129 const VKRenderGraphNode &node = render_graph.nodes_[node_handle];
130 if (node_type_is_rendering(node.type)) {
131 break;
132 }
133 std::swap(result_[end_index], result_[index]);
134 end_index -= 1;
135 }
136
137 /* Move begin_rendering right before the first graphics node. */
138 for (int index = start_index + 1; index < end_index; index++) {
139 NodeHandle node_handle = result_[index];
140 const VKRenderGraphNode &node = render_graph.nodes_[node_handle];
141 if (node_type_is_rendering(node.type)) {
142 break;
143 }
144 std::swap(result_[start_index], result_[index]);
145 start_index += 1;
146 }
147
148 /* Move buffer update buffer commands to before the rendering scope, unless the buffer is
149 * already being used by a draw command. Images modification could also be moved outside the
150 * rendering scope, but it is more tricky as they could also be attached to the frame-buffer.
151 */
152 pre_rendering_scope.clear();
153 rendering_scope.clear();
154 used_buffers.clear();
155
156 for (int index = start_index + 1; index < end_index; index++) {
157 NodeHandle node_handle = result_[index];
158 const VKRenderGraphNode &node = render_graph.nodes_[node_handle];
159 /* Should we add this node to the rendering scope. This is only done when we need to reorder
160 * nodes. In that case the rendering_scope has already an item and we should add this node to
161 * or the rendering scope or before the rendering scope. Adding nodes before rendering scope
162 * is done in the VKNodeType::UPDATE_BUFFER branch. */
163 bool add_to_rendering_scope = !rendering_scope.is_empty();
164 if (node.type == VKNodeType::UPDATE_BUFFER) {
165 /* Checking the node links to reduce potential locking the resource mutex. */
166 if (!used_buffers.contains(
167 render_graph.links_.buffers[node.links.buffers.start()].resource.handle))
168 {
169 /* Buffer isn't used by this rendering scope so we can safely move it before the
170 * rendering scope begins. */
171 pre_rendering_scope.append(node_handle);
172 add_to_rendering_scope = false;
173 /* When this is the first time we move a node before the rendering we should start
174 * building up the rendering scope as well. This is postponed so we can safe some cycles
175 * when no nodes needs to be moved at all. */
176 if (rendering_scope.is_empty()) {
177 rendering_scope.extend(Span<NodeHandle>(&result_[start_index], index - start_index));
178 }
179 }
180 }
181 if (add_to_rendering_scope) {
182 /* When rendering scope has an item we are rewriting the execution order and need to track
183 * what should be inside the rendering scope. */
184 rendering_scope.append(node_handle);
185 }
186
187 /* Any read/write to buffer resources should be added to used_buffers in order to detect if
188 * it is safe to move a node before the rendering scope. */
189 for (const VKRenderGraphBuffer &link : render_graph.linked_buffers(node)) {
190 used_buffers.add(link.resource.handle);
191 }
192 }
193
194 /* When pre_rendering_scope has an item we want to rewrite the order.
195 * The number of nodes are not changed, so we can do this inline. */
196 if (!pre_rendering_scope.is_empty()) {
197 MutableSpan<NodeHandle> store_none_rendering = result_.as_mutable_span().slice(
198 start_index, pre_rendering_scope.size());
199 MutableSpan<NodeHandle> store_rendering = result_.as_mutable_span().slice(
200 start_index + pre_rendering_scope.size(), rendering_scope.size());
201 store_none_rendering.copy_from(pre_rendering_scope);
202 store_rendering.copy_from(rendering_scope);
203 start_index += pre_rendering_scope.size();
204 }
205 });
206}
207
209
210/* -------------------------------------------------------------------- */
213
214void VKScheduler::debug_print(const VKRenderGraph &render_graph) const
215{
216 std::stringstream ss;
217 int indent = 0;
218
219 for (int index : result_.index_range()) {
220 const NodeHandle node_handle = result_[index];
221 const VKRenderGraphNode &node = render_graph.nodes_[node_handle];
222 if (node.type == VKNodeType::END_RENDERING) {
223 indent--;
224 }
225 for (int i = 0; i < indent; i++) {
226 ss << " ";
227 }
228 ss << node.type << "\n";
229#if 0
230 render_graph.debug_print(node_handle);
231#endif
232 if (node.type == VKNodeType::BEGIN_RENDERING) {
233 indent++;
234 }
235 }
236 ss << "\n";
237
238 std::cout << ss.str();
239}
240
242
243} // namespace blender::gpu::render_graph
#define BLI_assert(a)
#define ELEM(...)
Span< NodeHandle > select_nodes(const VKRenderGraph &render_graph)
#define index(i)
BLI_INLINE bool node_type_is_rendering(VKNodeType node_type)
__int64 int64_t
Definition BKE_text.h:90