[Tizen] Add some logs to check performance

[platform/core/uifw/dali-core.git] / dali / internal / event / common / notification-manager.cpp

diff --git a/dali/internal/event/common/notification-manager.cpp b/dali/internal/event/common/notification-manager.cpp
index f80b6e2..c0530cc 100644 (file)
--- a/dali/internal/event/common/notification-manager.cpp
+++ b/dali/internal/event/common/notification-manager.cpp
@@ -19,53 +19,52 @@
 #include <dali/internal/event/common/notification-manager.h>
 
 // INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
 #include <dali/devel-api/common/owner-container.h>
 #include <dali/devel-api/threading/mutex.h>
+#include <dali/integration-api/debug.h>
 #include <dali/internal/common/message.h>
-#include <dali/internal/event/common/property-notification-impl.h>
 #include <dali/internal/event/common/complete-notification-interface.h>
+#include <dali/internal/event/common/property-notification-impl.h>
+#include <dali/public-api/common/dali-common.h>
 
 namespace Dali
 {
-
 namespace Internal
 {
-
 namespace
 {
-typedef Dali::Vector< CompleteNotificationInterface* > InterfaceContainer;
+typedef Dali::Vector<CompleteNotificationInterface*> InterfaceContainer;
 
 /**
  * helper to move elements from one container to another
  * @param from where to move
  * @param to move target
  */
-void MoveElements( InterfaceContainer& from, InterfaceContainer& to )
+void MoveElements(InterfaceContainer& from, InterfaceContainer& to)
 {
   // check if there's something in from
   const InterfaceContainer::SizeType fromCount = from.Count();
-  if( fromCount > 0u )
+  if(fromCount > 0u)
   {
     // check if to has some elements
     const InterfaceContainer::SizeType toCount = to.Count();
-    if( toCount == 0u )
+    if(toCount == 0u)
     {
       // to is empty so we can swap with from
-      to.Swap( from );
+      to.Swap(from);
     }
     else
     {
-      to.Reserve( toCount + fromCount );
-      for( InterfaceContainer::SizeType i = 0; i < fromCount; ++i )
+      to.Reserve(toCount + fromCount);
+      for(InterfaceContainer::SizeType i = 0; i < fromCount; ++i)
       {
-        to.PushBack( from[ i ] );
+        to.PushBack(from[i]);
       }
       from.Clear();
     }
   }
 }
-}
+} // namespace
 
 using MessageQueueMutex = Dali::Mutex;
 using MessageContainer  = OwnerContainer<MessageBase*>;
@@ -76,14 +75,14 @@ struct NotificationManager::Impl
   {
     // reserve space on the vectors to avoid reallocs
     // applications typically have up-to 20-30 notifications at startup
-    updateCompletedMessageQueue.Reserve( 32 );
-    updateWorkingMessageQueue.Reserve( 32 );
-    eventMessageQueue.Reserve( 32 );
+    updateCompletedMessageQueue.Reserve(32);
+    updateWorkingMessageQueue.Reserve(32);
+    eventMessageQueue.Reserve(32);
 
     // only a few manager objects get complete notifications (animation, render list, property notifications, ...)
-    updateCompletedInterfaceQueue.Reserve( 4 );
-    updateWorkingInterfaceQueue.Reserve( 4 );
-    eventInterfaceQueue.Reserve( 4 );
+    updateCompletedInterfaceQueue.Reserve(4);
+    updateWorkingInterfaceQueue.Reserve(4);
+    eventInterfaceQueue.Reserve(4);
   }
 
   ~Impl() = default;
@@ -110,75 +109,80 @@ NotificationManager::~NotificationManager()
   delete mImpl;
 }
 
-void NotificationManager::QueueCompleteNotification( CompleteNotificationInterface* instance )
+void NotificationManager::QueueCompleteNotification(CompleteNotificationInterface* instance)
 {
   // queueMutex must be locked whilst accessing queues
-  MessageQueueMutex::ScopedLock lock( mImpl->queueMutex );
+  MessageQueueMutex::ScopedLock lock(mImpl->queueMutex);
 
-  mImpl->updateWorkingInterfaceQueue.PushBack( instance );
+  mImpl->updateWorkingInterfaceQueue.PushBack(instance);
 }
 
