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

Seems workable

parent f66fad20
No related branches found
No related tags found
No related merge requests found
......@@ -12,26 +12,25 @@ using namespace std;
EventData::EventData()
{
this->event_name = "Unnamed";
this->mode = vector<bool>();
}
EventData::~EventData(){}
void EventData::GetModeVals(const int mode)
{
if((mode == TimerMode::MPI_mode) || (mode == TimerMode::MPI_OpenMP) || (mode == TimerMode::MPI_CUDA) || (mode == TimerMode::MPI_OpenMP_CUDA))
this->mode.push_back(true);
this->mode[0] = true;
else
this->mode.push_back(false);
this->mode[0] = false;
if((mode == TimerMode::OpenMP_mode) || (mode == TimerMode::MPI_OpenMP) || (mode == TimerMode::OpenMP_CUDA) || (mode == TimerMode::MPI_OpenMP_CUDA))
this->mode.push_back(true);
this->mode[1] = true;
else
this->mode.push_back(false);
this->mode[1] = false;
if((mode == TimerMode::CUDA_mode) || (mode == TimerMode::MPI_CUDA) || (mode == TimerMode::OpenMP_CUDA) || (mode == TimerMode::MPI_OpenMP_CUDA))
this->mode.push_back(true);
this->mode[2] = true;
else
this->mode.push_back(false);
this->mode[2] = false;
}
string EventData::GetEventModeName()
......@@ -87,7 +86,7 @@ StartEventData::StartEventData(const string& name)
this->double_start = 0.0;
this->start = chrono::steady_clock::now();
this->event_name = name;
191284
#ifdef INCLUDE_GPU_TIMER
this->InitEventsCUDA(this->gpu_start);
#endif
......@@ -98,7 +97,10 @@ StartEventData& StartEventData::operator=(const StartEventData& src)
this->double_start = src.double_start;
this->start = src.start;
this->event_name = src.event_name;
this->mode = src.mode;
for (int i = 0; i < 3; i++)
this->mode[i] = src.mode[i];
#ifdef INCLUDE_GPU_TIMER
this->InitEventsCUDA(this->gpu_start);
......@@ -114,6 +116,7 @@ EndEventData::EndEventData()
this->double_end = 0.0;
this->end = chrono::steady_clock::now();
this->event_name = "Unnamed";
this->cont_mode = false;
#ifdef INCLUDE_GPU_TIMER
this->InitEventsCUDA(this->gpu_end);
......@@ -127,6 +130,7 @@ EndEventData::EndEventData(const string& name)
this->double_end = 0.0;
this->end = chrono::steady_clock::now();
this->event_name = name;
this->cont_mode = false;
#ifdef INCLUDE_GPU_TIMER
this->InitEventsCUDA(this->gpu_end);
......@@ -138,7 +142,10 @@ EndEventData& EndEventData::operator=(const EndEventData& src)
this->double_end = src.double_end;
this->end = src.end;
this->event_name = src.event_name;
this->mode = src.mode;
this->cont_mode = src.cont_mode;
for (int i = 0; i < 3; i++)
this->mode[i] = src.mode[i];
#ifdef INCLUDE_GPU_TIMER
this->InitEventsCUDA(this->gpu_end);
......@@ -147,3 +154,77 @@ EndEventData& EndEventData::operator=(const EndEventData& src)
return *this;
}
// ========= Output event ====================================
OutputEventData::OutputEventData()
{
this->time_series = vector<double>();
this->elapsed_time = 0.0; // seconds
this->ContiniousTime = 0.0;
this->count = 0;
}
OutputEventData::OutputEventData(const string& name)
{
this->time_series = vector<double>();
this->event_name = name;
this->elapsed_time = 0.0; // seconds
this->ContiniousTime = 0.0;
this->count = 0;
}
OutputEventData::~OutputEventData()
{
this->time_series.clear();
}
OutputEventData& OutputEventData::operator=(const OutputEventData& src)
{
this->event_name = src.event_name;
this->time_series = vector<double>();
this->elapsed_time = src.elapsed_time; // seconds
this->ContiniousTime = src.ContiniousTime;
this->count = src.count;
return *this;
}
double OutputEventData::GetMeanElapsedTime()
{
if(this->count != 0)
return this->elapsed_time / this->count;
return -1;
}
string OutputEventData::GetEventModeName()
{
bool ifMPI = this->mode[0], ifOpenMP = this->mode[1], ifCUDA = this->mode[2];
int flag = 0;
string EventModeName = "";
if(ifMPI)
{
EventModeName += "MPI";
flag = 1;
}
if(ifOpenMP)
{
if(flag == 1)
EventModeName += "_";
EventModeName += "OpenMP";
flag = 1;
}
if(ifCUDA)
{
if(flag == 1)
EventModeName += "_";
EventModeName += "CUDA";
}
if(!ifMPI && !ifOpenMP && !ifCUDA)
EventModeName += "Asynchronous";
return EventModeName;
}
\ No newline at end of file
......@@ -15,7 +15,7 @@ typedef std::chrono::steady_clock::time_point chrono_time_type;
class EventData{
public:
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
bool mode[3]; // Measurment type for current code block. Order: mode[0] ~ if MPI, mode[1] ~ if OpenMP, mode[2] ~ if CUDA
EventData();
~EventData();
......@@ -39,6 +39,7 @@ public:
bool ifCUDAinit; // If CUDA variables are initialized
double double_start;
chrono_time_type start;
int mode_enum;
StartEventData();
~StartEventData();
......@@ -52,7 +53,7 @@ public:
#ifdef INCLUDE_GPU_TIMER
cudaEvent_t gpu_end;
#endif
bool ifCUDAinit; // If CUDA variables are initialized
bool cont_mode; // If CUDA variables are initialized
double double_end;
chrono_time_type end;
......@@ -62,39 +63,21 @@ public:
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.
class OutputEventData{
public:
// private:
// void InitEventsCUDA();
// void DeinitEventsCUDA();
// // void MPISync();
// // void OpenMPSync();
// // void CUDASyncStart();
// // void CUDASyncEnd();
// };
\ No newline at end of file
double elapsed_time; // seconds
double ContiniousTime;
int count; // Count of current code block measurments
std::vector<double> time_series; // Measurments time series for current code block
std::string event_name; // Name ID for current code block
bool mode[3]; // Measurment type for current code block. Order: mode[0] ~ if MPI, mode[1] ~ if OpenMP, mode[2] ~ if CUDA
OutputEventData();
~OutputEventData();
OutputEventData(const std::string& name);
OutputEventData& operator=(const OutputEventData& src);
double GetMeanElapsedTime(); // elapsed_time / count for each measuring code block
std::string GetEventModeName(); // Generate measure type for current code block (used for dump), for example "MPI", "MPI_OpenMP" etc.
};
\ No newline at end of file
......@@ -20,6 +20,9 @@ Jikan::Jikan()
this->EventType["Synchronous events"] = set<string>();
this->EventType["Asynchronous events"] = set<string>();
this->Events = map< string, OutputEventData> ();
this->EventType = map< string, set<string> > ();
this->Start = vector<StartEventData> ();
this->End = vector<EndEventData> ();
......@@ -97,22 +100,23 @@ Jikan::~Jikan()
this->Start.clear();
this->End.clear();
this->Events.clear();
#ifdef INCLUDE_OPEN_MP
}
#endif
}
bool Jikan::ifContains(const string& Name)
{
map<string, EventData>::iterator it;
// bool Jikan::ifContains(const string& Name)
// {
// map<string, OutputEventData>::iterator it;
it = this->Events.find(Name);
if (it == this->Events.end())
return false;
// it = this->Events.find(Name);
// if (it == this->Events.end())
// return false;
return true;
}
// return true;
// }
void Jikan::JikanStart(const string& name, const int mode)
{
......@@ -125,6 +129,7 @@ void Jikan::JikanStart(const string& name, const int mode)
#endif
this->Start.push_back(StartEventData(name));
(this->Start)[CurrEventID].GetModeVals(mode);
(this->Start)[CurrEventID].mode_enum = mode;
#ifdef INCLUDE_OPEN_MP
}
#endif
......@@ -168,8 +173,6 @@ void Jikan::JikanStart(const string& name, const int mode)
void Jikan::JikanEnd(const string& name, const int mode, const int cont_mode_t)
{
bool 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
......@@ -178,10 +181,14 @@ void Jikan::JikanEnd(const string& name, const int mode, const int cont_mode_t)
#endif
this->End.push_back(EndEventData(name));
(this->End)[CurrEventID].GetModeVals(mode);
(this->End)[CurrEventID].cont_mode = cont_mode_t;
// printf("CurrEventID = %d, nmae = %s\n", CurrEventID, name.c_str());
#ifdef INCLUDE_OPEN_MP
}
#endif
bool ifMPI = (this->End)[CurrEventID].mode[0], ifOpenMP = (this->End)[CurrEventID].mode[1], ifCUDA = (this->End)[CurrEventID].mode[2];
//--------------------------- OpenMP synchronization --------------------------------
if(ifOpenMP)
{
......@@ -199,6 +206,13 @@ void Jikan::JikanEnd(const string& name, const int mode, const int cont_mode_t)
if(ifMPI)
this->BarrierMPI();
if(ifCUDA)
{
#ifdef INCLUDE_GPU_TIMER
this->EndCUDASync((this->End)[CurrEventID]);
#endif
}
this->EndEvent((this->End)[CurrEventID], cont_mode_t);
#ifdef INCLUDE_OPEN_MP
}
......@@ -206,6 +220,100 @@ void Jikan::JikanEnd(const string& name, const int mode, const int cont_mode_t)
//---------------------------------------------------------------------------------------
}
void Jikan::ProcessEvent(const string& name)
{
int CurrEndId = 0;
this->Events[name] = OutputEventData(name);
for (int i = 0; i < this->Start.size(); i++)
{
if(this->Start[i].event_name == name)
{
for (int j = CurrEndId; j < this->End.size(); j++)
{
// printf("i = %d, j = %d, %s\n", i, j, this->End[j].event_name.c_str());
if(this->End[j].event_name == name)
{
const bool ifMPI = this->Start[i].mode[0], ifOpenMP = this->Start[i].mode[1], ifCUDA = this->Start[i].mode[2];
double elapsed_time;
if(CurrEndId == 0)
{
this->Events[name].mode[0] = ifMPI;
this->Events[name].mode[1] = ifOpenMP;
this->Events[name].mode[2] = ifCUDA;
string EventTypeName;
if(this->Start[i].mode_enum == TimerMode::NO_SYNC)
EventTypeName = "Asynchronous events";
else
EventTypeName = "Synchronous events";
this->EventType[EventTypeName].insert(name);
}
if(ifCUDA && !ifMPI && !ifOpenMP)
{
#ifdef INCLUDE_GPU_TIMER
elapsed_time = this->CUDAGetTime(this->Start[i].gpu_start, this->End[j].gpu_end);
#endif
}
else if(!ifCUDA && !ifMPI && ifOpenMP)
{
#ifdef INCLUDE_OPEN_MP
elapsed_time = this->End[j].double_end - this->Start[i].double_start;
#endif
}
else
{
elapsed_time = chrono::duration_cast<chrono::nanoseconds>(this->End[j].end - this->Start[i].start).count() * 1e-9;
}
this->Events[name].elapsed_time += elapsed_time;
#ifdef SAVE_TIME_SERIES
if(this->End[j].cont_mode == 1)
{
this->Events[name].ContiniousTime += elapsed_time;
}
else
{
this->Events[name].ContiniousTime += elapsed_time;
this->Events[name].time_series.push_back(this->Events[name].ContiniousTime);
this->Events[name].ContiniousTime = 0.0;
this->Events[name].count++;
}
#endif
// printf("CurrEndId = %d\n", CurrEndId);
CurrEndId = j+1;
break;
}
}
}
}
}
void Jikan::ProcessStack()
{
set<string> EventIDs;
for (int i = 0; i < this->Start.size(); i++)
EventIDs.insert(this->Start[i].event_name);
for (set<string>::iterator i = EventIDs.begin(); i != EventIDs.end(); i++)
{
this->ProcessEvent(*i);
}
EventIDs.clear();
}
void Jikan::GenerateTypedOutputData(const string& EventType, string& EventTypeString)
{
const int n = this->EventType[EventType].size();
......@@ -223,54 +331,51 @@ 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()
{
printf("%d\n", this->Start.size());
// map<string, set<string> >::iterator it;
// map<string, set<string> >::iterator end_m;
this->ProcessStack();
// string Name;
// string Out = "{ ";
// string TypedOutput;
map<string, set<string> >::iterator it;
map<string, set<string> >::iterator end_m = this->EventType.end();
--end_m;
// 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;
// }
string Name;
string Out = "{ ";
string TypedOutput;
// Name = end_m->first;
// TypedOutput = "";
// this->GenerateTypedOutputData(Name, TypedOutput);
// Out += TypedOutput + "\n}";
for(it = this->EventType.begin(); it != end_m; ++it)
{
Name = it->first;
TypedOutput = "";
this->GenerateTypedOutputData(Name, TypedOutput);
Out += TypedOutput + ",\n";
}
// this->JSONdata = Out;
Name = end_m->first;
TypedOutput = "";
this->GenerateTypedOutputData(Name, TypedOutput);
Out += TypedOutput + "\n}";
// bool OutputRes = JSON::WriteOutput(this->JSONname, this->JSONdata);
this->JSONdata = Out;
// if(OutputRes != true)
// {
// this->Error = JSON::Error;
// }
bool OutputRes = JSON::WriteOutput(this->JSONname, this->JSONdata);
if(OutputRes != true)
{
this->Error = JSON::Error;
}
}
void Jikan::SetDumpFilename(const string& name)
......@@ -302,21 +407,14 @@ void Jikan::EndEvent(EndEventData& Event, const int cont_mode_t)
{
bool ifMPI = Event.mode[0], ifOpenMP = Event.mode[1], ifCUDA = Event.mode[2];
if(ifCUDA)
{
#ifdef INCLUDE_GPU_TIMER
this->EndCUDASync(Event);
#endif
}
#ifdef INCLUDE_OPEN_MP
else if( (!ifCUDA) && (!ifMPI) && (ifOpenMP))
if( (!ifCUDA) && (!ifMPI) && (ifOpenMP))
{
double end = omp_get_wtime();
}
#endif
else if(!ifCUDA && !ifOpenMP)
if(!ifCUDA && !ifOpenMP)
{
Event.end = chrono::steady_clock::now();
}
......
......@@ -21,25 +21,12 @@ using namespace std;
cudaEventSynchronize(Event.gpu_end);
}
// 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)
// {
// Event.count ++;
// }
double Jikan::CUDAGetTime(const cudaEvent_t& gpu_start, const cudaEvent_t& gpu_end)
{
float GPUtime = 0.0;
cudaEventElapsedTime(&GPUtime, gpu_start, gpu_end);
GPUtime *= 1e-3;
// #ifdef SAVE_TIME_SERIES
// if(cont_mode_t == 0)
// {
// Event.time_series.push_back(Event.ContiniousTime);
// Event.ContiniousTime = 0.0;
// }
// #endif
// }
return GPUtime;
}
#endif
\ No newline at end of file
......@@ -18,7 +18,7 @@ public:
std::vector<StartEventData> Start;
std::vector<EndEventData> End;
std::map<std::string, EventData> Events; // Measuring code blocks info: string = code block name ID, EventData = measuring code block data
std::map<std::string, OutputEventData> 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
......@@ -38,9 +38,6 @@ public:
void GenerateTypedOutputData(const std::string& EventType, std::string& EventTypeString);
void GenerateOutputData();
// private:
bool ifContains(const std::string& name); // Check if current code block measurments are already exist
#ifdef INCLUDE_MPI
bool ifWriteProc(MPI_Comm comm, int id); // Check if current MPI proc ID == id
#endif
......@@ -52,8 +49,10 @@ private:
void BarrierMPI(); // Start MPI barrier
void StartEvent(StartEventData& Event);
void EndEvent(EndEventData& Event, const int cont_mode_t);
void ProcessStack();
void ProcessEvent(const std::string& name);
#ifdef INCLUDE_GPU_TIMER
// void CUDAGetTime(EventData& Event, const int cont_mode_t);
double CUDAGetTime(const cudaEvent_t& gpu_start, const cudaEvent_t& end_start);
#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(OutputEventData 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(OutputEventData 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