CodeTimings.h

#pragma once
#include <unordered_map>
#include <string>
#include <ostream>
#include <ctime>
#include <cassert>

namespace AL {
namespace maya {


//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
const uint32_t MAX_TIMESTAMP_STACK_SIZE = 16;

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class ProfilerSectionTag
{
  friend class Profiler;
public:

  inline ProfilerSectionTag(
      const std::string sectionName,
      const std::string filePath,
      const size_t lineNumber)
    : m_sectionName(sectionName), m_filePath(filePath), m_lineNumber(lineNumber),
      m_hash(((std::hash<std::string>()(filePath) << 1) ^ (std::hash<size_t>()(lineNumber) << 1)) ^ std::hash<std::string>()(sectionName))
    {}

  inline bool operator == (const ProfilerSectionTag& rhs) const
    {
      return m_hash == rhs.m_hash &&
             m_sectionName == rhs.m_sectionName &&
             m_filePath == rhs.m_filePath &&
             m_lineNumber == rhs.m_lineNumber;
    }

  inline size_t hash() const
    { return m_hash;}

private:
  const std::string m_sectionName; 
  const std::string m_filePath; 
  const size_t m_lineNumber; 
  const size_t m_hash; 
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class ProfilerSectionPath
{
  friend class Profiler;
public:

  inline ProfilerSectionPath(const ProfilerSectionTag* const top, const ProfilerSectionPath* const parent = 0)
    : m_top(top), m_parent(parent), m_hash(m_top->hash() ^ (m_parent ? m_parent->hash() : 0))
    {}

  inline bool operator == (const ProfilerSectionPath& rhs) const
    { return (m_hash == rhs.m_hash && m_top == rhs.m_top && m_parent == rhs.m_parent); }

  inline size_t hash() const
    { return m_hash;}

private:
  const ProfilerSectionTag* const m_top;
  const ProfilerSectionPath* const m_parent;
  const size_t m_hash;
};
} // maya
} // AL

//----------------------------------------------------------------------------------------------------------------------
#ifndef AL_GENERATING_DOCS
namespace std {
template<> struct hash<AL::maya::ProfilerSectionTag> {
  inline size_t operator()(const AL::maya::ProfilerSectionTag& k) const {
    return k.hash();
  }
};
template<> struct hash<AL::maya::ProfilerSectionPath> {
  inline size_t operator()(const AL::maya::ProfilerSectionPath& k) const {
    return k.hash();
  }
};
} // std
#endif

//----------------------------------------------------------------------------------------------------------------------
namespace AL {
namespace maya {
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class Profiler
{
public:

  static void printReport(std::ostream& os);

  static inline void clearAll()
    {
      assert(m_stackPos == 0);
      m_map.clear();
    }

  static void pushTime(const ProfilerSectionTag* entry);

  static void popTime();

private:

  typedef std::unordered_map<ProfilerSectionPath, timespec> ProfilerSectionPathLUT;
  typedef ProfilerSectionPathLUT::const_iterator iter_t;
  static inline bool compareTimeStamps(const iter_t, const iter_t);
  static void print(std::ostream& os, iter_t, const ProfilerSectionPathLUT&, uint32_t, double);

  struct ProfilerSectionStackNode
  {
    timespec m_time;
    const ProfilerSectionTag* m_entry;
    ProfilerSectionPathLUT::iterator m_path;
  };

  static inline timespec timeDiff(const timespec startTime, const timespec endTime)
  {
    if (endTime.tv_nsec < startTime.tv_nsec)
    {
      return (timespec) {
          tv_sec: endTime.tv_sec - 1 - startTime.tv_sec,
          tv_nsec: 1000000000 + endTime.tv_nsec - startTime.tv_nsec
        };
    }
    return (timespec) {
        tv_sec: endTime.tv_sec - startTime.tv_sec,
        tv_nsec: endTime.tv_nsec - startTime.tv_nsec
      };
  }
  static inline timespec timeAdd(timespec t1, timespec t2)
  {
      int32_t sec = t2.tv_sec + t1.tv_sec;
      int32_t nsec = t2.tv_nsec + t1.tv_nsec;
      if (nsec >= 1000000000)
      {
          nsec -= 1000000000;
          sec++;
      }
      return (timespec){ tv_sec: sec, tv_nsec: nsec };
  }

  static ProfilerSectionStackNode m_timeStack[MAX_TIMESTAMP_STACK_SIZE];
  static int32_t m_stackPos;
  static ProfilerSectionPathLUT m_map;
};

//----------------------------------------------------------------------------------------------------------------------
} // maya
} // AL
//----------------------------------------------------------------------------------------------------------------------

#define AL_BEGIN_PROFILE_SECTION(TimedSection) \
  { \
    static const AL::maya::ProfilerSectionTag __entry(#TimedSection, __FILE__, __LINE__); \
    AL::maya::Profiler::pushTime(&__entry); \
  }

#define AL_END_PROFILE_SECTION() \
  { AL::maya::Profiler::popTime(); }