-void NotificationManager::QueueMessage( MessageBase* message )
+void NotificationManager::QueueMessage(MessageBase* message)
 {
-  DALI_ASSERT_DEBUG( NULL != message );
+  DALI_ASSERT_DEBUG(NULL != message);
 
   // queueMutex must be locked whilst accessing queues
-  MessageQueueMutex::ScopedLock lock( mImpl->queueMutex );
+  MessageQueueMutex::ScopedLock lock(mImpl->queueMutex);
 
-  mImpl->updateWorkingMessageQueue.PushBack( message );
+  mImpl->updateWorkingMessageQueue.PushBack(message);
 }
 
 void NotificationManager::UpdateCompleted()
 {
   // queueMutex must be locked whilst accessing queues
-  MessageQueueMutex::ScopedLock lock( mImpl->queueMutex );
+  MessageQueueMutex::ScopedLock lock(mImpl->queueMutex);
   // Move messages from update working queue to completed queue
   // note that in theory its possible for update completed to have last frames
   // events as well still hanging around. we need to keep them as well
-  mImpl->updateCompletedMessageQueue.MoveFrom( mImpl->updateWorkingMessageQueue );
+  mImpl->updateCompletedMessageQueue.MoveFrom(mImpl->updateWorkingMessageQueue);
   // move pointers from interface queue
-  MoveElements( mImpl->updateWorkingInterfaceQueue, mImpl->updateCompletedInterfaceQueue );
+  MoveElements(mImpl->updateWorkingInterfaceQueue, mImpl->updateCompletedInterfaceQueue);
   // finally the lock is released
 }
 
 bool NotificationManager::MessagesToProcess()
 {
   // queueMutex must be locked whilst accessing queues
-  MessageQueueMutex::ScopedLock lock( mImpl->queueMutex );
+  MessageQueueMutex::ScopedLock lock(mImpl->queueMutex);
 
-  return ( 0u < mImpl->updateCompletedMessageQueue.Count() ||
-         ( 0u < mImpl->updateCompletedInterfaceQueue.Count() ) );
+  return (0u < mImpl->updateCompletedMessageQueue.Count() ||
+          (0u < mImpl->updateCompletedInterfaceQueue.Count()));
 }
 
 void NotificationManager::ProcessMessages()
 {
   // queueMutex must be locked whilst accessing queues
   {
-    MessageQueueMutex::ScopedLock lock( mImpl->queueMutex );
+    MessageQueueMutex::ScopedLock lock(mImpl->queueMutex);
 
     // Move messages from update completed queue to event queue
     // note that in theory its possible for event queue to have
     // last frames events as well still hanging around so need to keep them
-    mImpl->eventMessageQueue.MoveFrom( mImpl->updateCompletedMessageQueue );
-    MoveElements( mImpl->updateCompletedInterfaceQueue, mImpl->eventInterfaceQueue );
+    mImpl->eventMessageQueue.MoveFrom(mImpl->updateCompletedMessageQueue);
+    MoveElements(mImpl->updateCompletedInterfaceQueue, mImpl->eventInterfaceQueue);
   }
   // end of scope, lock is released
 
-  MessageContainer::Iterator iter = mImpl->eventMessageQueue.Begin();
-  const MessageContainer::Iterator end = mImpl->eventMessageQueue.End();
-  for( ; iter != end; ++iter )
+  MessageContainer::Iterator       iter = mImpl->eventMessageQueue.Begin();
+  const MessageContainer::Iterator end  = mImpl->eventMessageQueue.End();
+  if(iter != end)
   {
-    (*iter)->Process( 0u/*ignored*/ );
+    DALI_LOG_RELEASE_INFO("Start ProcessMessages\n");
+    for(; iter != end; ++iter)
+    {
+      (*iter)->Process(0u /*ignored*/);
+    }
+    DALI_LOG_RELEASE_INFO("End ProcessMessages\n");
   }
   // release the processed messages from event side queue
   mImpl->eventMessageQueue.Clear();
 
-  InterfaceContainer::Iterator iter2 = mImpl->eventInterfaceQueue.Begin();
-  const InterfaceContainer::Iterator end2 = mImpl->eventInterfaceQueue.End();
-  for( ; iter2 != end2; ++iter2 )
+  InterfaceContainer::Iterator       iter2 = mImpl->eventInterfaceQueue.Begin();
+  const InterfaceContainer::Iterator end2  = mImpl->eventInterfaceQueue.End();
+  for(; iter2 != end2; ++iter2)
   {
     CompleteNotificationInterface* interface = *iter2;
-    if( interface )
+    if(interface)
     {
       interface->NotifyCompleted();
     }