adaptors/common/object-profiler.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "object-profiler.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <stdlib.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <dali/integration-api/profiling.h>
  25 #include <dali/public-api/actors/image-actor.h>
  26 #include <dali/public-api/common/stage.h>
  27 #include <dali/public-api/object/ref-object.h>
  28 #include <dali/public-api/object/base-object.h>
  29 #include <dali/public-api/object/type-registry.h>
  30
  31 using std::string;
  32 using namespace Dali::Integration::Profiling;
  33
  34 namespace Dali
  35 {
  36 namespace Internal
  37 {
  38 namespace Adaptor
  39 {
  40
  41 ObjectProfiler::ObjectProfiler( unsigned int timeInterval )
  42 {
  43   // This class must be created after the Stage; this means it doesn't count the initial objects
  44   // that are created by the stage (base layer, default camera actor)
  45   mObjectRegistry = Dali::Stage::GetCurrent().GetObjectRegistry();
  46
  47   mTimer = Dali::Timer::New( timeInterval * 1000 );
  48   mTimer.TickSignal().Connect( this, &ObjectProfiler::OnTimeout );
  49   mTimer.Start();
  50
  51   mObjectRegistry.ObjectCreatedSignal().Connect( this, &ObjectProfiler::OnObjectCreated );
  52   mObjectRegistry.ObjectDestroyedSignal().Connect( this, &ObjectProfiler::OnObjectDestroyed );
  53 }
  54
  55 ObjectProfiler::~ObjectProfiler()
  56 {
  57 }
  58
  59 void ObjectProfiler::DisplayInstanceCounts()
  60 {
  61   InstanceCountMapIterator iter = mInstanceCountMap.begin();
  62   InstanceCountMapIterator end = mInstanceCountMap.end();
  63
  64   for( ; iter != end; iter++ )
  65   {
  66     int memorySize = GetMemorySize(iter->first, iter->second);
  67     if( memorySize > 0 )
  68     {
  69       LogMessage( Debug::DebugInfo, "%-30s: % 4d  Memory MemorySize: ~% 6.1f kB\n",
  70                   iter->first.c_str(), iter->second, memorySize / 1024.0f );
  71     }
  72     else
  73     {
  74       LogMessage( Debug::DebugInfo, "%-30s: % 4d\n",
  75                   iter->first.c_str(), iter->second );
  76     }
  77   }
  78   LogMessage(Debug::DebugInfo, "\n");
  79 }
  80
  81 bool ObjectProfiler::OnTimeout()
  82 {
  83   DisplayInstanceCounts();
  84   return true;
  85 }
  86
  87 void ObjectProfiler::OnObjectCreated(BaseHandle handle)
  88 {
  89   string theType = handle.GetTypeName();
  90   if( theType.empty() )
  91   {
  92     DALI_LOG_ERROR("Object created from an unregistered type\n");
  93     theType = "<Unregistered>";
  94   }
  95
  96   mInstanceTypes.push_back(InstanceTypePair(&handle.GetBaseObject(), theType));
  97
  98   InstanceCountMapIterator iter = mInstanceCountMap.find(theType);
  99   if( iter == mInstanceCountMap.end() )
 100   {
 101     InstanceCountPair instanceCount(theType, 1);
 102     mInstanceCountMap.insert(instanceCount);
 103   }
 104   else
 105   {
 106     iter->second++;
 107   }
 108 }
 109
 110 void ObjectProfiler::OnObjectDestroyed(const Dali::RefObject* object)
 111 {
 112   const BaseObject* baseObject = static_cast<const BaseObject*>(object);
 113
 114   InstanceTypes::iterator end = mInstanceTypes.end();
 115   for( InstanceTypes::iterator iter = mInstanceTypes.begin(); iter != end; iter++)
 116   {
 117     if( iter->first == baseObject )
 118     {
 119       const std::string& theType = iter->second;
 120       if( !theType.empty() )
 121       {
 122         InstanceCountMapIterator countIter = mInstanceCountMap.find(theType);
 123         if( countIter != mInstanceCountMap.end() )
 124         {
 125           countIter->second--;
 126         }
 127       }
 128       mInstanceTypes.erase( iter );
 129       break;
 130     }
 131   }
 132 }
 133
 134 int ObjectProfiler::GetMemorySize(const std::string& name, int count)
 135 {
 136   struct MemoryMemorySize
 137   {
 138     std::string name;
 139     int memorySize;
 140   };
 141   MemoryMemorySize memoryMemorySizes[] =
 142     {
 143       { "Animation", ANIMATION_MEMORY_SIZE },
 144       { "Constraint", CONSTRAINT_MEMORY_SIZE },
 145       { "Actor", ACTOR_MEMORY_SIZE },
 146       { "Layer", LAYER_MEMORY_SIZE },
 147       { "CameraActor", CAMERA_ACTOR_MEMORY_SIZE },
 148       { "Image", IMAGE_MEMORY_SIZE },
 149       { "Renderer", RENDERER_MEMORY_SIZE },
 150       { "Geometry", GEOMETRY_MEMORY_SIZE },
 151       { "PropertyBuffer", PROPERTY_BUFFER_MEMORY_SIZE },
 152       { "TextureSet", TEXTURE_SET_MEMORY_SIZE },
 153       { "Sampler", SAMPLER_MEMORY_SIZE },
 154       { "Shader", SHADER_MEMORY_SIZE },
 155     };
 156
 157   for( size_t i=0; i<sizeof(memoryMemorySizes)/sizeof(MemoryMemorySize); i++ )
 158   {
 159     if( memoryMemorySizes[i].name.compare(name) == 0 )
 160     {
 161       return count * memoryMemorySizes[i].memorySize;
 162     }
 163   }
 164   return 0;
 165 }
 166
 167 } // Adaptor
 168 } // Internal
 169 } // Dali