1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "render_node_graph_share_manager.h"
17
18 #include <cstdint>
19
20 #include <base/math/mathf.h>
21 #include <render/namespace.h>
22
23 #include "device/gpu_resource_handle_util.h"
24 #include "util/log.h"
25
26 using namespace BASE_NS;
27
RENDER_BEGIN_NAMESPACE()28 RENDER_BEGIN_NAMESPACE()
29 RenderNodeGraphShareDataManager::RenderNodeGraphShareDataManager() {}
30
BeginFrame(const uint32_t renderNodeCount,const array_view<const RenderHandle> inputs,const array_view<const RenderHandle> outputs)31 void RenderNodeGraphShareDataManager::BeginFrame(const uint32_t renderNodeCount,
32 const array_view<const RenderHandle> inputs, const array_view<const RenderHandle> outputs)
33 {
34 lockedAccess_ = false;
35
36 // copy / clear all
37 inOut_ = {};
38 inOut_.inputView = { inOut_.inputs, inputs.size() };
39 inOut_.outputView = { inOut_.outputs, outputs.size() };
40 for (size_t idx = 0; idx < inOut_.inputView.size(); ++idx) {
41 inOut_.inputView[idx] = inputs[idx];
42 }
43 for (size_t idx = 0; idx < inOut_.outputView.size(); ++idx) {
44 inOut_.outputView[idx] = outputs[idx];
45 }
46
47 renderNodeResources_.resize(renderNodeCount);
48
49 // clear only view to gpu resource handles
50 for (auto& rnRef : renderNodeResources_) {
51 rnRef.outputs.clear();
52 }
53 }
54
PrepareExecuteFrame()55 void RenderNodeGraphShareDataManager::PrepareExecuteFrame()
56 {
57 lockedAccess_ = true;
58 }
59
RegisterRenderNodeGraphOutputs(const array_view<const RenderHandle> outputs)60 void RenderNodeGraphShareDataManager::RegisterRenderNodeGraphOutputs(const array_view<const RenderHandle> outputs)
61 {
62 if (lockedAccess_) {
63 #if (RENDER_VALIDATION_ENABLED == 1)
64 PLUGIN_LOG_W("RENDER_VALIDATION: render node graph outputs cannot be registered in ExecuteFrame()");
65 #endif
66 return;
67 }
68
69 inOut_.outputView = {};
70 inOut_.outputView = { inOut_.outputs, outputs.size() };
71 for (size_t idx = 0; idx < inOut_.outputView.size(); ++idx) {
72 inOut_.outputView[idx] = outputs[idx];
73 }
74 }
75
RegisterRenderNodeOutput(const uint32_t renderNodeIdx,const string_view name,const RenderHandle & handle)76 void RenderNodeGraphShareDataManager::RegisterRenderNodeOutput(
77 const uint32_t renderNodeIdx, const string_view name, const RenderHandle& handle)
78 {
79 if (lockedAccess_) {
80 #if (RENDER_VALIDATION_ENABLED == 1)
81 PLUGIN_LOG_ONCE_W(
82 "RegisterRenderNodeOutput_val", "RENDER_VALIDATION: outputs cannot be registered in ExecuteFrame()");
83 #endif
84 return; // early out
85 }
86
87 PLUGIN_ASSERT(renderNodeIdx < static_cast<uint32_t>(renderNodeResources_.size()));
88 auto& rnRef = renderNodeResources_[renderNodeIdx];
89 if (rnRef.outputs.size() >= MAX_RENDER_NODE_GRAPH_RES_COUNT) {
90 #if (RENDER_VALIDATION_ENABLED == 1)
91 PLUGIN_LOG_ONCE_W("RegisterRenderNodeOutput_valcount", "RENDER_VALIDATION: only %u outputs supported",
92 MAX_RENDER_NODE_GRAPH_RES_COUNT);
93 #endif
94 return; // early out
95 }
96
97 if (RenderHandleUtil::IsValid(handle)) {
98 rnRef.outputs.emplace_back(Resource { string(name), handle });
99 } else {
100 #if (RENDER_VALIDATION_ENABLED == 1)
101 PLUGIN_LOG_ONCE_W(string(rnRef.name + name) + string("_invha"),
102 "RENDER_VALIDATION: invalid handle registered as render node output (name: %s) (render node name: %s)",
103 name.data(), rnRef.name.data());
104 #endif
105 }
106 }
107
RegisterRenderNodeName(const uint32_t renderNodeIdx,const string_view name)108 void RenderNodeGraphShareDataManager::RegisterRenderNodeName(const uint32_t renderNodeIdx, const string_view name)
109 {
110 PLUGIN_ASSERT(renderNodeIdx < static_cast<uint32_t>(renderNodeResources_.size()));
111 renderNodeResources_[renderNodeIdx].name = name;
112 }
113
GetRenderNodeGraphInputs() const114 array_view<const RenderHandle> RenderNodeGraphShareDataManager::GetRenderNodeGraphInputs() const
115 {
116 return inOut_.inputView;
117 }
118
GetRenderNodeGraphOutputs() const119 array_view<const RenderHandle> RenderNodeGraphShareDataManager::GetRenderNodeGraphOutputs() const
120 {
121 return inOut_.outputView;
122 }
123
GetRenderNodeOutputs(const uint32_t renderNodeIdx) const124 array_view<const RenderNodeGraphShareDataManager::Resource> RenderNodeGraphShareDataManager::GetRenderNodeOutputs(
125 const uint32_t renderNodeIdx) const
126 {
127 if (renderNodeIdx < static_cast<uint32_t>(renderNodeResources_.size())) {
128 return renderNodeResources_[renderNodeIdx].outputs;
129 }
130 return {};
131 }
132
GetRenderNodeIndex(const string_view renderNodeName) const133 uint32_t RenderNodeGraphShareDataManager::GetRenderNodeIndex(const string_view renderNodeName) const
134 {
135 for (uint32_t idx = 0; idx < static_cast<uint32_t>(renderNodeResources_.size()); ++idx) {
136 if (renderNodeName == renderNodeResources_[idx].name.data()) {
137 return idx;
138 }
139 }
140 return ~0u;
141 }
142
RenderNodeGraphShareManager(RenderNodeGraphShareDataManager & renderNodeGraphShareDataMgr)143 RenderNodeGraphShareManager::RenderNodeGraphShareManager(RenderNodeGraphShareDataManager& renderNodeGraphShareDataMgr)
144 : renderNodeGraphShareDataMgr_(renderNodeGraphShareDataMgr)
145 {}
146
147 RenderNodeGraphShareManager::~RenderNodeGraphShareManager() = default;
148
Init(const uint32_t renderNodeIdx,const string_view name)149 void RenderNodeGraphShareManager::Init(const uint32_t renderNodeIdx, const string_view name)
150 {
151 renderNodeIdx_ = renderNodeIdx;
152 renderNodeGraphShareDataMgr_.RegisterRenderNodeName(renderNodeIdx_, name);
153 }
154
BeginFrame(const uint32_t renderNodeIdx)155 void RenderNodeGraphShareManager::BeginFrame(const uint32_t renderNodeIdx)
156 {
157 renderNodeIdx_ = renderNodeIdx;
158 }
159
GetRenderNodeGraphInputs() const160 array_view<const RenderHandle> RenderNodeGraphShareManager::GetRenderNodeGraphInputs() const
161 {
162 return renderNodeGraphShareDataMgr_.GetRenderNodeGraphInputs();
163 }
164
GetRenderNodeGraphOutputs() const165 array_view<const RenderHandle> RenderNodeGraphShareManager::GetRenderNodeGraphOutputs() const
166 {
167 return renderNodeGraphShareDataMgr_.GetRenderNodeGraphOutputs();
168 }
169
GetRenderNodeGraphInput(const uint32_t index) const170 RenderHandle RenderNodeGraphShareManager::GetRenderNodeGraphInput(const uint32_t index) const
171 {
172 const auto& ref = renderNodeGraphShareDataMgr_.GetRenderNodeGraphInputs();
173 return (index < ref.size()) ? ref[index] : RenderHandle {};
174 }
175
GetRenderNodeGraphOutput(const uint32_t index) const176 RenderHandle RenderNodeGraphShareManager::GetRenderNodeGraphOutput(const uint32_t index) const
177 {
178 const auto& ref = renderNodeGraphShareDataMgr_.GetRenderNodeGraphOutputs();
179 return (index < ref.size()) ? ref[index] : RenderHandle {};
180 }
181
RegisterRenderNodeGraphOutputs(const array_view<const RenderHandle> outputHandles)182 void RenderNodeGraphShareManager::RegisterRenderNodeGraphOutputs(const array_view<const RenderHandle> outputHandles)
183 {
184 #if (RENDER_VALIDATION_ENABLED == 1)
185 if (outputHandles.size() > RenderNodeGraphShareDataManager::MAX_RENDER_NODE_GRAPH_RES_COUNT) {
186 PLUGIN_LOG_W("RENDER_VALIDATION: render node tries to register %u render node graph outputs (max count: %u)",
187 RenderNodeGraphShareDataManager::MAX_RENDER_NODE_GRAPH_RES_COUNT,
188 static_cast<uint32_t>(outputHandles.size()));
189 }
190 #endif
191 renderNodeGraphShareDataMgr_.RegisterRenderNodeGraphOutputs(outputHandles);
192 }
193
RegisterRenderNodeOutputs(const array_view<const RenderHandle> outputs)194 void RenderNodeGraphShareManager::RegisterRenderNodeOutputs(const array_view<const RenderHandle> outputs)
195 {
196 #if (RENDER_VALIDATION_ENABLED == 1)
197 if (outputs.size() > RenderNodeGraphShareDataManager::MAX_RENDER_NODE_GRAPH_RES_COUNT) {
198 PLUGIN_LOG_W("RENDER_VALIDATION: render node tries to register %u outputs (max count: %u)",
199 static_cast<uint32_t>(outputs.size()), RenderNodeGraphShareDataManager::MAX_RENDER_NODE_GRAPH_RES_COUNT);
200 }
201 #endif
202 for (const auto& ref : outputs) {
203 renderNodeGraphShareDataMgr_.RegisterRenderNodeOutput(renderNodeIdx_, {}, ref);
204 }
205 }
206
RegisterRenderNodeOutput(const string_view name,const RenderHandle & handle)207 void RenderNodeGraphShareManager::RegisterRenderNodeOutput(const string_view name, const RenderHandle& handle)
208 {
209 renderNodeGraphShareDataMgr_.RegisterRenderNodeOutput(renderNodeIdx_, name, handle);
210 }
211
GetRegisteredRenderNodeOutput(const string_view renderNodeName,const uint32_t index) const212 RenderHandle RenderNodeGraphShareManager::GetRegisteredRenderNodeOutput(
213 const string_view renderNodeName, const uint32_t index) const
214 {
215 const uint32_t rnIdx = renderNodeGraphShareDataMgr_.GetRenderNodeIndex(renderNodeName);
216 const auto& ref = renderNodeGraphShareDataMgr_.GetRenderNodeOutputs(rnIdx);
217 return (index < ref.size()) ? ref[index].handle : RenderHandle {};
218 }
219
GetRegisteredRenderNodeOutput(const string_view renderNodeName,const string_view resourceName) const220 RenderHandle RenderNodeGraphShareManager::GetRegisteredRenderNodeOutput(
221 const string_view renderNodeName, const string_view resourceName) const
222 {
223 const uint32_t rnIdx = renderNodeGraphShareDataMgr_.GetRenderNodeIndex(renderNodeName);
224 const auto& ref = renderNodeGraphShareDataMgr_.GetRenderNodeOutputs(rnIdx);
225 // check for name from the resources
226 for (const auto& r : ref) {
227 if (r.name == resourceName) {
228 return r.handle;
229 }
230 }
231 return RenderHandle {};
232 }
233
GetRegisteredPrevRenderNodeOutput(const uint32_t index) const234 RenderHandle RenderNodeGraphShareManager::GetRegisteredPrevRenderNodeOutput(const uint32_t index) const
235 {
236 const uint32_t rnIdx = renderNodeIdx_ - 1u;
237 const auto& ref = renderNodeGraphShareDataMgr_.GetRenderNodeOutputs(rnIdx);
238 return (index < ref.size()) ? ref[index].handle : RenderHandle {};
239 }
240 RENDER_END_NAMESPACE()
241