1 /* 2 * Copyright (c) 2022 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_SERVICE_CORE_PIPELINE_PARALLEL_RENDER_RS_PARALLEL_RENDER_MANAGER_H 17 #define RENDER_SERVICE_CORE_PIPELINE_PARALLEL_RENDER_RS_PARALLEL_RENDER_MANAGER_H 18 19 #include <condition_variable> 20 #include <cstdint> 21 #include <map> 22 #include <memory> 23 #include <mutex> 24 #include <vector> 25 #include "EGL/egl.h" 26 #ifdef NEW_RENDER_CONTEXT 27 #include "render_context_base.h" 28 #endif 29 #include "rs_parallel_hardware_composer.h" 30 #include "rs_parallel_sub_thread.h" 31 #include "rs_parallel_pack_visitor.h" 32 #include "rs_parallel_task_manager.h" 33 #include "pipeline/parallel_render/rs_render_task.h" 34 #include "pipeline/rs_base_render_engine.h" 35 #include "pipeline/rs_base_render_node.h" 36 #include "common/rs_rect.h" 37 #include "common/rs_vector4.h" 38 39 namespace OHOS { 40 namespace Rosen { 41 class RSUniRenderVisitor; 42 class RSSurfaceRenderNode; 43 class RSDisplayRenderNode; 44 45 enum class ParallelRenderType { 46 DRAW_IMAGE = 0, 47 FLUSH_ONE_BUFFER 48 }; 49 50 enum class ParallelStatus { 51 OFF = 0, 52 ON, 53 FIRSTFLUSH, 54 WAITFIRSTFLUSH 55 }; 56 57 enum class TaskType { 58 PREPARE_TASK = 0, 59 PROCESS_TASK, 60 CALC_COST_TASK, 61 COMPOSITION_TASK 62 }; 63 64 class RSParallelRenderManager { 65 public: 66 static RSParallelRenderManager *Instance(); 67 void SetParallelMode(bool parallelMode); 68 bool GetParallelMode() const; 69 bool GetParallelModeSafe() const; 70 #ifdef NEW_RENDER_CONTEXT 71 void StartSubRenderThread(uint32_t threadNum, std::shared_ptr<RenderContextBase> context, 72 std::shared_ptr<DrawingContext> drawingContext); 73 #else 74 void StartSubRenderThread(uint32_t threadNum, RenderContext *context); 75 #endif 76 void EndSubRenderThread(); 77 void CopyVisitorAndPackTask(RSUniRenderVisitor &visitor, RSDisplayRenderNode &node); 78 void CopyPrepareVisitorAndPackTask(RSUniRenderVisitor &visitor, RSDisplayRenderNode &node); 79 void CopyCalcCostVisitorAndPackTask(RSUniRenderVisitor &visitor, RSDisplayRenderNode &node, bool isNeedCalc, 80 bool doAnimate, bool isOpDropped); 81 void PackRenderTask(RSSurfaceRenderNode &node, TaskType type = TaskType::PROCESS_TASK); 82 void PackParallelCompositionTask(std::shared_ptr<RSNodeVisitor> visitor, 83 const std::shared_ptr<RSBaseRenderNode> node); 84 void LoadBalanceAndNotify(TaskType type = TaskType::PROCESS_TASK); 85 void MergeRenderResult(RSPaintFilterCanvas& canvas); 86 void SetFrameSize(int width, int height); 87 void GetFrameSize(int &width, int &height) const; 88 void SubmitSuperTask(uint32_t taskIndex, std::unique_ptr<RSSuperRenderTask> superRenderTask); 89 void SubmitCompositionTask(uint32_t taskIndex, std::unique_ptr<RSCompositionTask> compositionTask); 90 void SubMainThreadNotify(int threadIndex); 91 void WaitSubMainThread(uint32_t threadIndex); 92 void SubMainThreadWait(uint32_t threadIndex); 93 void WaitCalcCostEnd(); 94 void WaitCompositionEnd(); 95 void UpdateNodeCost(RSDisplayRenderNode& node); 96 bool IsNeedCalcCost() const; 97 int32_t GetCost(RSRenderNode &node) const; 98 int32_t GetSelfDrawNodeCost() const; 99 void StartTiming(uint32_t subMainThreadIdx); 100 void StopTimingAndSetRenderTaskCost( 101 uint32_t subMainThreadIdx, uint64_t loadId, TaskType type = TaskType::PROCESS_TASK); 102 bool ParallelRenderExtEnabled(); 103 void TryEnableParallelRendering(); 104 void ReadySubThreadNumIncrement(); 105 void CommitSurfaceNum(int surfaceNum); 106 void WaitPrepareEnd(RSUniRenderVisitor &visitor); 107 TaskType GetTaskType() const; GetUniVisitor()108 RSUniRenderVisitor* GetUniVisitor() const 109 { 110 return uniVisitor_; 111 } 112 GetUniParallelCompositionVisitor()113 std::shared_ptr<RSUniRenderVisitor> GetUniParallelCompositionVisitor() const 114 { 115 return uniParallelCompositionVisitor_; 116 } 117 IsDoAnimate()118 bool IsDoAnimate() const 119 { 120 return doAnimate_; 121 } 122 IsOpDropped()123 bool IsOpDropped() const 124 { 125 return isOpDropped_; 126 } 127 IsSecurityDisplay()128 bool IsSecurityDisplay() const 129 { 130 return isSecurityDisplay_; 131 } 132 133 ParallelStatus GetParallelRenderingStatus() const; 134 void WorkSerialTask(RSSurfaceRenderNode &node); LockFlushMutex()135 void LockFlushMutex() 136 { 137 flushMutex_.lock(); 138 } UnlockFlushMutex()139 void UnlockFlushMutex() 140 { 141 flushMutex_.unlock(); 142 } 143 uint32_t GetParallelThreadNumber() const; 144 void AddSelfDrawingSurface(unsigned int subThreadIndex, bool isRRect, RectF rect, 145 Vector4f cornerRadius = {0.f, 0.f, 0.f, 0.f}); 146 void ClearSelfDrawingSurface(RSPaintFilterCanvas& canvas, unsigned int subThreadIndex); 147 void AddAppWindowNode(uint32_t surfaceIndex, std::shared_ptr<RSSurfaceRenderNode> appNode); GetAppWindowNodes()148 const std::map<uint32_t, std::vector<std::shared_ptr<RSSurfaceRenderNode>>>& GetAppWindowNodes() const 149 { 150 return appWindowNodesMap_; 151 } 152 153 // Use for Vulkan 154 void WaitProcessEnd(); 155 void InitDisplayNodeAndRequestFrame( 156 const std::shared_ptr<RSBaseRenderEngine> renderEngine, const ScreenInfo screenInfo); 157 void ProcessParallelDisplaySurface(RSUniRenderVisitor &visitor); 158 void ReleaseBuffer(); 159 void NotifyUniRenderFinish(); 160 std::shared_ptr<RSDisplayRenderNode> GetParallelDisplayNode(uint32_t subMainThreadIdx); 161 std::unique_ptr<RSRenderFrame> GetParallelFrame(uint32_t subMainThreadIdx); SetFilterSurfaceRenderNode(RSSurfaceRenderNode & node)162 void SetFilterSurfaceRenderNode(RSSurfaceRenderNode& node) 163 { 164 filterSurfaceRenderNodes_.push_back(node.ReinterpretCastTo<RSSurfaceRenderNode>()); 165 } ClearFilterSurfaceRenderNode()166 void ClearFilterSurfaceRenderNode() 167 { 168 std::vector<std::shared_ptr<RSSurfaceRenderNode>>().swap(filterSurfaceRenderNodes_); 169 } GetFilterSurfaceRenderNodeCount()170 uint32_t GetFilterSurfaceRenderNodeCount() 171 { 172 return filterSurfaceRenderNodes_.size(); 173 } 174 void ProcessFilterSurfaceRenderNode(); 175 176 private: 177 RSParallelRenderManager(); 178 ~RSParallelRenderManager() = default; 179 RSParallelRenderManager(const RSParallelRenderManager &) = delete; 180 RSParallelRenderManager(const RSParallelRenderManager &&) = delete; 181 RSParallelRenderManager &operator = (const RSParallelRenderManager &) = delete; 182 RSParallelRenderManager &operator = (const RSParallelRenderManager &&) = delete; 183 void DrawImageMergeFunc(RSPaintFilterCanvas& canvas); 184 void FlushOneBufferFunc(); 185 void GetCostFactor(); 186 void InitAppWindowNodeMap(); 187 #ifdef USE_ROSEN_DRAWING 188 bool DrawImageMergeFuncForRosenDrawing(RSPaintFilterCanvas& canvas, std::shared_ptr<Drawing::Image> texture); 189 #endif 190 std::shared_ptr<RSParallelPackVisitor> packVisitor_; 191 std::shared_ptr<RSParallelPackVisitor> packVisitorPrepare_; 192 std::shared_ptr<RSParallelPackVisitor> calcCostVisitor_; 193 std::vector<std::unique_ptr<RSParallelSubThread>> threadList_; 194 RSParallelTaskManager processTaskManager_; 195 RSParallelTaskManager prepareTaskManager_; 196 RSParallelTaskManager calcCostTaskManager_; 197 RSParallelTaskManager compositionTaskManager_; 198 int width_ = 0; 199 int height_ = 0; 200 std::vector<uint8_t> flipCoin_; 201 std::mutex parallelRenderMutex_; 202 std::mutex cvParallelRenderMutex_; 203 std::mutex flushMutex_; 204 std::condition_variable cvParallelRender_; 205 #ifdef NEW_RENDER_CONTEXT 206 std::shared_ptr<RenderContextBase> renderContext_ = nullptr; 207 std::shared_ptr<DrawingContext> drawingContext_ = nullptr; 208 #else 209 RenderContext* renderContext_ = nullptr; 210 #endif 211 ParallelRenderType renderType_ = ParallelRenderType::DRAW_IMAGE; 212 std::shared_ptr<RSBaseRenderNode> displayNode_ = nullptr; 213 std::shared_ptr<RSDisplayRenderNode> mainDisplayNode_ = nullptr; 214 std::shared_ptr<RSBaseRenderNode> baseNode_ = nullptr; 215 216 uint32_t expectedSubThreadNum_ = 0; 217 std::atomic<uint32_t> readySubThreadNum_ = 0; 218 bool firstFlush_ = false; 219 bool parallelMode_ = false; 220 RSUniRenderVisitor *uniVisitor_ = nullptr; 221 std::shared_ptr<RSUniRenderVisitor> uniParallelCompositionVisitor_ = nullptr; 222 TaskType taskType_; 223 std::unique_ptr<RSParallelHardwareComposer> parallelHardwareComposer_; 224 std::map<uint32_t, std::vector<std::shared_ptr<RSSurfaceRenderNode>>> appWindowNodesMap_; 225 226 std::vector<uint32_t> parallelPolicy_; 227 int32_t calcCostCount_ = 0; 228 std::map<std::string, int32_t> costFactor_; 229 std::map<int64_t, int32_t> imageFactor_; 230 231 bool doAnimate_ = false; 232 bool isOpDropped_ = false; 233 bool isSecurityDisplay_ = false; 234 235 std::vector<timespec> startTime_; 236 std::vector<timespec> stopTime_; 237 238 // Use for Vulkan 239 std::vector<std::shared_ptr<RSDisplayRenderNode>> parallelDisplayNodes_; 240 std::vector<std::shared_ptr<RSDisplayRenderNode>> backParallelDisplayNodes_; 241 std::vector<std::unique_ptr<RSRenderFrame>> parallelFrames_; 242 int readyBufferNum_ = 0; 243 std::vector<std::shared_ptr<RSSurfaceRenderNode>> filterSurfaceRenderNodes_; 244 }; 245 } // namespace Rosen 246 } // namespace OHOS 247 #endif // RENDER_SERVICE_CORE_PIPELINE_PARALLEL_RENDER_RS_PARALLEL_RENDER_MANAGER_H