Add trace logs to check performance

Change-Id: I441a332afb89b8527c34eeadc1e3c7b332caa789

diff --git a/dali/internal/common/core-impl.cpp b/dali/internal/common/core-impl.cpp
index c37dd21..919d6f5 100644 (file)
--- a/dali/internal/common/core-impl.cpp
+++ b/dali/internal/common/core-impl.cpp
@@ -27,6 +27,7 @@
 #include <dali/integration-api/platform-abstraction.h>
 #include <dali/integration-api/processor-interface.h>
 #include <dali/integration-api/render-controller.h>
+#include <dali/integration-api/trace.h>
 
 #include <dali/internal/event/actors/actor-impl.h>
 #include <dali/internal/event/animation/animation-playlist.h>
@@ -59,6 +60,8 @@ namespace
 // The Update for frame N+1 may be processed whilst frame N is being rendered.
 const uint32_t MAXIMUM_UPDATE_COUNT = 2u;
 
+DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
+
 #if defined(DEBUG_ENABLED)
 Debug::Filter* gCoreFilter = Debug::Filter::New(Debug::Concise, false, "LOG_CORE");
 #endif
@@ -365,61 +368,73 @@ void Core::UnregisterProcessor(Integration::Processor& processor, bool postProce
 
 void Core::RunProcessors()
 {
-  // Copy processor pointers to prevent changes to vector affecting loop iterator.
-  Dali::Vector<Integration::Processor*> processors(mProcessors);
+  if(mProcessors.Count() != 0)
+  {
+    DALI_TRACE_BEGIN(gTraceFilter, "DALI_CORE_RUN_PROCESSORS");
 
-  // To prevent accessing processor unregistered during the loop
-  mProcessorUnregistered = false;
+    // Copy processor pointers to prevent changes to vector affecting loop iterator.
+    Dali::Vector<Integration::Processor*> processors(mProcessors);
 
-  for(auto processor : processors)
-  {
-    if(processor)
+    // To prevent accessing processor unregistered during the loop
+    mProcessorUnregistered = false;
+
+    for(auto processor : processors)
     {
-      if(!mProcessorUnregistered)
+      if(processor)
       {
-        processor->Process(false);
-      }
-      else
-      {
-        // Run processor if the processor is still in the list.
-        // It may be removed during the loop.
-        auto iter = std::find(mProcessors.Begin(), mProcessors.End(), processor);
-        if(iter != mProcessors.End())
+        if(!mProcessorUnregistered)
         {
           processor->Process(false);
         }
+        else
+        {
+          // Run processor if the processor is still in the list.
+          // It may be removed during the loop.
+          auto iter = std::find(mProcessors.Begin(), mProcessors.End(), processor);
+          if(iter != mProcessors.End())
+          {
+            processor->Process(false);
+          }
+        }
       }
     }
+    DALI_TRACE_END(gTraceFilter, "DALI_CORE_RUN_PROCESSORS");
   }
 }
 
 void Core::RunPostProcessors()
 {
-  // Copy processor pointers to prevent changes to vector affecting loop iterator.
-  Dali::Vector<Integration::Processor*> processors(mPostProcessors);
+  if(mPostProcessors.Count() != 0)
+  {
+    DALI_TRACE_BEGIN(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS");
 
-  // To prevent accessing processor unregistered during the loop
-  mPostProcessorUnregistered = false;
+    // Copy processor pointers to prevent changes to vector affecting loop iterator.
+    Dali::Vector<Integration::Processor*> processors(mPostProcessors);
 
-  for(auto processor : processors)
-  {
-    if(processor)
+    // To prevent accessing processor unregistered during the loop
+    mPostProcessorUnregistered = false;
+
+    for(auto processor : processors)
     {
-      if(!mPostProcessorUnregistered)
+      if(processor)
       {
-        processor->Process(true);
-      }
-      else
-      {
-        // Run processor if the processor is still in the list.
-        // It may be removed during the loop.
-        auto iter = std::find(mPostProcessors.Begin(), mPostProcessors.End(), processor);
-        if(iter != mPostProcessors.End())
+        if(!mPostProcessorUnregistered)
         {
           processor->Process(true);
         }
+        else
+        {
+          // Run processor if the processor is still in the list.
+          // It may be removed during the loop.
+          auto iter = std::find(mPostProcessors.Begin(), mPostProcessors.End(), processor);
+          if(iter != mPostProcessors.End())
+          {
+            processor->Process(true);
+          }
+        }
       }
     }
+    DALI_TRACE_END(gTraceFilter, "DALI_CORE_RUN_POST_PROCESSORS");
   }
 }
 

diff --git a/dali/internal/event/common/notification-manager.cpp b/dali/internal/event/common/notification-manager.cpp
index dad673f..4764ed7 100644 (file)
--- a/dali/internal/event/common/notification-manager.cpp
+++ b/dali/internal/event/common/notification-manager.cpp
@@ -21,6 +21,8 @@
 // INTERNAL INCLUDES
 #include <dali/devel-api/common/owner-container.h>
 #include <dali/devel-api/threading/mutex.h>
+#include <dali/integration-api/debug.h>
+#include <dali/integration-api/trace.h>
 #include <dali/internal/common/message.h>
 #include <dali/internal/event/common/complete-notification-interface.h>
 #include <dali/internal/event/common/property-notification-impl.h>
@@ -34,6 +36,8 @@ namespace
 {
 typedef Dali::Vector<CompleteNotificationInterface*> InterfaceContainer;
 
+DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
+
 /**
  * helper to move elements from one container to another
  * @param from where to move
@@ -164,9 +168,14 @@ void NotificationManager::ProcessMessages()
 
   MessageContainer::Iterator       iter = mImpl->eventMessageQueue.Begin();
   const MessageContainer::Iterator end  = mImpl->eventMessageQueue.End();
-  for(; iter != end; ++iter)
+  if(iter != end)
   {
-    (*iter)->Process(0u /*ignored*/);
+    DALI_TRACE_BEGIN(gTraceFilter, "DALI_PROCESS_NOTIFICATION_MESSAGE");
+    for(; iter != end; ++iter)
+    {
+      (*iter)->Process(0u /*ignored*/);
+    }
+    DALI_TRACE_END(gTraceFilter, "DALI_PROCESS_NOTIFICATION_MESSAGE");
   }
   // release the processed messages from event side queue
   mImpl->eventMessageQueue.Clear();

diff --git a/dali/internal/event/events/key-event-processor.cpp b/dali/internal/event/events/key-event-processor.cpp
index 65160be..4180fc6 100644 (file)
--- a/dali/internal/event/events/key-event-processor.cpp
+++ b/dali/internal/event/events/key-event-processor.cpp
@@ -19,8 +19,8 @@
 #include <dali/internal/event/events/key-event-processor.h>
 
 // INTERNAL INCLUDES
-#include <dali/integration-api/debug.h>
 #include <dali/integration-api/events/key-event-integ.h>
+#include <dali/integration-api/trace.h>
 #include <dali/internal/event/common/scene-impl.h>
 #include <dali/internal/event/events/key-event-impl.h>
 #include <dali/public-api/events/key-event.h>
@@ -29,6 +29,11 @@ namespace Dali
 {
 namespace Internal
 {
+namespace
+{
+DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
+} // namespace
+
 KeyEventProcessor::KeyEventProcessor(Scene& scene)
 : mScene(scene)
 {
@@ -41,7 +46,14 @@ void KeyEventProcessor::ProcessKeyEvent(const Integration::KeyEvent& event)
   KeyEventPtr    keyEvent(new KeyEvent(event.keyName, event.logicalKey, event.keyString, event.keyCode, event.keyModifier, event.time, static_cast<Dali::KeyEvent::State>(event.state), event.compose, event.deviceName, event.deviceClass, event.deviceSubclass));
   Dali::KeyEvent keyEventHandle(keyEvent.Get());
 
-  DALI_LOG_RELEASE_INFO("Start processing key event [%s, %d]\n", event.keyName.c_str(), event.state);
+#ifdef TRACE_ENABLED
+  std::ostringstream stream;
+  if(gTraceFilter->IsTraceEnabled())
+  {
+    stream << "DALI_PROCESS_KEY_EVENT [" << event.keyName << ", " << event.state << "]\n";
+    DALI_TRACE_BEGIN(gTraceFilter, stream.str().c_str());
+  }
+#endif
 
   // Emit the key event signal from the scene.
   bool consumed = mScene.EmitInterceptKeyEventSignal(keyEventHandle);
@@ -54,7 +66,12 @@ void KeyEventProcessor::ProcessKeyEvent(const Integration::KeyEvent& event)
     mScene.EmitKeyEventSignal(keyEventHandle);
   }
 
-  DALI_LOG_RELEASE_INFO("End processing key event [consumed = %d]\n", consumed);
+#ifdef TRACE_ENABLED
+  if(gTraceFilter->IsTraceEnabled())
+  {
+    DALI_TRACE_END(gTraceFilter, stream.str().c_str());
+  }
+#endif
 }
 
 } // namespace Internal

diff --git a/dali/internal/event/size-negotiation/relayout-controller-impl.cpp b/dali/internal/event/size-negotiation/relayout-controller-impl.cpp
index 497f515..1589d94 100644 (file)
--- a/dali/internal/event/size-negotiation/relayout-controller-impl.cpp
+++ b/dali/internal/event/size-negotiation/relayout-controller-impl.cpp
@@ -26,6 +26,7 @@
 // INTERNAL INCLUDES
 #include <dali/integration-api/debug.h>
 #include <dali/integration-api/render-controller.h>
+#include <dali/integration-api/trace.h>
 #include <dali/internal/event/actors/actor-impl.h>
 #include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/event/common/thread-local-storage.h>
@@ -38,6 +39,8 @@ namespace Internal
 {
 namespace
 {
+DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
+
 #if defined(DEBUG_ENABLED)
 
 Integration::Log::Filter* gLogFilter(Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_RELAYOUT_CONTROLLER"));
@@ -436,6 +439,7 @@ void RelayoutController::Relayout()
     // 2. Iterate through the stack until it's empty.
     if(mRelayoutStack->Size() > 0)
     {
+      DALI_TRACE_BEGIN(gTraceFilter, "DALI_RELAYOUT");
       PRINT_HIERARCHY;
 
       while(mRelayoutStack->Size() > 0)
@@ -460,6 +464,7 @@ void RelayoutController::Relayout()
       mRelayoutInfoAllocator.ResetMemoryPool();
 
       PRINT_HIERARCHY;
+      DALI_TRACE_END(gTraceFilter, "DALI_RELAYOUT");
     }
 
     mPerformingRelayout = false;