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

Rename Jikan functions

parent f8430c5e
Branches
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Jikan.cpp
+ 190
− 171
View file @ fb73e883
#include "Jikan.h" #include "Jikan.h"
#include "ToJSON.h" #include "JikanWrapper.h"
#include <iostream> #ifdef INCLUDE_OPEN_MP
#include <map> #include "omp.h"
#include <string> #endif
#ifdef INCLUDE_MPI
#include "mpi.h"
#endif
using namespace std; using namespace std;
class Jikan Timer; extern "C"
{
extern class Jikan Timer;
void TimerStart(const char* name)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
string str_name = name;
Timer.Jikan_start(str_name);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
Jikan::Jikan() void TimerEnd(const char* name)
{ {
this->EventType["Synchronous events"] = set<string>(); #ifdef INCLUDE_OPEN_MP
this->EventType["Asynchronous events"] = set<string>(); #pragma omp master
this->EventType["CUDA events"] = set<string>(); {
#endif
this->JSONname = OUTPUT_NAME + string(".json"); string str_name = name;
this->JSONdata = "";
this->Error = ""; Timer.Jikan_end(str_name);
};
#ifdef INCLUDE_OPEN_MP
}
#endif
}
#ifdef INCLUDE_MPI #ifdef INCLUDE_MPI
bool Jikan::ifWriteProc(MPI_Comm comm, int id) void MPI_SyncTimerStart(const char* name)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{ {
bool if_write = false; #endif
int init_flag, fin_flag, iproc;
string str_name = name;
int init_flag, fin_flag;
MPI_Initialized(&init_flag); MPI_Initialized(&init_flag);
MPI_Finalized(&fin_flag); MPI_Finalized(&fin_flag);
bool if_MPI = (init_flag) && (!fin_flag); if((!fin_flag) && init_flag)
if(if_MPI) MPI_Barrier(MPI_COMM_WORLD);
{
MPI_Comm_rank(comm, &iproc);
if( iproc == id)
if_write = true;
}
else
if_write = true;
Timer.Jikan_sync_start(str_name);
return if_write; #ifdef INCLUDE_OPEN_MP
}
#else
bool Jikan::ifWriteProc()
{
return true;
} }
#endif #endif
}
Jikan::~Jikan() void MPI_SyncTimerEnd(const char* name)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{ {
this->Events.clear(); #endif
map<string, set<string> >::iterator it; string str_name = name;
for(it = this->EventType.begin(); it!=this->EventType.end(); ++it) int init_flag, fin_flag;
it->second.clear();
this->EventType.clear();
}
bool Jikan::ifContains(const string& Name) MPI_Initialized(&init_flag);
{ MPI_Finalized(&fin_flag);
map<string, EventData>::iterator it;
it = this->Events.find(Name); if((!fin_flag) && init_flag)
if (it == this->Events.end()) MPI_Barrier(MPI_COMM_WORLD);
return false;
return true; Timer.Jikan_sync_end(str_name);
}
void Jikan::Jikan_sync_start(const string& name) #ifdef INCLUDE_OPEN_MP
{ }
bool ExistFlag; #endif
ExistFlag = this->ifContains(name); }
if(ExistFlag) void MPI_SyncTimerStartCustom(const char* name, MPI_Comm comm)
{ {
chrono_time_type start = chrono::steady_clock::now(); #ifdef INCLUDE_OPEN_MP
(this->Events)[name].start = start; #pragma omp master
}
else
{ {
this->EventType["Synchronous events"].insert(name); #endif
string str_name = name;
(this->Events)[name] = EventData(name); int init_flag, fin_flag;
chrono_time_type start = chrono::steady_clock::now();
(this->Events)[name].start = start; MPI_Initialized(&init_flag);
} MPI_Finalized(&fin_flag);
if((!fin_flag) && init_flag)
MPI_Barrier(MPI_COMM_WORLD);
Timer.Jikan_sync_start(str_name);
(this->Events)[name].ifStart = true; #ifdef INCLUDE_OPEN_MP
}
#endif
} }
void Jikan::Jikan_sync_end(const string& name) void MPI_SyncTimerEndCustom(const char* name, MPI_Comm comm)
{ {
bool ExistFlag, ifStart; #ifdef INCLUDE_OPEN_MP
ExistFlag = this->ifContains(name); #pragma omp master
ifStart = (this->Events)[name].ifStart; {
#endif
string str_name = name;
if((!ExistFlag) || (!ifStart)) int init_flag, fin_flag;
return;
chrono_time_type end = chrono::steady_clock::now(); MPI_Initialized(&init_flag);
chrono_time_type start = (this->Events)[name].start; MPI_Finalized(&fin_flag);
double main_elapsed = chrono::duration_cast<chrono::nanoseconds>(end - start).count() * 1e-9; if((!fin_flag) && init_flag)
MPI_Barrier(comm);
(this->Events)[name].elapsed_time += main_elapsed; Timer.Jikan_sync_end(str_name);
(this->Events)[name].count ++;
#ifdef SAVE_TIME_SERIES #ifdef INCLUDE_OPEN_MP
(this->Events)[name].time_series.push_back(main_elapsed); }
#endif #endif
(this->Events)[name].ifStart = false;
} }
void Jikan::Jikan_start(const string& name) void WriteOutputCustom(MPI_Comm comm, int id)
{
bool ExistFlag;
ExistFlag = this->ifContains(name);
if(ExistFlag)
{ {
chrono_time_type start = chrono::steady_clock::now(); #ifdef INCLUDE_OPEN_MP
(this->Events)[name].start = start; #pragma omp master
}
else
{ {
this->EventType["Asynchronous events"].insert(name); #endif
(this->Events)[name] = EventData(name); bool ifWrite = Timer.ifWriteProc(comm, id);
chrono_time_type start = chrono::steady_clock::now(); if(ifWrite == true)
(this->Events)[name].start = start; Timer.GenerateOutputData();
}
(this->Events)[name].ifStart = true; #ifdef INCLUDE_OPEN_MP
}
#endif
} }
void Jikan::Jikan_end(const string& name) void WriteOutput(int id)
{ {
bool ExistFlag, ifStart; #ifdef INCLUDE_OPEN_MP
ExistFlag = this->ifContains(name); #pragma omp master
ifStart = (this->Events)[name].ifStart; {
#endif
if((!ExistFlag) || (!ifStart)) bool ifWrite = Timer.ifWriteProc(MPI_COMM_WORLD, id);
return; // cout << ifWrite << endl;
if(ifWrite == true)
Timer.GenerateOutputData();
chrono_time_type end = chrono::steady_clock::now(); #ifdef INCLUDE_OPEN_MP
chrono_time_type start = (this->Events)[name].start; }
#endif
}
double main_elapsed = chrono::duration_cast<chrono::nanoseconds>(end - start).count() * 1e-9; #else
void WriteOutput()
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
(this->Events)[name].elapsed_time += main_elapsed; bool ifWrite = Timer.ifWriteProc();
(this->Events)[name].count ++; if(ifWrite == true)
Timer.GenerateOutputData();
#ifdef SAVE_TIME_SERIES #ifdef INCLUDE_OPEN_MP
(this->Events)[name].time_series.push_back(main_elapsed); }
#endif #endif
(this->Events)[name].ifStart = false;
} }
#endif
void Jikan::GenerateTypedOutputData(const string& EventType, string& EventTypeString) #ifdef INCLUDE_OPEN_MP
void OpenMP_SyncTimerStart(const char* name)
{ {
const int n = this->EventType[EventType].size(); #pragma omp barrier
EventTypeString = JSON::StartTypedBlock(EventType); #pragma omp master
if(n == 0)
{ {
EventTypeString += "\n\t}"; string str_name = name;
return;
}
string Row; Timer.Jikan_sync_start(str_name);
string Name; }
set<string>::iterator it; }
set<string>::iterator end_m = this->EventType[EventType].end();
--end_m;
for (it = this->EventType[EventType].begin(); it != end_m; ++it) void OpenMP_SyncTimerEnd(const char* name)
{ {
Name = *it; #pragma omp barrier
JSON::GenerateRow(this->Events[Name], Row, JSON::SeparateRows); #pragma omp master
EventTypeString += Row; {
} string str_name = name;
Name = *end_m; Timer.Jikan_sync_end(str_name);
JSON::GenerateRow(this->Events[Name], Row, JSON::FinishRows);
EventTypeString += Row;
} }
}
#endif
//--------
void Jikan::GenerateOutputData() #ifdef INCLUDE_GPU_TIMER
void CudaTimerStart(const char* name)
{ {
map<string, set<string> >::iterator it; #ifdef INCLUDE_OPEN_MP
map<string, set<string> >::iterator end_m = this->EventType.end(); #pragma omp master
--end_m; {
#endif
string Name; string str_name = name;
string Out = "{ ";
string TypedOutput;
for(it = this->EventType.begin(); it!=end_m; ++it) Timer.cuda_Jikan_start(str_name);
{
Name = it->first; #ifdef INCLUDE_OPEN_MP
TypedOutput = ""; }
this->GenerateTypedOutputData(Name, TypedOutput); #endif
Out += TypedOutput + ",\n";
} }
Name = end_m->first; void CudaTimerEnd(const char* name)
TypedOutput = ""; {
this->GenerateTypedOutputData(Name, TypedOutput); #ifdef INCLUDE_OPEN_MP
Out += TypedOutput + "\n}";
this->JSONdata = Out; #pragma omp master
{
#endif
string str_name = name;
bool OutputRes = JSON::WriteOutput(this->JSONname, this->JSONdata); Timer.cuda_Jikan_end(str_name);
if(OutputRes != true) #ifdef INCLUDE_OPEN_MP
{
this->Error = JSON::Error;
} }
#ifdef INCLUDE_GPU_TIMER
this->FreeCudaEvents();
#endif #endif
} }
#endif
void Jikan::SetDumpFilename(const std::string& name)
{
this->JSONname = name;
} }
\ No newline at end of file
Jikan.h
+ 99
− 37
View file @ fb73e883
#pragma once #pragma once
#include "JikanWrapper.h" //------------------------- Jikan-config ---------------------------------------------
#include "Jikan-config.h" #define TIMER_ON
#include "Event.h" #define INCLUDE_GPU_TIMER
#define INCLUDE_MPI
#define INCLUDE_OPEN_MP
#define SAVE_TIME_SERIES
#define OUTPUT_NAME "Jikan-output"
//------------------------------------------------------------------------------------
#include <iostream>
#include <string>
#include <set>
#ifdef INCLUDE_MPI #ifdef INCLUDE_MPI
#include <mpi.h> #include <mpi.h>
#endif #endif
class Jikan #ifdef __cplusplus
{ extern "C" {
public: #endif
std::map<std::string, EventData> Events; void TimerStart(const char* name);
std::map<std::string, std::set<std::string> > EventType; void TimerEnd(const char* name);
std::string JSONname;
std::string JSONdata;
std::string Error;
Jikan(); //------------------------- Asynchronous timer mode functions -------------------------
~Jikan(); #ifdef TIMER_ON
#define START_JIKAN_TIMER(name) TimerStart(name);
#define END_JIKAN_TIMER(name) TimerEnd(name);
#else
#define START_JIKAN_TIMER(name)
#define END_JIKAN_TIMER(name)
#endif
//-------------------------------------------------------------------------------------
void Jikan_sync_start(const std::string& name); //------------------------- MPI-synchronous timer mode functions ----------------------
void Jikan_sync_end( const std::string& name); #ifdef INCLUDE_MPI
void MPI_SyncTimerStart(const char* name);
void MPI_SyncTimerEnd(const char* name);
void Jikan_start(const std::string& name); #define MPI_SYNC_JIKAN_TIMER_START_DEF(name) MPI_SyncTimerStart(name);
void Jikan_end( const std::string& name); #define MPI_SYNC_JIKAN_TIMER_END_DEF(name) MPI_SyncTimerEnd(name);
#ifdef INCLUDE_GPU_TIMER void MPI_SyncTimerStartCustom(const char* name, MPI_Comm comm);
void cuda_Jikan_start(const std::string& name); void MPI_SyncTimerEndCustom(const char* name, MPI_Comm comm);
void cuda_Jikan_end( const std::string& name);
#define MPI_SYNC_JIKAN_TIMER_START_CUSTOM(name, comm) MPI_SyncTimerStartCustom(name, comm);
#define MPI_SYNC_JIKAN_TIMER_END_CUSTOM(name, comm) MPI_SyncTimerEndCustom(name, comm);
#ifdef TIMER_ON
#define SYNC_SELECT(_1, _2, macro, ...) macro
#define START_JIKAN_TIMER_MPI(...) SYNC_SELECT(__VA_ARGS__, MPI_SYNC_JIKAN_TIMER_START_CUSTOM, MPI_SYNC_JIKAN_TIMER_START_DEF)(__VA_ARGS__)
#define END_JIKAN_TIMER_MPI(...) SYNC_SELECT(__VA_ARGS__, MPI_SYNC_JIKAN_TIMER_END_CUSTOM, MPI_SYNC_JIKAN_TIMER_END_DEF )(__VA_ARGS__)
#else
#define START_JIKAN_TIMER_MPI(...)
#define END_JIKAN_TIMER_MPI(...)
#endif
#else
#define START_JIKAN_TIMER_MPI(...)
#define END_JIKAN_TIMER_MPI(...)
#endif #endif
//-------------------------------------------------------------------------------------
//------------------------- OpenMP-synchronous timer mode functions -------------------
#ifdef INCLUDE_OPEN_MP
void OpenMP_SyncTimerStart(const char* name);
void OpenMP_SyncTimerEnd(const char* name);
void GenerateTypedOutputData(const std::string& EventType, std::string& EventTypeString); #ifdef TIMER_ON
void GenerateOutputData(); #define START_JIKAN_TIMER_OpenMP(name) OpenMP_SyncTimerStart(name);
#define END_JIKAN_TIMER_OpenMP(name) OpenMP_SyncTimerEnd(name);
#else
#define START_JIKAN_TIMER_OpenMP(name)
#define END_JIKAN_TIMER_OpenMP(name)
#endif
#else
#define START_JIKAN_TIMER_OpenMP(name)
#define END_JIKAN_TIMER_OpenMP(name)
#endif
//-------------------------------------------------------------------------------------
// private: //------------------------- CUDA-synchronous timer mode functions ---------------------
bool ifContains(const std::string& name); #ifdef INCLUDE_GPU_TIMER
void CudaTimerStart(const char* name);
void CudaTimerEnd(const char* name);
#ifdef INCLUDE_MPI #ifdef TIMER_ON
bool ifWriteProc(MPI_Comm comm, int id); #define START_JIKAN_TIMER_CUDA(name) CudaTimerStart(name);
#define END_JIKAN_TIMER_CUDA(name) CudaTimerEnd(name);
#else
#define START_JIKAN_TIMER_CUDA(name)
#define END_JIKAN_TIMER_CUDA(name)
#endif
#else #else
bool ifWriteProc(); #define START_JIKAN_TIMER_CUDA(name)
#define END_JIKAN_TIMER_CUDA(name)
#endif #endif
//-------------------------------------------------------------------------------------
void SetDumpFilename(const std::string& name); //------------------------- Dump functions --------------------------------------------
#ifdef INCLUDE_MPI
void WriteOutputCustom(MPI_Comm comm, int id);
void WriteOutput(int id);
private: #ifdef TIMER_ON
#define JIKAN_TIMER_OUTPUT_CUSTOM(comm) WriteOutputCustom(comm, 0);
#define JIKAN_TIMER_OUTPUT_DEF() WriteOutput(0);
#ifdef INCLUDE_GPU_TIMER #define OUTPUT_SELECT(_0, _1, macro, ...) macro
void FreeCudaEvents(); #define JIKAN_TIMER_OUTPUT(...) OUTPUT_SELECT(__VA_ARGS__, JIKAN_TIMER_OUTPUT_CUSTOM, JIKAN_TIMER_OUTPUT_DEF)(__VA_ARGS__)
#else
#define JIKAN_TIMER_OUTPUT(...)
#endif #endif
#else
void WriteOutput();
#define JIKAN_TIMER_OUTPUT() WriteOutput();
#endif
//-------------------------------------------------------------------------------------
}; #ifdef __cplusplus
\ No newline at end of file }
#endif
\ No newline at end of file
JikanDepths.cpp 0 → 100644
+ 234
− 0
View file @ fb73e883
#include "JikanDepths.h"
#include "ToJSON.h"
#include <iostream>
#include <map>
#include <string>
using namespace std;
class Jikan Timer;
Jikan::Jikan()
{
this->EventType["Synchronous events"] = set<string>();
this->EventType["Asynchronous events"] = set<string>();
this->EventType["CUDA events"] = set<string>();
this->JSONname = OUTPUT_NAME + string(".json");
this->JSONdata = "";
this->Error = "";
};
#ifdef INCLUDE_MPI
bool Jikan::ifWriteProc(MPI_Comm comm, int id)
{
bool if_write = false;
int init_flag, fin_flag, iproc;
MPI_Initialized(&init_flag);
MPI_Finalized(&fin_flag);
bool if_MPI = (init_flag) && (!fin_flag);
if(if_MPI)
{
MPI_Comm_rank(comm, &iproc);
if( iproc == id)
if_write = true;
}
else
if_write = true;
return if_write;
}
#else
bool Jikan::ifWriteProc()
{
return true;
}
#endif
Jikan::~Jikan()
{
this->Events.clear();
map<string, set<string> >::iterator it;
for(it = this->EventType.begin(); it!=this->EventType.end(); ++it)
it->second.clear();
this->EventType.clear();
}
bool Jikan::ifContains(const string& Name)
{
map<string, EventData>::iterator it;
it = this->Events.find(Name);
if (it == this->Events.end())
return false;
return true;
}
void Jikan::Jikan_sync_start(const string& name)
{
bool ExistFlag;
ExistFlag = this->ifContains(name);
if(ExistFlag)
{
chrono_time_type start = chrono::steady_clock::now();
(this->Events)[name].start = start;
}
else
{
this->EventType["Synchronous events"].insert(name);
(this->Events)[name] = EventData(name);
chrono_time_type start = chrono::steady_clock::now();
(this->Events)[name].start = start;
}
(this->Events)[name].ifStart = true;
}
void Jikan::Jikan_sync_end(const string& name)
{
bool ExistFlag, ifStart;
ExistFlag = this->ifContains(name);
ifStart = (this->Events)[name].ifStart;
if((!ExistFlag) || (!ifStart))
return;
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].count ++;
#ifdef SAVE_TIME_SERIES
(this->Events)[name].time_series.push_back(main_elapsed);
#endif
(this->Events)[name].ifStart = false;
}
void Jikan::Jikan_start(const string& name)
{
bool ExistFlag;
ExistFlag = this->ifContains(name);
if(ExistFlag)
{
chrono_time_type start = chrono::steady_clock::now();
(this->Events)[name].start = start;
}
else
{
this->EventType["Asynchronous events"].insert(name);
(this->Events)[name] = EventData(name);
chrono_time_type start = chrono::steady_clock::now();
(this->Events)[name].start = start;
}
(this->Events)[name].ifStart = true;
}
void Jikan::Jikan_end(const string& name)
{
bool ExistFlag, ifStart;
ExistFlag = this->ifContains(name);
ifStart = (this->Events)[name].ifStart;
if((!ExistFlag) || (!ifStart))
return;
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].count ++;
#ifdef SAVE_TIME_SERIES
(this->Events)[name].time_series.push_back(main_elapsed);
#endif
(this->Events)[name].ifStart = false;
}
void Jikan::GenerateTypedOutputData(const string& EventType, string& EventTypeString)
{
const int n = this->EventType[EventType].size();
EventTypeString = JSON::StartTypedBlock(EventType);
if(n == 0)
{
EventTypeString += "\n\t}";
return;
}
string Row;
string Name;
set<string>::iterator it;
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;
}
Name = *end_m;
JSON::GenerateRow(this->Events[Name], Row, JSON::FinishRows);
EventTypeString += Row;
}
void Jikan::GenerateOutputData()
{
map<string, set<string> >::iterator it;
map<string, set<string> >::iterator end_m = this->EventType.end();
--end_m;
string Name;
string Out = "{ ";
string TypedOutput;
for(it = this->EventType.begin(); it!=end_m; ++it)
{
Name = it->first;
TypedOutput = "";
this->GenerateTypedOutputData(Name, TypedOutput);
Out += TypedOutput + ",\n";
}
Name = end_m->first;
TypedOutput = "";
this->GenerateTypedOutputData(Name, TypedOutput);
Out += TypedOutput + "\n}";
this->JSONdata = Out;
bool OutputRes = JSON::WriteOutput(this->JSONname, this->JSONdata);
if(OutputRes != true)
{
this->Error = JSON::Error;
}
#ifdef INCLUDE_GPU_TIMER
this->FreeCudaEvents();
#endif
}
void Jikan::SetDumpFilename(const std::string& name)
{
this->JSONname = name;
}
\ No newline at end of file
JikanDepths.h 0 → 100644
+ 57
− 0
View file @ fb73e883
#pragma once
#include "JikanWrapper.h"
#include "Jikan-config.h"
#include "Event.h"
#include <iostream>
#include <string>
#include <set>
#ifdef INCLUDE_MPI
#include <mpi.h>
#endif
class Jikan
{
public:
std::map<std::string, EventData> Events;
std::map<std::string, std::set<std::string> > EventType;
std::string JSONname;
std::string JSONdata;
std::string Error;
Jikan();
~Jikan();
void Jikan_sync_start(const std::string& name);
void Jikan_sync_end( const std::string& name);
void Jikan_start(const std::string& name);
void Jikan_end( const std::string& name);
#ifdef INCLUDE_GPU_TIMER
void cuda_Jikan_start(const std::string& name);
void cuda_Jikan_end( const std::string& name);
#endif
void GenerateTypedOutputData(const std::string& EventType, std::string& EventTypeString);
void GenerateOutputData();
// private:
bool ifContains(const std::string& name);
#ifdef INCLUDE_MPI
bool ifWriteProc(MPI_Comm comm, int id);
#else
bool ifWriteProc();
#endif
void SetDumpFilename(const std::string& name);
private:
#ifdef INCLUDE_GPU_TIMER
void FreeCudaEvents();
#endif
};
\ No newline at end of file
JikanWrapper.cpp deleted 100644 → 0
+ 0
− 253
View file @ f8430c5e
#include "Jikan.h"
#include "JikanWrapper.h"
#ifdef INCLUDE_OPEN_MP
#include "omp.h"
#endif
#ifdef INCLUDE_MPI
#include "mpi.h"
#endif
using namespace std;
extern "C"
{
extern class Jikan Timer;
void TimerStart(const char* name)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
string str_name = name;
Timer.Jikan_start(str_name);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
void TimerEnd(const char* name)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
string str_name = name;
Timer.Jikan_end(str_name);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
#ifdef INCLUDE_MPI
void MPI_SyncTimerStart(const char* name)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
string str_name = name;
int init_flag, fin_flag;
MPI_Initialized(&init_flag);
MPI_Finalized(&fin_flag);
if((!fin_flag) && init_flag)
MPI_Barrier(MPI_COMM_WORLD);
Timer.Jikan_sync_start(str_name);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
void MPI_SyncTimerEnd(const char* name)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
string str_name = name;
int init_flag, fin_flag;
MPI_Initialized(&init_flag);
MPI_Finalized(&fin_flag);
if((!fin_flag) && init_flag)
MPI_Barrier(MPI_COMM_WORLD);
Timer.Jikan_sync_end(str_name);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
void MPI_SyncTimerStartCustom(const char* name, MPI_Comm comm)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
string str_name = name;
int init_flag, fin_flag;
MPI_Initialized(&init_flag);
MPI_Finalized(&fin_flag);
if((!fin_flag) && init_flag)
MPI_Barrier(MPI_COMM_WORLD);
Timer.Jikan_sync_start(str_name);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
void MPI_SyncTimerEndCustom(const char* name, MPI_Comm comm)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
string str_name = name;
int init_flag, fin_flag;
MPI_Initialized(&init_flag);
MPI_Finalized(&fin_flag);
if((!fin_flag) && init_flag)
MPI_Barrier(comm);
Timer.Jikan_sync_end(str_name);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
void WriteOutputCustom(MPI_Comm comm, int id)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
bool ifWrite = Timer.ifWriteProc(comm, id);
if(ifWrite == true)
Timer.GenerateOutputData();
#ifdef INCLUDE_OPEN_MP
}
#endif
}
void WriteOutput(int id)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
bool ifWrite = Timer.ifWriteProc(MPI_COMM_WORLD, id);
// cout << ifWrite << endl;
if(ifWrite == true)
Timer.GenerateOutputData();
#ifdef INCLUDE_OPEN_MP
}
#endif
}
#else
void WriteOutput()
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
bool ifWrite = Timer.ifWriteProc();
if(ifWrite == true)
Timer.GenerateOutputData();
#ifdef INCLUDE_OPEN_MP
}
#endif
}
#endif
#ifdef INCLUDE_OPEN_MP
void OpenMP_SyncTimerStart(const char* name)
{
#pragma omp barrier
#pragma omp master
{
string str_name = name;
Timer.Jikan_sync_start(str_name);
}
}
void OpenMP_SyncTimerEnd(const char* name)
{
#pragma omp barrier
#pragma omp master
{
string str_name = name;
Timer.Jikan_sync_end(str_name);
}
}
#endif
//--------
#ifdef INCLUDE_GPU_TIMER
void CudaTimerStart(const char* name)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
string str_name = name;
Timer.cuda_Jikan_start(str_name);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
void CudaTimerEnd(const char* name)
{
#ifdef INCLUDE_OPEN_MP
#pragma omp master
{
#endif
string str_name = name;
Timer.cuda_Jikan_end(str_name);
#ifdef INCLUDE_OPEN_MP
}
#endif
}
#endif
}
\ No newline at end of file
JikanWrapper.h deleted 100644 → 0
+ 0
− 111
View file @ f8430c5e
#pragma once
#include "Jikan-config.h"
#ifdef INCLUDE_MPI
#include <mpi.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
void TimerStart(const char* name);
void TimerEnd(const char* name);
// SIMPLE TIMER -------------------------------------------
#ifdef TIMER_ON
#define JIKAN_TIMER_START(name) TimerStart(name);
#define JIKAN_TIMER_END(name) TimerEnd(name);
#else
#define JIKAN_TIMER_START(name)
#define JIKAN_TIMER_END(name)
#endif
//---------------------------------------------------------
// MPI TIMER ----------------------------------------------
#ifdef INCLUDE_MPI
void MPI_SyncTimerStart(const char* name);
void MPI_SyncTimerEnd(const char* name);
#define MPI_SYNC_JIKAN_TIMER_START_DEF(name) MPI_SyncTimerStart(name);
#define MPI_SYNC_JIKAN_TIMER_END_DEF(name) MPI_SyncTimerEnd(name);
void MPI_SyncTimerStartCustom(const char* name, MPI_Comm comm);
void MPI_SyncTimerEndCustom(const char* name, MPI_Comm comm);
#define MPI_SYNC_JIKAN_TIMER_START_CUSTOM(name, comm) MPI_SyncTimerStartCustom(name, comm);
#define MPI_SYNC_JIKAN_TIMER_END_CUSTOM(name, comm) MPI_SyncTimerEndCustom(name, comm);
#ifdef TIMER_ON
#define SYNC_SELECT(_1, _2, macro, ...) macro
#define MPI_SYNC_JIKAN_TIMER_START(...) SYNC_SELECT(__VA_ARGS__, MPI_SYNC_JIKAN_TIMER_START_CUSTOM, MPI_SYNC_JIKAN_TIMER_START_DEF)(__VA_ARGS__)
#define MPI_SYNC_JIKAN_TIMER_END(...) SYNC_SELECT(__VA_ARGS__, MPI_SYNC_JIKAN_TIMER_END_CUSTOM, MPI_SYNC_JIKAN_TIMER_END_DEF )(__VA_ARGS__)
#else
#define MPI_SYNC_JIKAN_TIMER_START(...)
#define MPI_SYNC_JIKAN_TIMER_END(...)
#endif
#else
#define MPI_SYNC_JIKAN_TIMER_START(...)
#define MPI_SYNC_JIKAN_TIMER_END(...)
#endif
//---------------------------------------------------------
// OpenMP TIMER -------------------------------------------
#ifdef INCLUDE_OPEN_MP
void OpenMP_SyncTimerStart(const char* name);
void OpenMP_SyncTimerEnd(const char* name);
#ifdef TIMER_ON
#define OpenMP_SYNC_JIKAN_TIMER_START(name) OpenMP_SyncTimerStart(name);
#define OpenMP_SYNC_JIKAN_TIMER_END(name) OpenMP_SyncTimerEnd(name);
#else
#define OpenMP_SYNC_JIKAN_TIMER_START(name)
#define OpenMP_SYNC_JIKAN_TIMER_END(name)
#endif
#else
#define OpenMP_SYNC_JIKAN_TIMER_START(name)
#define OpenMP_SYNC_JIKAN_TIMER_END(name)
#endif
//---------------------------------------------------------
// CUDA TIMER ---------------------------------------------
#ifdef INCLUDE_GPU_TIMER
void CudaTimerStart(const char* name);
void CudaTimerEnd(const char* name);
#ifdef TIMER_ON
#define JIKAN_CUDA_TIMER_START(name) CudaTimerStart(name);
#define JIKAN_CUDA_TIMER_END(name) CudaTimerEnd(name);
#else
#define JIKAN_CUDA_TIMER_START(name)
#define JIKAN_CUDA_TIMER_END(name)
#endif
#else
#define JIKAN_CUDA_TIMER_START(name)
#define JIKAN_CUDA_TIMER_END(name)
#endif
//---------------------------------------------------------
#ifdef INCLUDE_MPI
void WriteOutputCustom(MPI_Comm comm, int id);
void WriteOutput(int id);
#ifdef TIMER_ON
#define JIKAN_TIMER_OUTPUT_CUSTOM(comm) WriteOutputCustom(comm, 0);
#define JIKAN_TIMER_OUTPUT_DEF() WriteOutput(0);
#define OUTPUT_SELECT(_0, _1, macro, ...) macro
#define JIKAN_TIMER_OUTPUT(...) OUTPUT_SELECT(__VA_ARGS__, JIKAN_TIMER_OUTPUT_CUSTOM, JIKAN_TIMER_OUTPUT_DEF)(__VA_ARGS__)
#else
#define JIKAN_TIMER_OUTPUT(...)
#endif
#else
void WriteOutput();
#define JIKAN_TIMER_OUTPUT() WriteOutput();
#endif
#ifdef __cplusplus
}
#endif
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment