ResourceUsageLogger.cpp

 
#include "Resources/BufferManager.h"
#include "Resources/TextureManager.h"
#include "Resources/AnimationManager.h"
#include "Resources/MeshManager.h"
#include "Resources/ModelManager.h"
#include "Resources/EffectManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/MaterialDefinitionManager.h"
#include "Resources/MaterialInstance.h"
#include "Resources/FontManager.h"
#include "Resources/AssetManager.h"
 
#include "Renderer/RenderResources.h"
 
#include "Services/Variables.h"
#include "Context.h"
 
#include "MemoryContext.h"
#include "ResourceUsageLogger.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Memory/Allocator.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ResourceUsage");
 
  std::string byteString(size_t size)
  {
    if (size < 1024 * 5) {
      return std::to_string(size) + "b";
    }
    size /= 1024;
    if (size < 1024 * 5) {
      return std::to_string(size) + "kb";
    }
    size /= 1024;
    if (size < 1024 * 5) {
      return std::to_string(size) + "mb";
    }
    size /= 1024;
    return std::to_string(size) + "gb";
  }
 
}
 
 
Cogs::Core::ResourceUsageLogger::ResourceUsageLogger(Context* context)
{
  timer.start();
  context->variables->set("resources.usageLogger.rate",
#if defined(COGS_PARANOIA)
    1.f
#else
    0.f
#endif
    );
}
 
Cogs::Core::ResourceUsageLogger::~ResourceUsageLogger()
{
}
 
void Cogs::Core::ResourceUsageLogger::update(Context* context, bool force)
{
  auto rate = context->variables->get("resources.usageLogger.rate", 0.f);
 
  if (!force && (rate <= 0.f || timer.elapsedSeconds() < rate)) return;
  timer.start();
  LOG_DEBUG(logger, "Allocators: bas=%s/%zu, res=%s/%zu, io=%s/%zu, cmp=%s/%zu, scr=%s/%zu, str=%s/%zu",
            byteString(context->memory->baseAllocator->getAllocatedBytes()).c_str(),      context->memory->baseAllocator->getAllocationCount(),
            byteString(context->memory->resourceAllocator->getAllocatedBytes()).c_str(),  context->memory->resourceAllocator->getAllocationCount(),
            byteString(context->memory->ioAllocator->getAllocatedBytes()).c_str(),        context->memory->ioAllocator->getAllocationCount(),
            byteString(context->memory->componentAllocator->getAllocatedBytes()).c_str(), context->memory->componentAllocator->getAllocationCount(),
            byteString(context->memory->scriptAllocator->getAllocatedBytes()).c_str(),    context->memory->scriptAllocator->getAllocationCount(),
            byteString(context->memory->getStringsAllocator()->getAllocatedBytes()).c_str(), context->memory->getStringsAllocator()->getAllocationCount());
 
  if (context->renderer) {
    if (const auto* renderResources = context->renderer->getResources()) {
      LOG_DEBUG(logger, "renderResources: %s", renderResources->getReport().c_str());
    }
  }
  if (context->bufferManager) LOG_DEBUG(logger, "bufMgr: %s", context->bufferManager->getReport().c_str());
  if (context->textureManager) LOG_DEBUG(logger, "texMgr: %s", context->textureManager->getReport().c_str());
  if (context->animationManager) LOG_DEBUG(logger, "aniMgr: %s", context->animationManager->getReport().c_str());
  if (context->meshManager) LOG_DEBUG(logger, "mshMgr: %s", context->meshManager->getReport().c_str());
  if (context->modelManager) LOG_DEBUG(logger, "modMgr: %s", context->modelManager->getReport().c_str());
  if (context->effectManager) LOG_DEBUG(logger, "effMgr: %s", context->effectManager->getReport().c_str());
  if (context->materialManager) LOG_DEBUG(logger, "matMgr: %s", context->materialManager->getReport().c_str());
  if (context->materialInstanceManager) LOG_DEBUG(logger, "mInMgr: %s", context->materialInstanceManager->getReport().c_str());
  if (context->fontManager) LOG_DEBUG(logger, "fntMgr: %s", context->fontManager->getReport().c_str());
  if (context->assetManager) LOG_DEBUG(logger, "assMgr: %s", context->assetManager->getReport().c_str());
  if (context->materialDefinitionManager) LOG_DEBUG(logger, "mdfMgr: %s", context->materialDefinitionManager->getReport().c_str());
}