From 5c05c81123354e6b75a49d5e17d7688c548c338d Mon Sep 17 00:00:00 2001 From: jmm Date: Sat, 13 Sep 2025 20:13:07 +0800 Subject: [PATCH] mosaic screen bugfix Signed-off-by: jmm --- .../hetero_hdr/rs_hetero_hdr_buffer_layer.cpp | 9 +- .../hdr/hetero_hdr/rs_hetero_hdr_manager.cpp | 5 +- .../render_thread/rs_uni_render_engine.cpp | 1 - .../render_thread/rs_uni_render_util.cpp | 4 +- .../hetero_hdr/rs_hdr_pattern_manager.h | 80 ++++++++++++------ .../include/hetero_hdr/rs_hdr_vulkan_task.h | 3 +- .../src/hetero_hdr/rs_hdr_pattern_manager.cpp | 22 +++++ .../src/hetero_hdr/rs_hdr_vulkan_task.cpp | 22 ++++- .../ohos/backend/rs_surface_ohos_vulkan.cpp | 4 +- .../ohos/backend/rs_vulkan_context.cpp | 5 +- .../rs_hdr_pattern_manager_test.cpp | 82 +++++++++++++++++++ 11 files changed, 191 insertions(+), 46 deletions(-) diff --git a/rosen/modules/render_service/core/feature/hdr/hetero_hdr/rs_hetero_hdr_buffer_layer.cpp b/rosen/modules/render_service/core/feature/hdr/hetero_hdr/rs_hetero_hdr_buffer_layer.cpp index 92efb98745..377a0561b1 100644 --- a/rosen/modules/render_service/core/feature/hdr/hetero_hdr/rs_hetero_hdr_buffer_layer.cpp +++ b/rosen/modules/render_service/core/feature/hdr/hetero_hdr/rs_hetero_hdr_buffer_layer.cpp @@ -37,7 +37,7 @@ namespace OHOS { namespace Rosen { namespace { -const uint32_t BUFFER_SIZE = 2; +const uint32_t BUFFER_SIZE = 3; const uint32_t STRIDE_ALIGNMENT = 0x8; const std::string HPAE_HETERO_BUFFER_TAG = "hpae_memory_hdrhetero"; } @@ -118,13 +118,13 @@ sptr RSHeteroHDRBufferLayer::PrepareHDRDstBuffer(RSSurfaceRenderP void RSHeteroHDRBufferLayer::ConsumeAndUpdateBuffer() { + // The log information related to the failure has been printed within the function. + ReleaseBuffer(); if (surfaceHandler_ == nullptr) { RS_LOGE("[hdrHetero]:RSHeteroHDRBufferLayer ConsumeAndUpdateBuffer surfaceHandler is nullptr"); return; } RSBaseRenderUtil::ConsumeAndUpdateBuffer(*surfaceHandler_); - // The log information related to the failure has been printed within the function. - ReleaseBuffer(); } sptr RSHeteroHDRBufferLayer::RequestSurfaceBuffer( @@ -209,9 +209,6 @@ bool RSHeteroHDRBufferLayer::ReleaseBuffer() RS_LOGE("[hdrHetero]:RSHeteroHDRBufferLayer ReleaseBuffer surfaceHandler ReleaseBuffer failed"); return false; } - // reset prevBuffer if we release it successfully, - // to avoid releasing the same buffer next frame in some situations. - surfaceHandler_->ResetPreBuffer(!RSSystemProperties::GetVKImageUseEnabled()); } return true; } diff --git a/rosen/modules/render_service/core/feature/hdr/hetero_hdr/rs_hetero_hdr_manager.cpp b/rosen/modules/render_service/core/feature/hdr/hetero_hdr/rs_hetero_hdr_manager.cpp index 479198d752..d9048bec4f 100644 --- a/rosen/modules/render_service/core/feature/hdr/hetero_hdr/rs_hetero_hdr_manager.cpp +++ b/rosen/modules/render_service/core/feature/hdr/hetero_hdr/rs_hetero_hdr_manager.cpp @@ -34,7 +34,7 @@ namespace Rosen { namespace { constexpr float DEGAMMA = 1.0f / 2.2f; constexpr float GAMMA2_2 = 2.2f; -constexpr int GRAPH_NUM = 2; +constexpr int GRAPH_NUM = 3; constexpr int MAX_RELEASE_FRAME_NUM = 5; constexpr float RATIO_CHANGE_TH = 0.02f; } @@ -542,6 +542,7 @@ bool RSHeteroHDRManager::UpdateHDRHeteroParams(RSPaintFilterCanvas& canvas, RS_LOGE("[hdrHetero]:RSHeteroHDRManager UpdateHDRHeteroParams hdrSurfaceHandler is nullptr"); return false; } + rsHeteroHDRBufferLayer_.ReleaseBuffer(); bool invalidBuffer = !RSBaseRenderUtil::ConsumeAndUpdateBuffer(*hdrSurfaceHandler, CONSUME_DIRECTLY, false, 0) || !hdrSurfaceHandler->GetBuffer(); @@ -549,7 +550,7 @@ bool RSHeteroHDRManager::UpdateHDRHeteroParams(RSPaintFilterCanvas& canvas, RS_LOGE("[hdrHetero]:RSHeteroHDRManager UpdateHDRHeteroParams ConsumeAndUpdateBuffer or GetBuffer failed"); return false; } - RSHDRPatternManager::Instance().SetThreadId(); + RSHDRPatternManager::Instance().SetThreadId(canvas); ProcessParamsUpdate(canvas, surfaceDrawable, drawableParams); RS_LOGD("[hdrHetero]:RSHeteroHDRManager UpdateHDRHeteroParams done"); diff --git a/rosen/modules/render_service/core/pipeline/render_thread/rs_uni_render_engine.cpp b/rosen/modules/render_service/core/pipeline/render_thread/rs_uni_render_engine.cpp index d84f8cfe3b..5d91c3ba16 100644 --- a/rosen/modules/render_service/core/pipeline/render_thread/rs_uni_render_engine.cpp +++ b/rosen/modules/render_service/core/pipeline/render_thread/rs_uni_render_engine.cpp @@ -57,7 +57,6 @@ void RSUniRenderEngine::DrawSurfaceNodeWithParams(RSPaintFilterCanvas& canvas, std::shared_ptr hdrSurfaceHandler = RSHeteroHDRManager::Instance().GetHDRSurfaceHandler(); RegisterDeleteBufferListener(hdrSurfaceHandler->GetConsumer()); DrawImage(canvas, params); - RSHeteroHDRManager::Instance().ReleaseBuffer(); } else { RegisterDeleteBufferListener(surfaceDrawable.GetConsumerOnDraw()); #ifdef RS_ENABLE_TV_PQ_METADATA diff --git a/rosen/modules/render_service/core/pipeline/render_thread/rs_uni_render_util.cpp b/rosen/modules/render_service/core/pipeline/render_thread/rs_uni_render_util.cpp index 6477e177f0..7d867ee933 100644 --- a/rosen/modules/render_service/core/pipeline/render_thread/rs_uni_render_util.cpp +++ b/rosen/modules/render_service/core/pipeline/render_thread/rs_uni_render_util.cpp @@ -1082,9 +1082,7 @@ void RSUniRenderUtil::OptimizedFlushAndSubmit(std::shared_ptr& surface->Flush(&drawingFlushInfo); grContext->Submit(); DestroySemaphoreInfo::DestroySemaphore(destroyInfo); - for (auto frameId : frameIdVec) { - RSHDRVulkanTask::SubmitWaitEventToGPU(frameId); - } + RSHDRPatternManager::Instance().MHCClearGPUTaskFunc(); } else { surface->FlushAndSubmit(true); } diff --git a/rosen/modules/render_service_base/include/hetero_hdr/rs_hdr_pattern_manager.h b/rosen/modules/render_service_base/include/hetero_hdr/rs_hdr_pattern_manager.h index bf4b064826..2bca43d01a 100644 --- a/rosen/modules/render_service_base/include/hetero_hdr/rs_hdr_pattern_manager.h +++ b/rosen/modules/render_service_base/include/hetero_hdr/rs_hdr_pattern_manager.h @@ -23,6 +23,8 @@ #include #include "common/rs_common_def.h" #include "common/rs_macros.h" +#include "hetero_hdr/rs_hdr_vulkan_task.h" +#include "pipeline/rs_paint_filter_canvas.h" #include "platform/common/rs_log.h" #include "rs_trace.h" @@ -77,20 +79,7 @@ public: RSHDRPatternManager& operator=(const RSHDRPatternManager&) = delete; RSHDRPatternManager& operator=(RSHDRPatternManager&&) = delete; - void SetThreadId() - { -#ifdef ROSEN_OHOS - std::unique_lock lock(frameIdMutex_); - if (processConsumed_) { - return; - } - if (flushedBuffer_) { // one HDR buffer can be consumed only once - flushedBuffer_ = false; - processConsumed_ = true; - tid_ = gettid(); - } -#endif - } + void SetThreadId(RSPaintFilterCanvas& canvas); void SetBufferFlushed() { @@ -138,8 +127,6 @@ public: bool MHCCheck(const std::string logTag); - std::vector MHCGetFrameIdForGPUTask(); - bool MHCSetCurFrameId(uint64_t frameId) { std::unique_lock lock(frameIdMutex_); @@ -167,7 +154,53 @@ public: std::unique_lock lock(frameIdMutex_); vsyncId_ = frameId; } -protected: + + bool MHCCheckWaitSemaphoreSet(uint64_t frameId) + { + std::unique_lock lock(frameIdMutex_); + auto it = waitSemaphoreSet_.find(frameId); + if (it != waitSemaphoreSet_.end()) { + waitSemaphoreSet_.erase(it); + return true; + } + return false; + } + + std::vector MHCGetFrameIdForGPUTask(); + + void MHCRegisterSubmitGPUFunc(void* key, std::function func) + { + std::unique_lock lock(funcMutex_); + submitFuncs_[key] = func; + } + + void MHCSubmitGPUTask(std::vector keys) + { + std::unique_lock lock(funcMutex_); + for (auto key : keys) { + auto it = submitFuncs_.find(key); + if (it != submitFuncs_.end()) { + auto func = it->second; + func(); + submitFuncs_.erase(it); + } + } + } + + void MHCClearGPUTaskFunc() + { + std::unique_lock lock(funcMutex_); + if (!submitFuncs_.empty) { + for (auto it = submitFuncs_.begin; it != submitFuncs_.end; it++) { + auto func = it->second; + func(); + } + RS_LOGW("[hdrHetero]:RSHDRPatternManager MHCClearGPUTaskFunc submitFuncs_ is not empty"); + submitFuncs_.clear(); + } + } + +private: RSHDRPatternManager(); ~RSHDRPatternManager(); @@ -182,16 +215,6 @@ protected: #endif } - bool MHCCheckIsFirstFrame() - { - return (curFrameIdUsed_ == false) && (lastFrameIdUsed_ == true); - } - - bool MHCCheckIsNextFrame() - { - return lastFrameIdUsed_ == false; - } - #ifdef ROSEN_OHOS void* MHCLibFrameworkHandle_ = nullptr; #endif @@ -208,6 +231,9 @@ protected: bool lastFrameIdUsed_ = true; uint64_t vsyncId_ = 0; bool isFinishDLOpen_ = false; + std::set waitSemaphoreSet_{}; + std::mutex = funcMutex_; + std::unordered_map> submitFuncs_{}; }; } // namespace Rosen } // namespace OHOS diff --git a/rosen/modules/render_service_base/include/hetero_hdr/rs_hdr_vulkan_task.h b/rosen/modules/render_service_base/include/hetero_hdr/rs_hdr_vulkan_task.h index 3f30c89d6f..9f77139aad 100644 --- a/rosen/modules/render_service_base/include/hetero_hdr/rs_hdr_vulkan_task.h +++ b/rosen/modules/render_service_base/include/hetero_hdr/rs_hdr_vulkan_task.h @@ -32,11 +32,12 @@ namespace Rosen { class RSB_EXPORT RSHDRVulkanTask { public: - static void InsertHTSWaitSemaphore(std::shared_ptr& surfaceDrawing, uint64_t frameId); + static void InsertHTSWaitSemaphore(Drawing::Surface* surfaceDrawing, uint64_t frameId); static bool GetHTSNotifySemaphore(std::shared_ptr& notifySemaphore, uint64_t frameId); static void SubmitWaitEventToGPU(uint64_t frameId); static void PrepareHDRSemaphoreVector(std::vector& semaphoreVec, std::shared_ptr& surface, std::vector& frameIdVec); + static std::vector GetWaitSemaphoreKeys(VkSubmitInfo* pSubmits); private: RSHDRVulkanTask() = default; diff --git a/rosen/modules/render_service_base/src/hetero_hdr/rs_hdr_pattern_manager.cpp b/rosen/modules/render_service_base/src/hetero_hdr/rs_hdr_pattern_manager.cpp index 606e88cc92..61cddee8c3 100644 --- a/rosen/modules/render_service_base/src/hetero_hdr/rs_hdr_pattern_manager.cpp +++ b/rosen/modules/render_service_base/src/hetero_hdr/rs_hdr_pattern_manager.cpp @@ -266,6 +266,28 @@ bool RSHDRPatternManager::MHCReleaseAll() return true; } +void SetThreadId(RSPaintFilterCanvas& canvas); +{ +#ifdef ROSEN_OHOS +#ifdef RS_ENABLE_VK + std::unique_lock lock(frameIdMutex_); + if (processConsumed_) { + return; + } + if (flushedBuffer_ && !curFrameIdUsed_) { // one HDR buffer can be consumed only once + flushedBuffer_ = false; + processConsumed_ = true; + tid_ = gettid(); + if (curFrameId_ != 0) { + auto drawingSurface = canvas.GetSurface(); + RSHDRVulkanTask::InsertHTSWaitSemaphore(drawingSurface, curFrameId_); + waitSemaphoreSet_.insert(curFrameId_); + } + } +#endif // RS_ENABLE_VK +#endif // ROSEN_OHOS +} + std::vector RSHDRPatternManager::MHCGetFrameIdForGPUTask() { std::vector frameIdVec{}; diff --git a/rosen/modules/render_service_base/src/hetero_hdr/rs_hdr_vulkan_task.cpp b/rosen/modules/render_service_base/src/hetero_hdr/rs_hdr_vulkan_task.cpp index 1b9f5c4b89..ddd535059e 100644 --- a/rosen/modules/render_service_base/src/hetero_hdr/rs_hdr_vulkan_task.cpp +++ b/rosen/modules/render_service_base/src/hetero_hdr/rs_hdr_vulkan_task.cpp @@ -27,7 +27,7 @@ std::unordered_map> g_semaphoreMap{}; std::mutex g_vulkanTaskMutex; } -void RSHDRVulkanTask::InsertHTSWaitSemaphore(std::shared_ptr& surfaceDrawing, uint64_t frameId) +void RSHDRVulkanTask::InsertHTSWaitSemaphore(Drawing::Surface* surfaceDrawing, uint64_t frameId) { auto MHCEventId = RSHDRPatternManager::Instance().MHCGetVulkanTaskWaitEvent(frameId, MHC_PATTERN_TASK_HDR_GPU); if (MHCEventId == 0) { @@ -53,7 +53,10 @@ void RSHDRVulkanTask::InsertHTSWaitSemaphore(std::shared_ptr& RS_LOGE("[hdrHetero]:RSHDRVulkanTask InsertHTSWaitSemaphore waitSemaphore create failed"); return; } + void* key = (void*)waitSemaphore; surfaceDrawing->Wait(1, waitSemaphore); // 2D Engine will destroy semaphore + std::function func = [frameId]() { RSHDRVulkanTask::SubmitWaitEventToGPU(frameId); }; + RSHDRPatternManager::Instance().MHCRegisterSubmitGPUFunc(key, func); } bool RSHDRVulkanTask::GetHTSNotifySemaphore(std::shared_ptr& notifySemaphore, uint64_t frameId) @@ -117,8 +120,23 @@ void RSHDRVulkanTask::PrepareHDRSemaphoreVector(std::vector& #endif semaphoreVec.emplace_back(std::move(htsSemaphore)); } - RSHDRVulkanTask::InsertHTSWaitSemaphore(surface, frameId); + if (!RSHDRPatternManager.Instance().MHCCheckWaitSemaphoreSet(frameId)) { + RSHDRVulkanTask::InsertHTSWaitSemaphore(surface.get(), frameId); + } + } +} + +std::vector RSHDRVulkanTask::GetWaitSemaphoreKeys(VkSubmitInfo* pSubmits) +{ + std::vector keys{}; + if (!pSubmits || pSubmits->waitSemaphoreCount == 0 || !pSubmits->pWaitSemaphores) { + RS_LOGE("[hdrHetero]:RSHDRVulkanTask GetWaitSemaphoreKeys invalid parameters"); + return keys; + } + for (uint32_t i = 0; i < pSubmits->waitSemaphoreCount; i++) { + keys.push_back(pSubmits->pWaitSemaphores[i]); } + return keys; } } // namespace Rosen } // namespace OHOS diff --git a/rosen/modules/render_service_base/src/platform/ohos/backend/rs_surface_ohos_vulkan.cpp b/rosen/modules/render_service_base/src/platform/ohos/backend/rs_surface_ohos_vulkan.cpp index 81a9341ccd..63afc0da63 100644 --- a/rosen/modules/render_service_base/src/platform/ohos/backend/rs_surface_ohos_vulkan.cpp +++ b/rosen/modules/render_service_base/src/platform/ohos/backend/rs_surface_ohos_vulkan.cpp @@ -563,9 +563,7 @@ bool RSSurfaceOhosVulkan::FlushFrame(std::unique_ptr& frame, uin mSkContext->Submit(); mSkContext->EndFrame(); } - for (auto frameId : frameIdVec) { - RSHDRVulkanTask::SubmitWaitEventToGPU(frameId); - } + RSHDRPatternManager::Instance().MHCClearGPUTaskFunc(); int fenceFd = -1; if (mReservedFlushFd != -1) { diff --git a/rosen/modules/render_service_base/src/platform/ohos/backend/rs_vulkan_context.cpp b/rosen/modules/render_service_base/src/platform/ohos/backend/rs_vulkan_context.cpp index ee2c540545..91fd4ac345 100644 --- a/rosen/modules/render_service_base/src/platform/ohos/backend/rs_vulkan_context.cpp +++ b/rosen/modules/render_service_base/src/platform/ohos/backend/rs_vulkan_context.cpp @@ -879,7 +879,10 @@ VKAPI_ATTR VkResult RsVulkanContext::HookedVkQueueSubmit(VkQueue queue, uint32_t std::lock_guard lock(vkInterface.graphicsQueueMutex_); RS_LOGD("%{public}s queue", __func__); RS_OPTIONAL_TRACE_NAME_FMT("%s queue", __func__); - return vkInterface.vkQueueSubmit(queue, submitCount, pSubmits, fence); + VkResult ret = vkInterface.vkQueueSubmit(queue, submitCount, pSubmits, fence); + std::vector keys = RSHDRVulkanTask::GetWaitSemaphoreKeys(pSubmits); + RSHDRPatternManager::Instance().MHCSubmitGPUTask(keys); + return ret; } RS_LOGE("%{public}s abnormal queue occured", __func__); return VK_ERROR_UNKNOWN; diff --git a/rosen/test/render_service/render_service/unittest/feature/hetero_hdr/rs_hdr_pattern_manager_test.cpp b/rosen/test/render_service/render_service/unittest/feature/hetero_hdr/rs_hdr_pattern_manager_test.cpp index 2d91800573..516e1bcd49 100644 --- a/rosen/test/render_service/render_service/unittest/feature/hetero_hdr/rs_hdr_pattern_manager_test.cpp +++ b/rosen/test/render_service/render_service/unittest/feature/hetero_hdr/rs_hdr_pattern_manager_test.cpp @@ -379,6 +379,58 @@ HWTEST_F(RSHDRPatternManagerTest, MHCDlsymInvalidTest, TestSize.Level1) EXPECT_EQ(ret, true); } +/** + * @tc.name: SetThreadIdTest + * @tc.desc: etThreadId + * @tc.type: FUNC + * @tc.require: + */ + HWTEST_F(RSHDRPatternManagerTest, SetThreadIdTest, TestSize.Level1) + { + Drawing::Canvas drawingCanvas; + RSPaintFilterCanvas canvas(&drawingCanvas); + MHCDevice_->graphPatternRequestEGraph = nullptr; + auto tempSet = SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_; + SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_.clear(); + + // test 1 + SingletonMockRSHDRPatternManager::Instance().processConsumed_ = true; + SingletonMockRSHDRPatternManager::Instance().SetThreadId(canvas); + EXPECT_EQ(SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_.size(), 0); + + // test 2 + SingletonMockRSHDRPatternManager::Instance().processConsumed_ = false; + SingletonMockRSHDRPatternManager::Instance().flushedBuffer_ = false; + SingletonMockRSHDRPatternManager::Instance().SetThreadId(canvas); + EXPECT_EQ(SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_.size(), 0); + + // test 3 + SingletonMockRSHDRPatternManager::Instance().processConsumed_ = false; + SingletonMockRSHDRPatternManager::Instance().flushedBuffer_ = true; + SingletonMockRSHDRPatternManager::Instance().curFrameIdUsed_ = false; + SingletonMockRSHDRPatternManager::Instance().curFrameId_ = 0; + SingletonMockRSHDRPatternManager::Instance().SetThreadId(canvas); + EXPECT_EQ(SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_.size(), 0); + + // test 4 + SingletonMockRSHDRPatternManager::Instance().processConsumed_ = false; + SingletonMockRSHDRPatternManager::Instance().flushedBuffer_ = true; + SingletonMockRSHDRPatternManager::Instance().curFrameIdUsed_ = true; + SingletonMockRSHDRPatternManager::Instance().curFrameId_ = 0; + SingletonMockRSHDRPatternManager::Instance().SetThreadId(canvas); + EXPECT_EQ(SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_.size(), 0); + + // test 5 + SingletonMockRSHDRPatternManager::Instance().processConsumed_ = false; + SingletonMockRSHDRPatternManager::Instance().flushedBuffer_ = true; + SingletonMockRSHDRPatternManager::Instance().curFrameIdUsed_ = false; + SingletonMockRSHDRPatternManager::Instance().curFrameId_ = 1; + SingletonMockRSHDRPatternManager::Instance().SetThreadId(canvas); + EXPECT_EQ(SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_.size(), 1); + + SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_ = tempSet; + } + /** * @tc.name: MHCGetFrameIdForGPUTaskTest_Branch1 * @tc.desc: Test MHCGetFrameIdForGPUTask branch 1 scenarios @@ -512,8 +564,38 @@ HWTEST_F(RSHDRPatternManagerTest, PrepareHDRSemaphoreVectorTest, TestSize.Level1 std::vector semaphoreVec = {backendSemaphore}; RSHDRVulkanTask::PrepareHDRSemaphoreVector(semaphoreVec, surface, frameIdVec); + auto waitSemaphoreSetTemp = SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_; + SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_.clear(); + // MHCCheckWaitSemaphoreSet false + std::vector semaphoreVec2 = {backendSemaphore}; + RSHDRVulkanTask::PrepareHDRSemaphoreVector(semaphoreVec2, surface, frameIdVec); + // MHCCheckWaitSemaphoreSet true + uint64_t frameId1 = 1; + std::vector semaphoreVec3 = {backendSemaphore}; + SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_.insert(frameId1); + RSHDRVulkanTask::PrepareHDRSemaphoreVector(semaphoreVec3, surface, frameIdVec); + SingletonMockRSHDRPatternManager::Instance().waitSemaphoreSet_. = waitSemaphoreSetTemp; + uint64_t frameId = 0; RSHDRVulkanTask::SubmitWaitEventToGPU(frameId); } +/** + * @tc.name: GetWaitSemaphoreKeysTest + * @tc.desc: Test GetWaitSemaphoreKeys + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(RSHDRPatternManagerTest, GetWaitSemaphoreKeysTest, TestSize.Level1) +{ + VkSubmitInfo* submitInfo = nullptr; + auto ret = RSHDRVulkanTask::GetWaitSemaphoreKeys(submitInfo); + EXPECT_EQ(ret.size(), 0); + + VkSubmitInfo* submitInfo1 = new VkSubmitInfo(); + submitInfo1->waitSemaphoreCount = 1; + submitInfo1->pWaitSemaphores = nullptr; + auto ret1 = RSHDRVulkanTask::GetWaitSemaphoreKeys(submitInfo1); + EXPECT_EQ(ret1.size(), 0); +} } // namespace OHOS::Rosen \ No newline at end of file -- Gitee