Profiler.hpp

Go to the documentation of this file.

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#pragma once
#endif
#ifndef COMMON_PROFILER_H_
#define COMMON_PROFILER_H_

#include <stack> // :(
#include <map> // :(
#include "DateTime.hpp"
#include "Threads.hpp"

namespace common
{


class Profiler;

enum PROFILER_UNITS {
  PROFILER_UNITS_MILLISECONDS,
  PROFILER_UNITS_SECONDS,
};

class ProfilerItem
{
private:
  // Sumaryczny czas wykonania
  GameTime m_Time;
  // Liczba przebiegów
  uint m_Count;
  // Czas rozpoczęcia bieżącego przebiegu [s]
  GameTime m_StartTime;
  tstring m_strName; // Nazwa elementu
  std::vector<ProfilerItem> m_ItemVector; // Podelementy

  friend class Profiler;
  ProfilerItem * Begin(const tstring &Name);
  void Start() { m_StartTime = GetCurrentGameTime(); }
  void Stop() { m_Time += GetCurrentGameTime() - m_StartTime; m_Count++; }

public:
  ProfilerItem(const tstring &Name);

  const tstring &GetName() { return m_strName; }
  bool Empty() { return m_Count == 0; }
  uint GetCount() { return m_Count; }
  GameTime GetAvgTime() { return Empty() ? GameTime::ZERO : (m_Time / (int8)m_Count); }
  size_t GetItemCount() { return m_ItemVector.size(); }
  ProfilerItem* GetItem(size_t index) { return &m_ItemVector[index]; }
  void FormatString(tstring *S, unsigned dwLevel, PROFILER_UNITS units);
};

class Profiler
{
public:
  Profiler();
  Profiler(const tstring &Name);
  void Begin(const tstring &Name);
  void End();
  ProfilerItem* GetRootItem() { return &m_DefaultItem; }

  void FormatString(tstring *S, PROFILER_UNITS units);

private:
  std::stack<ProfilerItem*> m_ItemStack;
  ProfilerItem m_DefaultItem;
};


class Profile
{
private:
  Profiler &m_Profiler;
public:
  Profile(Profiler &profiler, const tstring &Name);
  ~Profile();
};


template < typename KeyT, typename KeyTraits=std::less<KeyT> >
class FlatProfiler
{
public:
  FlatProfiler() : m_Mutex(0) { }
  void Clear();
  void AddSample(const KeyT &key, GameTime timeInterval);
  void FormatString(tstring *out, PROFILER_UNITS units);

private:
  struct ENTRY
  {
    GameTime SumTime;
    uint Count;
    ENTRY() : SumTime(GameTime::ZERO), Count(0) { }
    GameTime GetAvgTime() const { return SumTime / (int8)Count; }
  };
  typedef std::map<KeyT, ENTRY, KeyTraits> MapType;

  Mutex m_Mutex;
  MapType m_Entries;
};


template < typename KeyT, typename KeyTraits=std::less<KeyT> >
class FlatProfilerSampler
{
public:
  FlatProfilerSampler(FlatProfiler<KeyT, KeyTraits> &profiler, const KeyT &key) : m_Profiler(profiler), m_Key(key), m_StartTime(GetCurrentGameTime()) { }
  ~FlatProfilerSampler() { m_Profiler.AddSample(m_Key, GetCurrentGameTime() - m_StartTime); }

private:
  FlatProfiler<KeyT, KeyTraits> &m_Profiler;
  KeyT m_Key;
  GameTime m_StartTime;
};

template <typename KeyT, typename KeyTraits>
void FlatProfiler<KeyT, KeyTraits>::Clear()
{
  MutexLock lock(m_Mutex);
  m_Entries.clear();
}

template <typename KeyT, typename KeyTraits>
void FlatProfiler<KeyT, KeyTraits>::AddSample(const KeyT &key, GameTime timeInterval)
{
  MutexLock lock(m_Mutex);
  ENTRY &entry = m_Entries[key];
  entry.SumTime += timeInterval;
  entry.Count++;
}

template <typename KeyT, typename KeyTraits>
void FlatProfiler<KeyT, KeyTraits>::FormatString(tstring *out, PROFILER_UNITS units)
{
  MutexLock lock(m_Mutex);

  tstring keyStr;
  for (MapType::iterator it = m_Entries.begin(); it != m_Entries.end(); ++it)
  {
    const ENTRY &entry = it->second;

    SthToStr<KeyT>(&keyStr, it->first);
    *out += keyStr;
    *out += _T(" : ");

    if (units == PROFILER_UNITS_MILLISECONDS)
    {
      *out += DoubleToStrR(entry.GetAvgTime().ToSeconds_d()*1000.);
      *out += _T(" ms (");
    }
    else // PROFILER_UNITS_SECONDS
    {
      *out += DoubleToStrR(entry.GetAvgTime().ToSeconds_d());
      *out += _T(" s (");
    }
    *out += UintToStrR(entry.Count);
    *out += _T(")\n");
  }
}

// code_profiler

} // namespace common

#define PROFILE_GUARD(profiler,Name)   common::Profile __profile_guard_object(profiler, Name);


#endif

---