1 /*
2  * Copyright (c) 2024 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 #ifndef RENDER_RENDER__RENDER_NODE_GRAPH_MANAGER_H
17 #define RENDER_RENDER__RENDER_NODE_GRAPH_MANAGER_H
18 
19 #include <cstdint>
20 #include <mutex>
21 
22 #include <base/containers/string.h>
23 #include <base/containers/unique_ptr.h>
24 #include <base/containers/vector.h>
25 #include <core/namespace.h>
26 #include <render/namespace.h>
27 #include <render/nodecontext/intf_render_node_graph_manager.h>
28 #include <render/resource_handle.h>
29 
30 #include "nodecontext/render_node_graph_node_store.h"
31 #include "resource_handle_impl.h"
32 
33 CORE_BEGIN_NAMESPACE()
34 class IFileManager;
35 CORE_END_NAMESPACE()
36 
37 RENDER_BEGIN_NAMESPACE()
38 class Device;
39 class RenderNodeManager;
40 class RenderNodeGraphLoader;
41 
42 /**
43 RenderDataManager class.
44 Implementation for render data manager class.
45 */
46 class RenderNodeGraphManager final : public IRenderNodeGraphManager {
47 public:
48     RenderNodeGraphManager(Device& device, CORE_NS::IFileManager& fileMgr);
49     ~RenderNodeGraphManager() override;
50 
51     RenderNodeGraphManager(const RenderNodeGraphManager&) = delete;
52     RenderNodeGraphManager& operator=(const RenderNodeGraphManager&) = delete;
53 
54     RenderHandleReference Get(const RenderHandle& handle) const override;
55     RenderHandleReference Create(const RenderNodeGraphUsageType usage, const RenderNodeGraphDesc& desc,
56         const BASE_NS::string_view renderNodeGraphName,
57         const BASE_NS::string_view renderNodeGraphDataStoreName) override;
58     RenderHandleReference Create(const RenderNodeGraphUsageType usage, const RenderNodeGraphDesc& desc,
59         const BASE_NS::string_view renderNodeGraphName) override;
60     RenderHandleReference Create(const RenderNodeGraphUsageType usage, const RenderNodeGraphDesc& desc) override;
61 
62     // should be called once per frame for destruction of old render node graphs,
63     // and for inserting or erasing individual render nodes
64     void HandlePendingAllocations();
65 
66     void PushBackRenderNode(const RenderHandleReference& handle, const RenderNodeDesc& renderNodeDesc) override;
67     void EraseRenderNode(const RenderHandleReference& handle, const BASE_NS::string_view renderNodeName) override;
68     void InsertBeforeRenderNode(const RenderHandleReference& handle, const RenderNodeDesc& renderNodeDesc,
69         const BASE_NS::string_view renderNodeName) override;
70     void InsertAfterRenderNode(const RenderHandleReference& handle, const RenderNodeDesc& renderNodeDesc,
71         const BASE_NS::string_view renderNodeName) override;
72     void UpdateRenderNodeGraph(
73         const RenderHandleReference& handle, const RenderNodeGraphDescInfo& graphDescInfo) override;
74     RenderNodeGraphDescInfo GetInfo(const RenderHandleReference& handle) const override;
75     void SetRenderNodeGraphResources(const RenderHandleReference& handle,
76         const BASE_NS::array_view<const RenderHandleReference> inputs,
77         const BASE_NS::array_view<const RenderHandleReference> outputs) override;
78     RenderNodeGraphResourceInfo GetRenderNodeGraphResources(const RenderHandleReference& handle) const override;
79 
80     RenderNodeGraphNodeStore* Get(RenderHandle handle);
81 
82     RenderHandleReference LoadAndCreate(const RenderNodeGraphUsageType usage, const BASE_NS::string_view uri) override;
83     IRenderNodeGraphLoader& GetRenderNodeGraphLoader() override;
84 
85     RenderNodeManager& GetRenderNodeManager() const;
86 
87     void Destroy(BASE_NS::string_view typeName);
88 
89 private:
90     // not locked inside (needs to be locked from outside)
91     void Destroy(const RenderHandle handle);
92 
93     struct PendingRenderNodeGraph {
94         enum class Type : uint8_t {
95             ALLOC = 0,
96             DEALLOC = 1,
97         };
98         Type type { Type::ALLOC };
99 
100         RenderHandle renderNodeGraphHandle;
101         BASE_NS::fixed_string<RenderDataConstants::MAX_DEFAULT_NAME_LENGTH> renderNodeGraphName;
102         BASE_NS::fixed_string<RenderDataConstants::MAX_DEFAULT_NAME_LENGTH> renderNodeGraphDataStoreName;
103         BASE_NS::fixed_string<RenderDataConstants::MAX_DEFAULT_NAME_LENGTH> renderNodeGraphUri;
104         RenderNodeGraphDesc renderNodeGraphDesc;
105         RenderNodeGraphUsageType usageType { RenderNodeGraphUsageType::RENDER_NODE_GRAPH_STATIC };
106     };
107     // If individual nodes are insert or erased, we need a pending destruction
108     struct PendingRenderNode {
109         enum class Type : uint8_t {
110             ALLOC = 0,
111             DEALLOC = 1,
112         };
113         enum class PosType : uint8_t {
114             BACK = 0,
115             BEFORE = 1,
116             AFTER = 2,
117         };
118         Type type { Type::ALLOC };
119 
120         RenderHandle renderNodeGraphHandle;
121         RenderNodeDesc renderNodeDesc;
122 
123         PosType posType { PosType::BACK };
124         RenderDataConstants::RenderDataFixedString renderNodeName;
125     };
126     struct PendingRenderNodeGraphDestruction {
127         uint64_t frameIndex { 0u };
128         BASE_NS::vector<RenderNodeContextData> renderNodeGraphContextData;
129     };
130     // If individual nodes are erased, we need a pending destruction
131     struct PendingRenderNodeDestruction {
132         uint64_t frameIndex { 0u };
133         RenderNodeContextData renderNodeContextData;
134     };
135 
136     void DynamicRenderNodeOpImpl(const RenderHandle handle, const RenderNodeDesc& renderNodeDesc,
137         const PendingRenderNode::Type type, const PendingRenderNode::PosType posType,
138         BASE_NS::string_view renderNodeName);
139 
140     // needs to be locked when called
141     void PendingCreate(const PendingRenderNodeGraph& renderNodeGraph);
142     void PendingDestroy(const RenderHandle nodeGraphHandle);
143     void PendingAllocRenderNode(const RenderHandle nodeGraphHandle, const PendingRenderNode& pendingNode);
144     void PendingDeallocRenderNode(const RenderHandle nodeGraphHandle, const BASE_NS::string_view renderNodeName);
145     void UpdateRenderNodeGraphResources();
146 
147     Device& device_;
148     BASE_NS::unique_ptr<RenderNodeManager> renderNodeMgr_;
149     BASE_NS::unique_ptr<RenderNodeGraphLoader> renderNodeGraphLoader_;
150 
151     BASE_NS::vector<BASE_NS::unique_ptr<RenderNodeGraphNodeStore>> nodeGraphData_;
152     BASE_NS::vector<RenderHandleReference> nodeGraphHandles_;
153     // client-side
154     struct RenderNodeGraphShareHandles {
155         RenderHandleReference inputs[RenderNodeGraphShareData::MAX_RENDER_NODE_GRAPH_RES_COUNT] { {}, {}, {}, {} };
156         RenderHandleReference outputs[RenderNodeGraphShareData::MAX_RENDER_NODE_GRAPH_RES_COUNT] { {}, {}, {}, {} };
157         uint32_t inputCount { 0 };
158         uint32_t outputCount { 0 };
159     };
160     BASE_NS::vector<RenderNodeGraphShareHandles> nodeGraphShareData_;
161 
162     BASE_NS::vector<uint64_t> availableHandleIds_;
163 
164     BASE_NS::vector<PendingRenderNodeGraphDestruction> pendingRenderNodeGraphDestructions_;
165     BASE_NS::vector<PendingRenderNodeDestruction> pendingRenderNodeDestructions_;
166     BASE_NS::vector<PendingRenderNodeGraph> pendingRenderNodeGraphs_;
167     BASE_NS::vector<PendingRenderNode> pendingRenderNodes_;
168 
169     // mutex for all owned data
170     mutable std::mutex mutex_;
171 };
172 RENDER_END_NAMESPACE()
173 
174 #endif // CORE__RENDER__RENDER_NODE_GRAPH_MANAGER_H
175