netgen/libsrc/core/paje_trace.hpp

194 lines
5.4 KiB
C++
Raw Normal View History

2019-01-02 22:38:03 +05:00
#ifndef NETGEN_CORE_PAJE_TRACE_HPP
#define NETGEN_CORE_PAJE_TRACE_HPP
#include <limits>
#include <vector>
#include "logging.hpp" // for logger
2019-01-03 19:54:50 +05:00
#include "ngcore_api.hpp" // for NGCORE_API
#include "utils.hpp"
2019-01-02 22:38:03 +05:00
namespace ngcore
{
extern NGCORE_API class PajeTrace *trace;
class PajeTrace
{
public:
2019-01-03 19:54:50 +05:00
using TClock = std::chrono::system_clock;
2019-01-02 22:38:03 +05:00
protected:
2019-01-16 18:33:48 +05:00
std::shared_ptr<Logger> logger = GetLogger("PajeTrace");
2019-01-02 22:38:03 +05:00
private:
NGCORE_API static size_t max_tracefile_size;
NGCORE_API static bool trace_thread_counter;
NGCORE_API static bool trace_threads;
2019-01-02 22:38:03 +05:00
bool tracing_enabled;
TTimePoint start_time;
int nthreads;
public:
void WriteSunburstHTML();
2019-01-02 22:38:03 +05:00
// Approximate number of events to trace. Tracing will
// be stopped if any thread reaches this number of events
unsigned int max_num_events_per_thread;
static void SetTraceThreads( bool atrace_threads )
{
trace_threads = atrace_threads;
}
static void SetTraceThreadCounter( bool trace_threads )
{
trace_thread_counter = trace_threads;
}
static void SetMaxTracefileSize( size_t max_size )
{
max_tracefile_size = max_size;
}
std::string tracefile_name;
struct Job
{
int job_id;
const std::type_info *type;
TTimePoint start_time;
TTimePoint stop_time;
};
struct Task
{
int thread_id;
int id;
int id_type;
int additional_value;
TTimePoint start_time;
TTimePoint stop_time;
static constexpr int ID_NONE = -1;
static constexpr int ID_JOB = 1;
static constexpr int ID_TIMER = 2;
};
struct TimerEvent
{
int timer_id;
TTimePoint time;
bool is_start;
int thread_id;
bool operator < (const TimerEvent & other) const { return time < other.time; }
};
struct ThreadLink
{
int thread_id;
int key;
TTimePoint time;
bool is_start;
bool operator < (const ThreadLink & other) const { return time < other.time; }
};
std::vector<std::vector<Task> > tasks;
std::vector<Job> jobs;
std::vector<TimerEvent> timer_events;
std::vector<std::vector<ThreadLink> > links;
public:
NGCORE_API void StopTracing();
2019-01-03 19:54:50 +05:00
PajeTrace() = delete;
PajeTrace(const PajeTrace &) = delete;
PajeTrace(PajeTrace &&) = delete;
NGCORE_API PajeTrace(int anthreads, std::string aname = "");
NGCORE_API ~PajeTrace();
2019-01-02 22:38:03 +05:00
2019-01-03 19:54:50 +05:00
void operator=(const PajeTrace &) = delete;
void operator=(PajeTrace &&) = delete;
2019-01-02 22:38:03 +05:00
void StartTimer(int timer_id)
{
if(!tracing_enabled) return;
if(unlikely(timer_events.size() == max_num_events_per_thread))
StopTracing();
2019-01-03 19:54:50 +05:00
timer_events.push_back(TimerEvent{timer_id, GetTimeCounter(), true});
2019-01-02 22:38:03 +05:00
}
void StopTimer(int timer_id)
{
if(!tracing_enabled) return;
if(unlikely(timer_events.size() == max_num_events_per_thread))
StopTracing();
2019-01-03 19:54:50 +05:00
timer_events.push_back(TimerEvent{timer_id, GetTimeCounter(), false});
2019-01-02 22:38:03 +05:00
}
NETGEN_INLINE int StartTask(int thread_id, int id, int id_type = Task::ID_NONE, int additional_value = -1)
{
if(!tracing_enabled) return -1;
if(!trace_threads && !trace_thread_counter) return -1;
if(unlikely(tasks[thread_id].size() == max_num_events_per_thread))
StopTracing();
int task_num = tasks[thread_id].size();
2019-01-03 19:54:50 +05:00
tasks[thread_id].push_back( Task{thread_id, id, id_type, additional_value, GetTimeCounter()} );
2019-01-02 22:38:03 +05:00
return task_num;
}
void StopTask(int thread_id, int task_num)
{
if(!trace_threads && !trace_thread_counter) return;
if(task_num>=0)
2019-01-03 19:54:50 +05:00
tasks[thread_id][task_num].stop_time = GetTimeCounter();
2019-01-02 22:38:03 +05:00
}
void SetTask(int thread_id, int task_num, int additional_value) {
if(!trace_threads && !trace_thread_counter) return;
if(task_num>=0)
tasks[thread_id][task_num].additional_value = additional_value;
}
void StartJob(int job_id, const std::type_info & type)
{
if(!tracing_enabled) return;
if(jobs.size() == max_num_events_per_thread)
StopTracing();
2019-01-03 19:54:50 +05:00
jobs.push_back( Job{job_id, &type, GetTimeCounter()} );
2019-01-02 22:38:03 +05:00
}
void StopJob()
{
if(tracing_enabled)
2019-01-03 19:54:50 +05:00
jobs.back().stop_time = GetTimeCounter();
2019-01-02 22:38:03 +05:00
}
void StartLink(int thread_id, int key)
{
if(!tracing_enabled) return;
if(links[thread_id].size() == max_num_events_per_thread)
StopTracing();
2019-01-03 19:54:50 +05:00
links[thread_id].push_back( ThreadLink{thread_id, key, GetTimeCounter(), true} );
2019-01-02 22:38:03 +05:00
}
void StopLink(int thread_id, int key)
{
if(!tracing_enabled) return;
if(links[thread_id].size() == max_num_events_per_thread)
StopTracing();
2019-01-03 19:54:50 +05:00
links[thread_id].push_back( ThreadLink{thread_id, key, GetTimeCounter(), false} );
2019-01-02 22:38:03 +05:00
}
2019-01-03 19:54:50 +05:00
void Write( const std::string & filename );
2019-01-02 22:38:03 +05:00
2020-08-07 15:01:49 +05:00
void SendData(); // MPI parallel data reduction
2019-01-02 22:38:03 +05:00
};
2019-01-03 19:54:50 +05:00
} // namespace ngcore
2019-01-02 22:38:03 +05:00
#endif // NETGEN_CORE_PAJE_TRACE_HPP