Skip to content
Snippets Groups Projects
Commit 0679e1d3 authored by 数学の武士's avatar 数学の武士
Browse files

Separate event classes

parent d065eaa3
No related branches found
No related tags found
No related merge requests found
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
cmake_minimum_required(VERSION 3.0)
enable_language(CXX)
enable_language(CUDA)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD 11)
project(timer)
......
......@@ -5,25 +5,8 @@
using namespace std;
#ifdef INCLUDE_GPU_TIMER
void EventData::InitEventsCUDA()
void EventData::InitEventsCUDA(cudaEvent_t &event)
{
cudaEventCreate(&(this->gpu_start));
cudaEventCreate(&(this->gpu_end));
this->ifCUDAinit = true;
}
void EventData::DeinitEventsCUDA()
{
if((this->ifCUDAinit))
{
// cudaError_t stat = cudaEventDestroy(this->gpu_start);
// cout << "gpu_star: " << cudaGetErrorString(stat) << endl;
// stat = cudaEventDestroy(this->gpu_end);
// cout << "gpu_end: " << cudaGetErrorString(stat) << endl;
this->ifCUDAinit = false;
}
cudaEventCreate(&event);
}
#endif
\ No newline at end of file
......@@ -14,37 +14,87 @@ typedef std::chrono::steady_clock::time_point chrono_time_type;
class EventData{
public:
#ifdef INCLUDE_GPU_TIMER
cudaEvent_t gpu_start, gpu_end;
#endif
bool if_mode_set; // If measurment type (MPI, OpenMP ...) is set
bool ifCUDAinit; // If CUDA variables are initialized
bool ifStart, ifEnd; // If measurment for current code block is started/finished
double elapsed_time, double_start; // seconds
double ContiniousTime;
int count; // Count of current code block measurments
chrono_time_type start;
std::vector<double> time_series; // Measurments time series for current code block
std::string event_name; // Name ID for current code block
std::vector<bool> mode; // Measurment type for current code block. Order: mode[0] ~ if MPI, mode[1] ~ if OpenMP, mode[2] ~ if CUDA
EventData();
~EventData();
EventData(const std::string& name);
EventData& operator=(const EventData& src);
double GetMeanElapsedTime(); // elapsed_time / count for each measuring code block
void GetModeVals(const int& mode); //
void GetModeVals(const int mode); //
std::string GetEventModeName(); // Generate measure type for current code block (used for dump), for example "MPI", "MPI_OpenMP" etc.
private:
void InitEventsCUDA();
void DeinitEventsCUDA();
// private:
#ifdef INCLUDE_GPU_TIMER
void InitEventsCUDA(cudaEvent_t &event);
#endif
};
class StartEventData : public EventData
{
public:
#ifdef INCLUDE_GPU_TIMER
cudaEvent_t gpu_start;
#endif
bool ifCUDAinit; // If CUDA variables are initialized
double double_start;
chrono_time_type start;
StartEventData();
~StartEventData();
StartEventData(const std::string& name);
StartEventData& operator=(const StartEventData& src);
};
class EndEventData : public EventData
{
public:
#ifdef INCLUDE_GPU_TIMER
cudaEvent_t gpu_end;
#endif
bool ifCUDAinit; // If CUDA variables are initialized
double double_end;
chrono_time_type end;
// void MPISync();
// void OpenMPSync();
// void CUDASyncStart();
// void CUDASyncEnd();
EndEventData();
~EndEventData();
EndEventData(const std::string& name);
EndEventData& operator=(const EndEventData& src);
};
// class StartEventData{
// public:
// #ifdef INCLUDE_GPU_TIMER
// cudaEvent_t gpu_start, gpu_end;
// #endif
// bool if_mode_set; // If measurment type (MPI, OpenMP ...) is set
// bool ifCUDAinit; // If CUDA variables are initialized
// bool ifStart, ifEnd; // If measurment for current code block is started/finished
// double elapsed_time, double_start; // seconds
// double ContiniousTime;
// int count; // Count of current code block measurments
// chrono_time_type start, end;
// std::vector<double> time_series; // Measurments time series for current code block
// std::string event_name; // Name ID for current code block
// std::vector<bool> mode; // Measurment type for current code block. Order: mode[0] ~ if MPI, mode[1] ~ if OpenMP, mode[2] ~ if CUDA
// EventData();
// ~EventData();
// EventData(const std::string& name);
// EventData& operator=(const EventData& src);
// double GetMeanElapsedTime(); // elapsed_time / count for each measuring code block
// void GetModeVals(const int& mode); //
// std::string GetEventModeName(); // Generate measure type for current code block (used for dump), for example "MPI", "MPI_OpenMP" etc.
// private:
// void InitEventsCUDA();
// void DeinitEventsCUDA();
// // void MPISync();
// // void OpenMPSync();
// // void CUDASyncStart();
// // void CUDASyncEnd();
// };
\ No newline at end of file
......@@ -16,11 +16,11 @@ extern "C"
Timer.JikanStart(str_name, mode);
}
void TimerEnd(const char* name, const int cont_mode_t)
void TimerEnd(const char* name, const int mode_t, const int cont_mode_t)
{
string str_name = name;
Timer.JikanEnd(str_name, cont_mode_t);
Timer.JikanEnd(str_name, mode_t, cont_mode_t);
}
void WriteOutput()
......
......@@ -38,16 +38,16 @@ extern "C" {
#endif
void TimerStart(const char* name, const int mode_t);
void TimerEnd(const char* name, const int cont_mode_t);
void TimerEnd (const char* name, const int mode_t, const int cont_mode_t);
void WriteOutput();
#ifdef TIMER_ON
#define START_JIKAN_TIMER(name, mode_t) TimerStart(name, mode_t);
#define END_JIKAN_TIMER(name, cont_mode_t) TimerEnd(name, cont_mode_t);
#define END_JIKAN_TIMER(name, mode_t, cont_mode_t) TimerEnd(name, mode_t, cont_mode_t);
#define JIKAN_TIMER_OUTPUT() WriteOutput();
#else
#define START_JIKAN_TIMER(name, mode_t)
#define END_JIKAN_TIMER(name)
#define END_JIKAN_TIMER(name, mode_t, cont_mode_t)
#define JIKAN_TIMER_OUTPUT()
#endif
......
......@@ -20,6 +20,9 @@ Jikan::Jikan()
this->EventType["Synchronous events"] = set<string>();
this->EventType["Asynchronous events"] = set<string>();
this->Start = vector<StartEventData> ();
this->End = vector<EndEventData> ();
this->JSONname = OUTPUT_NAME + string(".json");
this->JSONdata = "";
this->Error = "";
......@@ -85,12 +88,16 @@ Jikan::~Jikan()
#endif
this->Events.clear();
unordered_map<string, set<string> >::iterator it;
map<string, set<string> >::iterator it;
for(it = this->EventType.begin(); it!=this->EventType.end(); ++it)
it->second.clear();
this->EventType.clear();
this->Start.clear();
this->End.clear();
#ifdef INCLUDE_OPEN_MP
}
#endif
......@@ -98,7 +105,7 @@ Jikan::~Jikan()
bool Jikan::ifContains(const string& Name)
{
unordered_map<string, EventData>::iterator it;
map<string, EventData>::iterator it;
it = this->Events.find(Name);
if (it == this->Events.end())
......@@ -107,30 +114,17 @@ bool Jikan::ifContains(const string& Name)
return true;
}
void Jikan::JikanStart(const string& name, const int& mode)
{
bool ExistFlag, ifMPI, ifOpenMP;
ExistFlag = this->ifContains(name);
if(!ExistFlag)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
void Jikan::JikanStart(const string& name, const int mode)
{
#endif
(this->Events)[name] = EventData(name);
(this->Events)[name].GetModeVals(mode);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
bool ifMPI, ifOpenMP;
int CurrEventID = this->Start.size();
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
(this->Events)[name].ifStart = true;
// printf("(this->Events)[name].ifStart = %d\n", (this->Events)[name].ifStart);
this->Start.push_back(StartEventData(name));
(this->Start)[CurrEventID].GetModeVals(mode);
#ifdef INCLUDE_OPEN_MP
}
#endif
......@@ -139,24 +133,12 @@ void Jikan::JikanStart(const string& name, const int& mode)
#pragma omp barrier
#endif
ifMPI = (this->Events)[name].mode[0], ifOpenMP = (this->Events)[name].mode[1];
ifMPI = (this->Start)[CurrEventID].mode[0], ifOpenMP = (this->Start)[CurrEventID].mode[1];
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
if(!ExistFlag)
{
string EventTypeName;
if(mode == TimerMode::NO_SYNC)
EventTypeName = "Asynchronous events";
else
EventTypeName = "Synchronous events";
this->EventType[EventTypeName].insert(name);
}
//--------------------------- MPI synchronization ---------------------------------------
if(ifMPI)
this->BarrierMPI();
......@@ -178,38 +160,24 @@ void Jikan::JikanStart(const string& name, const int& mode)
#pragma omp master
{
#endif
this->StartEvent(name);
this->StartEvent((this->Start)[CurrEventID]);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
void Jikan::JikanEnd(const string& name, const int cont_mode_t)
{
bool ExistFlag, ifStart;
bool ifMPI, ifOpenMP, ifCUDA;
ExistFlag = this->ifContains(name);
ifStart = (this->Events)[name].ifStart;
if((!ExistFlag) || (!ifStart))
void Jikan::JikanEnd(const string& name, const int mode, const int cont_mode_t)
{
return;
}
bool ifMPI = (this->Events)[name].mode[0], ifOpenMP = (this->Events)[name].mode[1], ifCUDA = (this->Events)[name].mode[2];
ifMPI = (this->Events)[name].mode[0], ifOpenMP = (this->Events)[name].mode[1], ifCUDA = (this->Events)[name].mode[2];
int CurrEventID = this->End.size();
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
if((ifCUDA) && (!ifMPI) && (!ifOpenMP))
{
#ifdef INCLUDE_GPU_TIMER
this->EndCUDASync(name);
this->CUDAGetTime(name, cont_mode_t);
#endif
}
this->End.push_back(EndEventData(name));
(this->End)[CurrEventID].GetModeVals(mode);
#ifdef INCLUDE_OPEN_MP
}
#endif
......@@ -231,12 +199,11 @@ void Jikan::JikanEnd(const string& name, const int cont_mode_t)
if(ifMPI)
this->BarrierMPI();
this->EndEvent(name, cont_mode_t);
this->EndEvent((this->End)[CurrEventID], cont_mode_t);
#ifdef INCLUDE_OPEN_MP
}
#endif
//---------------------------------------------------------------------------------------
(this->Events)[name].ifStart = false;
}
void Jikan::GenerateTypedOutputData(const string& EventType, string& EventTypeString)
......@@ -256,53 +223,54 @@ void Jikan::GenerateTypedOutputData(const string& EventType, string& EventTypeSt
set<string>::iterator end_m = this->EventType[EventType].end();
--end_m;
for (it = this->EventType[EventType].begin(); it != end_m; ++it)
{
Name = *it;
JSON::GenerateRow(this->Events[Name], Row, JSON::SeparateRows);
EventTypeString += Row;
}
// for (it = this->EventType[EventType].begin(); it != end_m; ++it)
// {
// Name = *it;
// JSON::GenerateRow(this->Events[Name], Row, JSON::SeparateRows);
// EventTypeString += Row;
// }
Name = *end_m;
JSON::GenerateRow(this->Events[Name], Row, JSON::FinishRows);
EventTypeString += Row;
// Name = *end_m;
// JSON::GenerateRow(this->Events[Name], Row, JSON::FinishRows);
// EventTypeString += Row;
}
void Jikan::GenerateOutputData()
{
unordered_map<string, set<string> >::iterator it;
unordered_map<string, set<string> >::iterator end_m;
printf("%d\n", this->Start.size());
// map<string, set<string> >::iterator it;
// map<string, set<string> >::iterator end_m;
string Name;
string Out = "{ ";
string TypedOutput;
// string Name;
// string Out = "{ ";
// string TypedOutput;
for(it = this->EventType.begin(); it!=this->EventType.end(); ++it)
{
if(next(it) != this->EventType.end())
{
Name = it->first;
TypedOutput = "";
this->GenerateTypedOutputData(Name, TypedOutput);
Out += TypedOutput + ",\n";
}
else
end_m = it;
}
// for(it = this->EventType.begin(); it!=this->EventType.end(); ++it)
// {
// if(next(it) != this->EventType.end())
// {
// Name = it->first;
// TypedOutput = "";
// this->GenerateTypedOutputData(Name, TypedOutput);
// Out += TypedOutput + ",\n";
// }
// else
// end_m = it;
// }
Name = end_m->first;
TypedOutput = "";
this->GenerateTypedOutputData(Name, TypedOutput);
Out += TypedOutput + "\n}";
// Name = end_m->first;
// TypedOutput = "";
// this->GenerateTypedOutputData(Name, TypedOutput);
// Out += TypedOutput + "\n}";
this->JSONdata = Out;
// this->JSONdata = Out;
bool OutputRes = JSON::WriteOutput(this->JSONname, this->JSONdata);
// bool OutputRes = JSON::WriteOutput(this->JSONname, this->JSONdata);
if(OutputRes != true)
{
this->Error = JSON::Error;
}
// if(OutputRes != true)
// {
// this->Error = JSON::Error;
// }
}
void Jikan::SetDumpFilename(const string& name)
......@@ -310,86 +278,47 @@ void Jikan::SetDumpFilename(const string& name)
this->JSONname = name;
}
void Jikan::StartEvent(const string& name)
void Jikan::StartEvent(StartEventData& Event)
{
bool ifMPI = (this->Events)[name].mode[0], ifOpenMP = (this->Events)[name].mode[1], ifCUDA = (this->Events)[name].mode[2];
bool ifMPI = Event.mode[0], ifOpenMP = Event.mode[1], ifCUDA = Event.mode[2];
if((ifCUDA))
{
#ifdef INCLUDE_GPU_TIMER
// printf("StartCUDASync\n");
this->StartCUDASync(name);
this->StartCUDASync(Event);
#endif
}
#ifdef INCLUDE_OPEN_MP
else if( (!ifMPI) && (ifOpenMP) )
(this->Events)[name].double_start = omp_get_wtime();
Event.double_start = omp_get_wtime();
#endif
else
(this->Events)[name].start = chrono::steady_clock::now();
Event.start = chrono::steady_clock::now();
}
#define btoa(x) ((x)?"true":"false")
void Jikan::EndEvent(const string& name, const int cont_mode_t)
void Jikan::EndEvent(EndEventData& Event, const int cont_mode_t)
{
bool ifMPI = (this->Events)[name].mode[0], ifOpenMP = (this->Events)[name].mode[1], ifCUDA = (this->Events)[name].mode[2];
bool ifMPI = Event.mode[0], ifOpenMP = Event.mode[1], ifCUDA = Event.mode[2];
if(ifCUDA)
{
#ifdef INCLUDE_GPU_TIMER
this->EndCUDASync(name);
this->EndCUDASync(Event);
#endif
}
#ifdef INCLUDE_OPEN_MP
else if( (!ifMPI) && (ifOpenMP))
else if( (!ifCUDA) && (!ifMPI) && (ifOpenMP))
{
double end = omp_get_wtime();
double main_elapsed = end - (this->Events)[name].double_start;
(this->Events)[name].elapsed_time += main_elapsed;
(this->Events)[name].ContiniousTime += main_elapsed;
if(cont_mode_t == 0)
{
(this->Events)[name].count ++;
}
#ifdef SAVE_TIME_SERIES
if(cont_mode_t == 0)
{
(this->Events)[name].time_series.push_back((this->Events)[name].ContiniousTime);
(this->Events)[name].ContiniousTime = 0.0;
}
#endif
}
#endif
else
else if(!ifCUDA && !ifOpenMP)
{
chrono_time_type end = chrono::steady_clock::now();
chrono_time_type start = (this->Events)[name].start;
double main_elapsed = chrono::duration_cast<chrono::nanoseconds>(end - start).count() * 1e-9;
(this->Events)[name].elapsed_time += main_elapsed;
(this->Events)[name].ContiniousTime += main_elapsed;
if(cont_mode_t == 0)
{
(this->Events)[name].count ++;
}
#ifdef SAVE_TIME_SERIES
if(cont_mode_t == 0)
{
(this->Events)[name].time_series.push_back((this->Events)[name].ContiniousTime);
(this->Events)[name].ContiniousTime = 0.0;
}
#endif
Event.end = chrono::steady_clock::now();
}
}
......
......@@ -10,36 +10,36 @@
using namespace std;
#ifdef INCLUDE_GPU_TIMER
void Jikan::StartCUDASync(const string& name)
void Jikan::StartCUDASync(StartEventData& Event)
{
cudaEventRecord ((this->Events)[name].gpu_start);
cudaEventRecord (Event.gpu_start);
}
void Jikan::EndCUDASync(const string& name)
void Jikan::EndCUDASync(EndEventData& Event)
{
cudaEventRecord((this->Events)[name].gpu_end);
cudaEventSynchronize((this->Events)[name].gpu_end);
cudaEventRecord(Event.gpu_end);
cudaEventSynchronize(Event.gpu_end);
}
void Jikan::CUDAGetTime(const string& name, const int cont_mode_t)
{
float GPUtime = 0.0;
cudaEventElapsedTime(&GPUtime, (this->Events)[name].gpu_start, (this->Events)[name].gpu_end );
GPUtime *= 1e-3;
(this->Events)[name].elapsed_time += GPUtime;
(this->Events)[name].ContiniousTime += GPUtime;
// void Jikan::CUDAGetTime(EventData& Event, const int cont_mode_t)
// {
// float GPUtime = 0.0;
// cudaEventElapsedTime(&GPUtime, Event.gpu_start, Event.gpu_end );
// GPUtime *= 1e-3;
// Event.elapsed_time += GPUtime;
// Event.ContiniousTime += GPUtime;
if(cont_mode_t == 0)
{
(this->Events)[name].count ++;
}
// if(cont_mode_t == 0)
// {
// Event.count ++;
// }
#ifdef SAVE_TIME_SERIES
if(cont_mode_t == 0)
{
(this->Events)[name].time_series.push_back((this->Events)[name].ContiniousTime);
(this->Events)[name].ContiniousTime = 0.0;
}
#endif
}
// #ifdef SAVE_TIME_SERIES
// if(cont_mode_t == 0)
// {
// Event.time_series.push_back(Event.ContiniousTime);
// Event.ContiniousTime = 0.0;
// }
// #endif
// }
#endif
\ No newline at end of file
......@@ -6,7 +6,7 @@
#include <iostream>
#include <string>
#include <set>
#include <unordered_map>
#include <map>
#ifdef INCLUDE_MPI
#include <mpi.h>
......@@ -15,12 +15,11 @@
class Jikan
{
public:
EventData Start[60000];
EventData End[60000];
int last_used_start, last_used_end;
std::vector<StartEventData> Start;
std::vector<EndEventData> End;
std::unordered_map<std::string, EventData> Events; // Measuring code blocks info: string = code block name ID, EventData = measuring code block data
std::unordered_map<std::string, std::set<std::string> > EventType; // Code blocks measurment types: synchronious or ansynchronious
std::map<std::string, EventData> Events; // Measuring code blocks info: string = code block name ID, EventData = measuring code block data
std::map<std::string, std::set<std::string> > EventType; // Code blocks measurment types: synchronious or ansynchronious
std::string JSONname; // Measurments dump filename
std::string JSONdata; // Dump string
std::string Error; // Dump error ?
......@@ -28,12 +27,12 @@ public:
Jikan();
~Jikan();
void JikanStart(const std::string& name, const int& mode); // Start code block measurments
void JikanEnd( const std::string& name, const int cont_mode_t); // End code block measurments
void JikanStart(const std::string& name, const int mode); // Start code block measurments
void JikanEnd( const std::string& name, const int mode, const int cont_mode_t); // End code block measurments
#ifdef INCLUDE_GPU_TIMER
void StartCUDASync(const std::string& name); // Start CUDA synchronization
void EndCUDASync( const std::string& name); // End CUDA synchronization
void StartCUDASync( StartEventData& Event); // Start CUDA synchronization
void EndCUDASync( EndEventData& Event); // End CUDA synchronization
#endif
void GenerateTypedOutputData(const std::string& EventType, std::string& EventTypeString);
......@@ -51,10 +50,10 @@ public:
private:
void BarrierMPI(); // Start MPI barrier
void StartEvent(const std::string& name);
void EndEvent(const std::string& name, const int cont_mode_t);
void StartEvent(StartEventData& Event);
void EndEvent(EndEventData& Event, const int cont_mode_t);
#ifdef INCLUDE_GPU_TIMER
void CUDAGetTime(const std::string& name, const int cont_mode_t);
// void CUDAGetTime(EventData& Event, const int cont_mode_t);
#endif
};
\ No newline at end of file
......@@ -45,43 +45,43 @@ string Number2String(const double Val)
return NumberAsString;
}
bool JSON::GenerateRow(EventData Event, string &ResRow, const string& EndRowJSON)
{
string EventModeName = JSON::StartSubRow("Event mode") + "\"" + Event.GetEventModeName() + "\"" + JSON::SeparateSubRows;
string FullElapsedTime = JSON::StartSubRow(string("Full elapsed time")) + Number2String(Event.elapsed_time) + JSON::SeparateSubRows;
double mean_elapsed = Event.GetMeanElapsedTime();
string MeanElapsedTime = JSON::StartSubRow(string("Mean elapsed time")) + Number2String(mean_elapsed) + JSON::SeparateSubRows;
string TimeSeries = JSON::StartSubRow(string("Time series")) + "[";
int TimeSeriesLen = Event.time_series.size();
for (int i = 0; i < TimeSeriesLen - 1; i++)
{
// ostringstream StrTSValue;
// StrTSValue << Event.time_series[i];
// string strObj = StrTSValue.str();
// // printf("Event.time_series[i] = %e, AccurateValue %s\n", Event.time_series[i], AccurateValue);
// TimeSeries += strObj + ", ";
TimeSeries += Number2String(Event.time_series[i]) + ", ";
}
if(TimeSeriesLen != 0)
{
// ostringstream StrTSValue;
// StrTSValue << Event.time_series[TimeSeriesLen - 1];
// string strObj = StrTSValue.str();
TimeSeries += Number2String(Event.time_series[TimeSeriesLen - 1]);
}
TimeSeries += "]" ;
// printf("TimeSeries %s\n", TimeSeries.c_str());
string JSONrow = JSON::StartSubRow(Event.event_name) + "{" + EventModeName + FullElapsedTime + MeanElapsedTime + TimeSeries + EndRowJSON;
ResRow = JSONrow;
return true;
}
// bool JSON::GenerateRow(EventData Event, string &ResRow, const string& EndRowJSON)
// {
// string EventModeName = JSON::StartSubRow("Event mode") + "\"" + Event.GetEventModeName() + "\"" + JSON::SeparateSubRows;
// string FullElapsedTime = JSON::StartSubRow(string("Full elapsed time")) + Number2String(Event.elapsed_time) + JSON::SeparateSubRows;
// double mean_elapsed = Event.GetMeanElapsedTime();
// string MeanElapsedTime = JSON::StartSubRow(string("Mean elapsed time")) + Number2String(mean_elapsed) + JSON::SeparateSubRows;
// string TimeSeries = JSON::StartSubRow(string("Time series")) + "[";
// int TimeSeriesLen = Event.time_series.size();
// for (int i = 0; i < TimeSeriesLen - 1; i++)
// {
// // ostringstream StrTSValue;
// // StrTSValue << Event.time_series[i];
// // string strObj = StrTSValue.str();
// // // printf("Event.time_series[i] = %e, AccurateValue %s\n", Event.time_series[i], AccurateValue);
// // TimeSeries += strObj + ", ";
// TimeSeries += Number2String(Event.time_series[i]) + ", ";
// }
// if(TimeSeriesLen != 0)
// {
// // ostringstream StrTSValue;
// // StrTSValue << Event.time_series[TimeSeriesLen - 1];
// // string strObj = StrTSValue.str();
// TimeSeries += Number2String(Event.time_series[TimeSeriesLen - 1]);
// }
// TimeSeries += "]" ;
// // printf("TimeSeries %s\n", TimeSeries.c_str());
// string JSONrow = JSON::StartSubRow(Event.event_name) + "{" + EventModeName + FullElapsedTime + MeanElapsedTime + TimeSeries + EndRowJSON;
// ResRow = JSONrow;
// return true;
// }
bool JSON::WriteOutput(const string& Filename, const string& OutputData)
{
......
......@@ -13,6 +13,6 @@ public:
static std::string SeparateSubRows;
static std::string SeparateRows;
static std::string FinishRows;
static bool GenerateRow(EventData Event, std::string &ResRow, const std::string& name);
// static bool GenerateRow(EventData Event, std::string &ResRow, const std::string& name);
static bool WriteOutput(const std::string& Filename, const std::string& OutputData);
};
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment