Skip to content
Permalink
Fetching contributors…
Cannot retrieve contributors at this time
142 lines (116 sloc) 3.81 KB
/**
* @file Profile.h
* @author Jeff Kiah
*/
#pragma once
#ifndef GRIFFIN_PROFILE_H
#define GRIFFIN_PROFILE_H
#include <cstdint>
#include <string>
#include <utility/auto_lister.h>
#include "ProfileAggregate.h"
#include <utility/concurrency.h>
#include <boost/container/flat_map.hpp>
using boost::container::flat_map;
using namespace std;
// Macros
#if defined(GRIFFIN_PROFILE) && (GRIFFIN_PROFILE == 1)
#define PROFILE_BLOCK(name, frame, thread) griffin::Profile<thread> profile_(frame, name, __FILE__, __LINE__);
#else
#define PROFILE_BLOCK(...)
#endif
namespace griffin {
typedef flat_map<intptr_t, ProfileAggregate> ProfileAggregateMap;
extern monitor<ProfileAggregateMap> g_aggregates;
/**
* @class Profile
* Profile is an RAII-type container meant to be placed on the stack and will time from
* creation to destruction.
*
* Profile must be thread safe but should not introduce locks that increase contention of the
* normally running program. For this reason, unique storage is required for each thread that
* is profiled, including a separate stack of Profiles and a separate ProfileAggregate. A
* master index of references to all thread-specific lists is kept. This can be problematic for
* thread pools when the same task can be picked up by any worker thread at random. The
* information for one task will be spread over several lists, but you would actually want to
* see it combined into one aggregated entry. A post processing step could look at all of the
* thread lists and combine split profiles by name, and also indicate how many unique threads
* the profile was run on over its lifetime.
*
* std::this_thread::get_id().hash() is used to index each thread in the master map
*/
template <int Th>
struct Profile : auto_stacker<Profile<Th>> {
int64_t m_frame; //!< frame the code block is called on
int64_t m_startCounts; //!< counts at start of profiling block
const char* m_name; //!< name of this profile
const char* m_file; //!< source file (from macro)
int m_line; //!< line number of profile start (from macro)
/**
* Constructor
* @param frame frame number of profiling step
* @param name unique name of this profile block
* @param file source file of the profile block
* @param line line number of the profile block start
*/
Profile(int64_t frame, const char* name, const char* file, int line);
/**
* Destructor
*/
~Profile();
/**
*
*/
const char* getParentName() const;
/**
* get the full path of nested profile blocks
*/
std::string getPath() const;
};
// TEMP
template <int Th>
Profile<Th>::Profile(int64_t frame, const char* name, const char* file, int line) :
m_frame{ frame },
m_name{ name },
m_file{ file },
m_line{ line }
{
m_startCounts = Timer::queryCounts();
}
template <int Th>
Profile<Th>::~Profile() {
auto countsPassed = Timer::countsSince(m_startCounts);
//auto threadIdHash = this_thread::get_id().hash();
//auto& threadAggregates = getThreadAggregates(threadIdHash);
g_aggregates([=](ProfileAggregateMap& aggMap) {
// thread safe function
auto size = aggMap.size();
auto& agg = aggMap[reinterpret_cast<intptr_t>(m_name)]; // get or create the block aggregate
if (aggMap.size() == size + 1) { // if newly created
agg.init(m_name, getParentName(), getPath());
}
agg.invoke(countsPassed, m_frame);
});
}
template <int Th>
const char* Profile<Th>::getParentName() const {
const char* parentName = nullptr;
auto s = stack().size();
if (s > 1) {
auto parent = stack()[s - 2];
parentName = parent->m_name;
}
return parentName;
}
template <int Th>
string Profile<Th>::getPath() const {
string path;
path.reserve(100);
for (auto p : stack()) {
path.append(p->m_name);
if (p != this) { path.append("/"); }
}
return std::move(path);
}
}
#endif
You can’t perform that action at this time.