From b8b1144af5b695038e0f21d39c7a9df1f779c206 Mon Sep 17 00:00:00 2001 From: Eunki Hong Date: Wed, 9 Aug 2023 22:09:34 +0900 Subject: [PATCH] Allow worker thread trace + Trace during image works Let we add trace marker during image load & apply masking. It will be helpful when we detect performance bottleneck. Change-Id: I3c629a6b018cdb6bb5e700a8809557e8475fd1cf Signed-off-by: Eunki Hong --- .../dali-toolkit-test-utils/toolkit-adaptor.cpp | 146 ++++++++++++--------- .../controls/gl-view/gl-view-render-thread.cpp | 4 +- .../controls/gl-view/gl-view-render-thread.h | 15 ++- .../image-loader/fast-track-loading-task.cpp | 34 +++++ .../internal/image-loader/loading-task.cpp | 38 +++++- .../vector-animation-task.cpp | 23 ++++ .../vector-animation-thread.cpp | 6 +- .../vector-animation-thread.h | 3 + dali-toolkit/internal/visuals/svg/svg-task.cpp | 23 ++++ 9 files changed, 222 insertions(+), 70 deletions(-) diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp index 8f3095f..ca52b18 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2023 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,21 +24,19 @@ #include #include -#include -#include #include #include #include +#include +#include #include namespace Dali { - namespace Internal { namespace Adaptor { - /////////////////////////////////////////////////////////////////////////////// // // Dali::Internal::Adaptor::Adaptor Stub @@ -49,14 +47,14 @@ Dali::Adaptor* gAdaptor = nullptr; Dali::Adaptor& Adaptor::New() { - DALI_ASSERT_ALWAYS( ! gAdaptor ); + DALI_ASSERT_ALWAYS(!gAdaptor); gAdaptor = new Dali::Adaptor; return *gAdaptor; } Dali::Adaptor& Adaptor::Get() { - DALI_ASSERT_ALWAYS( gAdaptor ); + DALI_ASSERT_ALWAYS(gAdaptor); return *gAdaptor; } @@ -69,33 +67,32 @@ Adaptor::~Adaptor() gAdaptor = nullptr; } -void Adaptor::Start( Dali::Window window ) +void Adaptor::Start(Dali::Window window) { - AddWindow( &GetImplementation( window ) ); + AddWindow(&GetImplementation(window)); } -Integration::Scene Adaptor::GetScene( Dali::Window window ) +Integration::Scene Adaptor::GetScene(Dali::Window window) { return window.GetScene(); } -bool Adaptor::AddIdle( CallbackBase* callback, bool hasReturnValue ) +bool Adaptor::AddIdle(CallbackBase* callback, bool hasReturnValue) { - mCallbacks.PushBack( callback ); + mCallbacks.PushBack(callback); return true; } -void Adaptor::RemoveIdle( CallbackBase* callback ) +void Adaptor::RemoveIdle(CallbackBase* callback) { - mCallbacks.Erase( std::find_if( mCallbacks.Begin(), mCallbacks.End(), - [ &callback ] ( CallbackBase* current ) { return callback == current; } ) ); + mCallbacks.Erase(std::find_if(mCallbacks.Begin(), mCallbacks.End(), [&callback](CallbackBase* current) { return callback == current; })); } void Adaptor::RunIdles() { - for( auto& callback : mCallbacks ) + for(auto& callback : mCallbacks) { - CallbackBase::Execute( *callback ); + CallbackBase::Execute(*callback); } mCallbacks.Clear(); @@ -103,22 +100,22 @@ void Adaptor::RunIdles() Dali::RenderSurfaceInterface& Adaptor::GetSurface() { - DALI_ASSERT_ALWAYS( ! mWindows.empty() ); + DALI_ASSERT_ALWAYS(!mWindows.empty()); - return reinterpret_cast < Dali::RenderSurfaceInterface& >( mWindows.front()->GetRenderSurface() ); + return reinterpret_cast(mWindows.front()->GetRenderSurface()); } Dali::WindowContainer Adaptor::GetWindows() { Dali::WindowContainer windows; - for ( auto iter = mWindows.begin(); iter != mWindows.end(); ++iter ) + for(auto iter = mWindows.begin(); iter != mWindows.end(); ++iter) { // Downcast to Dali::Window - Dali::Window window( dynamic_cast( *iter ) ); - if ( window ) + Dali::Window window(dynamic_cast(*iter)); + if(window) { - windows.push_back( window ); + windows.push_back(window); } } @@ -129,21 +126,21 @@ Dali::SceneHolderList Adaptor::GetSceneHolders() { Dali::SceneHolderList sceneHolderList; - for( auto iter = mWindows.begin(); iter != mWindows.end(); ++iter ) + for(auto iter = mWindows.begin(); iter != mWindows.end(); ++iter) { - sceneHolderList.push_back( Dali::Integration::SceneHolder( *iter ) ); + sceneHolderList.push_back(Dali::Integration::SceneHolder(*iter)); } return sceneHolderList; } -Dali::Internal::Adaptor::SceneHolder* Adaptor::GetWindow( Dali::Actor& actor ) +Dali::Internal::Adaptor::SceneHolder* Adaptor::GetWindow(Dali::Actor& actor) { - Dali::Integration::Scene scene = Dali::Integration::Scene::Get( actor ); + Dali::Integration::Scene scene = Dali::Integration::Scene::Get(actor); - for( auto window : mWindows ) + for(auto window : mWindows) { - if ( scene == window->GetScene() ) + if(scene == window->GetScene()) { return window; } @@ -152,39 +149,39 @@ Dali::Internal::Adaptor::SceneHolder* Adaptor::GetWindow( Dali::Actor& actor ) return nullptr; } -void Adaptor::AddWindow( Internal::Adaptor::SceneHolder* window ) +void Adaptor::AddWindow(Internal::Adaptor::SceneHolder* window) { - if ( window ) + if(window) { - mWindows.push_back( window ); + mWindows.push_back(window); - Dali::Integration::SceneHolder newWindow( window ); - mWindowCreatedSignal.Emit( newWindow ); + Dali::Integration::SceneHolder newWindow(window); + mWindowCreatedSignal.Emit(newWindow); } } -void Adaptor::RemoveWindow( Internal::Adaptor::SceneHolder* window ) +void Adaptor::RemoveWindow(Internal::Adaptor::SceneHolder* window) { - auto iter = std::find( mWindows.begin(), mWindows.end(), window ); - if( iter != mWindows.end() ) + auto iter = std::find(mWindows.begin(), mWindows.end(), window); + if(iter != mWindows.end()) { - mWindows.erase( iter ); + mWindows.erase(iter); } } -void Adaptor::RegisterProcessor( Integration::Processor& processor, bool postProcessor ) +void Adaptor::RegisterProcessor(Integration::Processor& processor, bool postProcessor) { Integration::Core& core = mTestApplication->GetCore(); - core.RegisterProcessor( processor, postProcessor ); + core.RegisterProcessor(processor, postProcessor); } -void Adaptor::UnregisterProcessor( Integration::Processor& processor, bool postProcessor ) +void Adaptor::UnregisterProcessor(Integration::Processor& processor, bool postProcessor) { Integration::Core& core = mTestApplication->GetCore(); - core.UnregisterProcessor( processor, postProcessor ); + core.UnregisterProcessor(processor, postProcessor); } -void Adaptor::SetApplication( Dali::TestApplication& testApplication ) +void Adaptor::SetApplication(Dali::TestApplication& testApplication) { mTestApplication = &testApplication; } @@ -214,7 +211,7 @@ Dali::Adaptor::WindowCreatedSignalType& Adaptor::WindowCreatedSignal() /////////////////////////////////////////////////////////////////////////////// Adaptor::Adaptor() -: mImpl( new Internal::Adaptor::Adaptor ) +: mImpl(new Internal::Adaptor::Adaptor) { } @@ -240,21 +237,21 @@ void Adaptor::Stop() { } -bool Adaptor::AddIdle( CallbackBase* callback, bool hasReturnValue ) +bool Adaptor::AddIdle(CallbackBase* callback, bool hasReturnValue) { - return mImpl->AddIdle( callback, hasReturnValue ); + return mImpl->AddIdle(callback, hasReturnValue); } -void Adaptor::RemoveIdle( CallbackBase* callback ) +void Adaptor::RemoveIdle(CallbackBase* callback) { - mImpl->RemoveIdle( callback ); + mImpl->RemoveIdle(callback); } -void Adaptor::ReplaceSurface( Window window, Dali::RenderSurfaceInterface& surface ) +void Adaptor::ReplaceSurface(Window window, Dali::RenderSurfaceInterface& surface) { } -void Adaptor::ReplaceSurface( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& surface ) +void Adaptor::ReplaceSurface(Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& surface) { } @@ -294,7 +291,7 @@ Any Adaptor::GetNativeWindowHandle() return window; } -Any Adaptor::GetNativeWindowHandle( Actor actor ) +Any Adaptor::GetNativeWindowHandle(Actor actor) { return GetNativeWindowHandle(); } @@ -303,7 +300,7 @@ void Adaptor::ReleaseSurfaceLock() { } -void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender ) +void Adaptor::SetRenderRefreshRate(unsigned int numberOfVSyncsPerRender) { } @@ -325,15 +322,15 @@ void Adaptor::NotifyLanguageChanged() { } -void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp ) +void Adaptor::FeedTouchPoint(TouchPoint& point, int timeStamp) { } -void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent ) +void Adaptor::FeedWheelEvent(WheelEvent& wheelEvent) { } -void Adaptor::FeedKeyEvent( KeyEvent& keyEvent ) +void Adaptor::FeedKeyEvent(KeyEvent& keyEvent) { } @@ -358,24 +355,51 @@ public: } }; -LogFactory* gLogFactory = NULL; +LogFactory* gLogFactory = NULL; const LogFactoryInterface& Adaptor::GetLogFactory() { - if( gLogFactory == NULL ) + if(gLogFactory == NULL) { gLogFactory = new LogFactory; } return *gLogFactory; } -void Adaptor::RegisterProcessor( Integration::Processor& processor, bool postProcessor) +class TraceFactory : public TraceFactoryInterface +{ +public: + virtual void InstallTraceFunction() const + { + Dali::Integration::Trace::LogContextFunction logContextFunction(&TestApplication::LogContext); + Dali::Integration::Trace::InstallLogContextFunction(logContextFunction); + } + + TraceFactory() + { + } + virtual ~TraceFactory() + { + } +}; + +TraceFactory* gTraceFactory = NULL; +const TraceFactoryInterface& Adaptor::GetTraceFactory() +{ + if(gTraceFactory == NULL) + { + gTraceFactory = new TraceFactory; + } + return *gTraceFactory; +} + +void Adaptor::RegisterProcessor(Integration::Processor& processor, bool postProcessor) { - mImpl->RegisterProcessor( processor, postProcessor ); + mImpl->RegisterProcessor(processor, postProcessor); } -void Adaptor::UnregisterProcessor( Integration::Processor& processor, bool postProcessor) +void Adaptor::UnregisterProcessor(Integration::Processor& processor, bool postProcessor) { - mImpl->UnregisterProcessor( processor, postProcessor ); + mImpl->UnregisterProcessor(processor, postProcessor); } } // namespace Dali diff --git a/dali-toolkit/internal/controls/gl-view/gl-view-render-thread.cpp b/dali-toolkit/internal/controls/gl-view/gl-view-render-thread.cpp index 3e84cfd..391dd34 100644 --- a/dali-toolkit/internal/controls/gl-view/gl-view-render-thread.cpp +++ b/dali-toolkit/internal/controls/gl-view/gl-view-render-thread.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2023 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -43,6 +43,7 @@ constexpr uint64_t DEFAULT_FRAME_DURATION_IN_NANOSECONDS(DEFAULT_FRAME_DURATION_ GlViewRenderThread::GlViewRenderThread(Dali::NativeImageSourceQueuePtr queue) : mLogFactory(Dali::Adaptor::Get().GetLogFactory()), + mTraceFactory(Dali::Adaptor::Get().GetTraceFactory()), mSurfaceSize(1, 1), mNativeImageSurface(), mNativeImageQueue(queue), @@ -154,6 +155,7 @@ void GlViewRenderThread::Run() { Dali::SetThreadName("GlViewRenderer"); mLogFactory.InstallLogFunction(); + mTraceFactory.InstallTraceFunction(); int renderFrameResult = 0; diff --git a/dali-toolkit/internal/controls/gl-view/gl-view-render-thread.h b/dali-toolkit/internal/controls/gl-view/gl-view-render-thread.h index 753526e..cc5f45a 100644 --- a/dali-toolkit/internal/controls/gl-view/gl-view-render-thread.h +++ b/dali-toolkit/internal/controls/gl-view/gl-view-render-thread.h @@ -2,7 +2,7 @@ #define DALI_TOOLKIT_INTERNAL_GL_VIEW_THREAD_H /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2023 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,6 +25,7 @@ #include #include #include +#include #include #include @@ -145,11 +146,13 @@ private: void SleepUntil(uint64_t timeInNanoseconds); private: - const Dali::LogFactoryInterface& mLogFactory; - Dali::Vector2 mSurfaceSize; ///< The size of mNativeImageQueue - Dali::NativeImageSurfacePtr mNativeImageSurface; - Dali::NativeImageSourceQueuePtr mNativeImageQueue; - Semaphore<> mSurfaceSemaphore; ///< The semaphore to avoid race condition to the render target + const Dali::LogFactoryInterface& mLogFactory; + const Dali::TraceFactoryInterface& mTraceFactory; + + Dali::Vector2 mSurfaceSize; ///< The size of mNativeImageQueue + Dali::NativeImageSurfacePtr mNativeImageSurface; + Dali::NativeImageSourceQueuePtr mNativeImageQueue; + Semaphore<> mSurfaceSemaphore; ///< The semaphore to avoid race condition to the render target std::unique_ptr mGlInitCallback; std::unique_ptr mGlRenderFrameCallback; diff --git a/dali-toolkit/internal/image-loader/fast-track-loading-task.cpp b/dali-toolkit/internal/image-loader/fast-track-loading-task.cpp index 607abbc..cd97cc2 100644 --- a/dali-toolkit/internal/image-loader/fast-track-loading-task.cpp +++ b/dali-toolkit/internal/image-loader/fast-track-loading-task.cpp @@ -23,6 +23,11 @@ #include #include #include +#include + +#ifdef TRACE_ENABLED +#include +#endif namespace Dali { @@ -30,6 +35,11 @@ namespace Toolkit { namespace Internal { +namespace +{ +DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_IMAGE_PERFORMANCE_MARKER, false); +} + FastTrackLoadingTask::FastTrackLoadingTask(const VisualUrl& url, ImageDimensions dimensions, FittingMode::Type fittingMode, SamplingMode::Type samplingMode, bool orientationCorrection, DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad, CallbackBase* callback) : AsyncTask(MakeCallback(this, &FastTrackLoadingTask::OnComplete), url.GetProtocolType() == VisualUrl::ProtocolType::REMOTE ? AsyncTask::PriorityType::LOW : AsyncTask::PriorityType::HIGH), mUrl(url), @@ -91,6 +101,15 @@ bool FastTrackLoadingTask::IsReady() void FastTrackLoadingTask::Load() { +#ifdef TRACE_ENABLED + if(gTraceFilter && gTraceFilter->IsTraceEnabled()) + { + std::ostringstream oss; + oss << "[url:" << mUrl.GetUrl() << "]"; + DALI_TRACE_BEGIN_WITH_MESSAGE(gTraceFilter, "DALI_IMAGE_FAST_TRACK_UPLOADING_TASK", oss.str().c_str()); + } +#endif + Devel::PixelBuffer pixelBuffer; std::vector pixelBuffers; @@ -128,6 +147,21 @@ void FastTrackLoadingTask::Load() DALI_LOG_ERROR("FastTrackLoadingTask::Load: ??? Undefined case. PixelBuffers.size() : %zu : ResourceId : %d, url : [%s]\n", pixelBuffers.size(), mResourceId, mUrl.GetUrl().c_str()); } } + +#ifdef TRACE_ENABLED + if(gTraceFilter && gTraceFilter->IsTraceEnabled()) + { + std::ostringstream oss; + oss << "["; + oss << "pixelBuffers: " << pixelBuffers.size() << " "; + if(!pixelBuffers.empty()) + { + oss << "premult:" << mPremultiplied << " "; + } + oss << "url:" << mUrl.GetUrl() << "]"; + DALI_TRACE_END_WITH_MESSAGE(gTraceFilter, "DALI_IMAGE_FAST_TRACK_UPLOADING_TASK", oss.str().c_str()); + } +#endif } void FastTrackLoadingTask::MultiplyAlpha(Dali::Devel::PixelBuffer pixelBuffer) diff --git a/dali-toolkit/internal/image-loader/loading-task.cpp b/dali-toolkit/internal/image-loader/loading-task.cpp index e81b16f..a1fcd63 100644 --- a/dali-toolkit/internal/image-loader/loading-task.cpp +++ b/dali-toolkit/internal/image-loader/loading-task.cpp @@ -16,21 +16,31 @@ */ // CLASS HEADER -#include "loading-task.h" +#include // EXTERNAL INCLUDES #include #include #include #include +#include #include +#ifdef TRACE_ENABLED +#include +#endif + namespace Dali { namespace Toolkit { namespace Internal { +namespace +{ +DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_IMAGE_PERFORMANCE_MARKER, false); +} + LoadingTask::LoadingTask(uint32_t id, Dali::AnimatedImageLoading animatedImageLoading, uint32_t frameIndex, DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad, CallbackBase* callback) : AsyncTask(callback), url(), @@ -148,6 +158,15 @@ LoadingTask::~LoadingTask() void LoadingTask::Process() { +#ifdef TRACE_ENABLED + if(gTraceFilter && gTraceFilter->IsTraceEnabled()) + { + std::ostringstream oss; + oss << "[url:" << (!!(animatedImageLoading) ? animatedImageLoading.GetUrl() : url.GetUrl()) << "]"; + DALI_TRACE_BEGIN_WITH_MESSAGE(gTraceFilter, "DALI_IMAGE_LOADING_TASK", oss.str().c_str()); + } +#endif + isReady = false; if(!isMaskTask) { @@ -159,6 +178,23 @@ void LoadingTask::Process() } MultiplyAlpha(); isReady = true; + +#ifdef TRACE_ENABLED + if(gTraceFilter && gTraceFilter->IsTraceEnabled()) + { + std::ostringstream oss; + oss << "["; + oss << "masking:" << isMaskTask << " "; + oss << "index: " << frameIndex << " "; + oss << "pixelBuffers: " << pixelBuffers.size() << " "; + if(!pixelBuffers.empty()) + { + oss << "premult:" << pixelBuffers[0].IsAlphaPreMultiplied() << " "; + } + oss << "url:" << (!!(animatedImageLoading) ? animatedImageLoading.GetUrl() : url.GetUrl()) << "]"; + DALI_TRACE_END_WITH_MESSAGE(gTraceFilter, "DALI_IMAGE_LOADING_TASK", oss.str().c_str()); + } +#endif } bool LoadingTask::IsReady() diff --git a/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-task.cpp b/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-task.cpp index b1e9bea..c19a440 100644 --- a/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-task.cpp +++ b/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-task.cpp @@ -20,6 +20,7 @@ // EXTERNAL INCLUDES #include +#include #include #include @@ -28,6 +29,10 @@ #include #include +#ifdef TRACE_ENABLED +#include +#endif + namespace Dali { namespace Toolkit @@ -43,6 +48,8 @@ constexpr auto MICROSECONDS_PER_SECOND(1e+6); Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_ANIMATION"); #endif +DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_IMAGE_PERFORMANCE_MARKER, false); + } // unnamed namespace VectorAnimationTask::VectorAnimationTask(VisualFactoryCache& factoryCache) @@ -136,6 +143,8 @@ bool VectorAnimationTask::IsAnimating() bool VectorAnimationTask::Load(bool synchronousLoading) { + DALI_TRACE_SCOPE(gTraceFilter, "DALI_LOTTIE_LOADING_TASK"); + if(!mVectorRenderer.Load(mUrl)) { DALI_LOG_ERROR("VectorAnimationTask::Load: Load failed [%s]\n", mUrl.c_str()); @@ -452,6 +461,8 @@ bool VectorAnimationTask::Rasterize() return false; } + DALI_TRACE_BEGIN(gTraceFilter, "DALI_LOTTIE_RASTERIZE_TASK"); + ApplyAnimationData(); if(mPlayState == PlayState::PLAYING && mUpdateFrameNumber) @@ -559,6 +570,18 @@ bool VectorAnimationTask::Rasterize() mKeepAnimation = true; } +#ifdef TRACE_ENABLED + if(gTraceFilter && gTraceFilter->IsTraceEnabled()) + { + std::ostringstream oss; + oss << "[size: " << mWidth << " x " << mHeight << ", "; + oss << "frame: " << mCurrentFrame << ", "; + oss << "loop: " << mCurrentLoop << ", "; + oss << "state : " << mPlayState << "]"; + DALI_TRACE_END_WITH_MESSAGE(gTraceFilter, "DALI_LOTTIE_RASTERIZE_TASK", oss.str().c_str()); + } +#endif + return true; } diff --git a/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.cpp b/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.cpp index 9d2cfbe..66a9f14 100644 --- a/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.cpp +++ b/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.cpp @@ -47,7 +47,8 @@ VectorAnimationThread::VectorAnimationThread() mConditionalWait(), mNeedToSleep(false), mDestroyThread(false), - mLogFactory(Dali::Adaptor::Get().GetLogFactory()) + mLogFactory(Dali::Adaptor::Get().GetLogFactory()), + mTraceFactory(Dali::Adaptor::Get().GetTraceFactory()) { mAsyncTaskManager = Dali::AsyncTaskManager::Get(); mSleepThread.Start(); @@ -176,6 +177,7 @@ void VectorAnimationThread::Run() { SetThreadName("VectorAnimationThread"); mLogFactory.InstallLogFunction(); + mTraceFactory.InstallTraceFunction(); while(!mDestroyThread) { @@ -289,6 +291,7 @@ VectorAnimationThread::SleepThread::SleepThread(CallbackBase* callback) mAwakeCallback(std::unique_ptr(callback)), mSleepTimePoint(), mLogFactory(Dali::Adaptor::Get().GetLogFactory()), + mTraceFactory(Dali::Adaptor::Get().GetTraceFactory()), mNeedToSleep(false), mDestroyThread(false) { @@ -318,6 +321,7 @@ void VectorAnimationThread::SleepThread::Run() { SetThreadName("VectorSleepThread"); mLogFactory.InstallLogFunction(); + mTraceFactory.InstallTraceFunction(); while(!mDestroyThread) { diff --git a/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h b/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h index 14aa6c9..07537c5 100644 --- a/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h +++ b/dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -145,6 +146,7 @@ private: std::unique_ptr mAwakeCallback; std::chrono::time_point mSleepTimePoint; const Dali::LogFactoryInterface& mLogFactory; + const Dali::TraceFactoryInterface& mTraceFactory; bool mNeedToSleep; bool mDestroyThread; }; @@ -168,6 +170,7 @@ private: bool mDestroyThread; bool mEventTriggered{false}; const Dali::LogFactoryInterface& mLogFactory; + const Dali::TraceFactoryInterface& mTraceFactory; Dali::AsyncTaskManager mAsyncTaskManager; }; diff --git a/dali-toolkit/internal/visuals/svg/svg-task.cpp b/dali-toolkit/internal/visuals/svg/svg-task.cpp index 7b8ef29..bcd0f91 100644 --- a/dali-toolkit/internal/visuals/svg/svg-task.cpp +++ b/dali-toolkit/internal/visuals/svg/svg-task.cpp @@ -22,16 +22,26 @@ #include #include #include +#include // INTERNAL INCLUDES #include +#ifdef TRACE_ENABLED +#include +#endif + namespace Dali { namespace Toolkit { namespace Internal { +namespace +{ +DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_IMAGE_PERFORMANCE_MARKER, false); +} + SvgTask::SvgTask(VectorImageRenderer vectorRenderer, CallbackBase* callback, AsyncTask::PriorityType priorityType) : AsyncTask(callback, priorityType), mVectorRenderer(vectorRenderer), @@ -74,6 +84,8 @@ void SvgLoadingTask::Process() return; } + DALI_TRACE_SCOPE(gTraceFilter, "DALI_SVG_LOADING_TASK"); + Dali::Vector buffer; if(!mUrl.IsLocalResource()) @@ -128,15 +140,26 @@ void SvgRasterizingTask::Process() return; } +#ifdef TRACE_ENABLED + if(gTraceFilter && gTraceFilter->IsTraceEnabled()) + { + std::ostringstream oss; + oss << "[size: " << mWidth << " x " << mHeight << "]"; + DALI_TRACE_BEGIN_WITH_MESSAGE(gTraceFilter, "DALI_SVG_RASTERIZE_TASK", oss.str().c_str()); + } +#endif + Devel::PixelBuffer pixelBuffer = mVectorRenderer.Rasterize(mWidth, mHeight); if(!pixelBuffer) { DALI_LOG_ERROR("Rasterize is failed!\n"); + DALI_TRACE_END(gTraceFilter, "DALI_SVG_RASTERIZE_TASK"); return; } mPixelData = Devel::PixelBuffer::Convert(pixelBuffer); mHasSucceeded = true; + DALI_TRACE_END(gTraceFilter, "DALI_SVG_RASTERIZE_TASK"); } bool SvgRasterizingTask::IsReady() -- 2.7.4