Add description comments

Event.cpp

@@ -15,7 +15,7 @@ EventData::EventData()
     this->start = chrono::steady_clock::now();
     this->elapsed_time = 0.0; 
     this->count = 0;
-    this->ifCUDA = 0;
+    // this->ifCUDA = 0;
     this->event_name = "Unnamed";
     this->ifStart = false, this->ifEnd = false;
     this->if_mode_set = false;
@@ -49,7 +49,7 @@ EventData::EventData(const string& name)
     this->start = chrono::steady_clock::now();
     this->elapsed_time = 0.0; 
     this->count = 0;
-    this->ifCUDA = 0;
+    // this->ifCUDA = 0;
     this->event_name = name;
     this->ifStart = false, this->ifEnd = false;
     this->if_mode_set = false;
@@ -70,7 +70,7 @@ EventData& EventData::operator=(const EventData& src)
     this->start = src.start;
     this->elapsed_time = 0.0; 
     this->count = 0;
-    this->ifCUDA = 0;
+    // this->ifCUDA = 0;
     this->event_name = src.event_name;
     this->ifStart = false, this->ifEnd = false;
     this->if_mode_set = src.if_mode_set;
@@ -104,12 +104,12 @@ void EventData::GetModeVals(const int& mode)
     else
         this->mode.push_back(false);
     
-    this->if_mode_set = true;
-    
     if((mode == TimerMode::CUDA_mode)   || (mode == TimerMode::MPI_CUDA)   || (mode == TimerMode::OpenMP_CUDA) || (mode == TimerMode::MPI_OpenMP_CUDA))
         this->mode.push_back(true);
     else
         this->mode.push_back(false);
+
+    this->if_mode_set = true;
 }
 
 string EventData::GetEventModeName()
@@ -144,3 +144,34 @@ string EventData::GetEventModeName()
 
     return EventModeName;
 }
+
+// void EventData::MPISync()
+// {
+// #ifdef INCLUDE_MPI
+//     int init_flag, fin_flag;
+
+//     MPI_Initialized(&init_flag);
+//     MPI_Finalized(&fin_flag);
+
+//     if((!fin_flag) && init_flag)
+//         MPI_Barrier(MPI_COMM_WORLD);
+// #endif
+// }
+
+// void EventData::MPISync()
+// {
+// #ifdef INCLUDE_MPI
+//     int init_flag, fin_flag;
+
+//     MPI_Initialized(&init_flag);
+//     MPI_Finalized(&fin_flag);
+
+//     if((!fin_flag) && init_flag)
+//         MPI_Barrier(MPI_COMM_WORLD);
+// #endif
+// }
+
+// void EventData::OpenMPSync()
+// {
+//     #pragma omp barrier
+// }

Event.cu

@@ -25,3 +25,14 @@ void EventData::DeinitEventsCUDA()
         this->ifCUDAinit = false;
     }
 }
+
+// void EventData::CUDASyncStart()
+// {
+//     cudaEventRecord (this->gpu_start);
+// }
+
+// void EventData::CUDASyncStart()
+// {
+//     cudaEventRecord(this->gpu_end);
+// 	cudaEventSynchronize(this->gpu_end);
+// }
\ No newline at end of file

Event.h

@@ -19,26 +19,31 @@ public:
     cudaEvent_t gpu_start, gpu_end;
 #endif
 
-    bool if_mode_set;
-    bool ifCUDAinit;
-    chrono_time_type start;
+    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
-    int count, ifCUDA;
-    bool ifStart, ifEnd;
-    std::vector<double> time_series;
-    std::string event_name;
-    std::vector<bool> mode;            // order: mode[0] ~ if MPI, mode[1] ~ if OpenMP, mode[2] ~ if CUDA
+    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();
-    void GetModeVals(const int& mode);
-    std::string GetEventModeName();
+    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

Jikan.cpp

@@ -13,14 +13,14 @@ extern "C"
     {
         string str_name = name;
 
-        Timer.Jikan_start(str_name, mode);
+        Timer.JikanStart(str_name, mode);
     }
 
     void TimerEnd(const char* name)
     {
         string str_name = name;
 
-        Timer.Jikan_end(str_name);
+        Timer.JikanEnd(str_name);
     }
 
     void WriteOutput()

JikanDepths.cpp

@@ -80,7 +80,7 @@ bool Jikan::ifContains(const string& Name)
     return true;
 }
 
-void Jikan::Jikan_start(const string& name, const int& mode)
+void Jikan::JikanStart(const string& name, const int& mode)
 {
     bool ExistFlag, ifMPI, ifOpenMP;
     ExistFlag = this->ifContains(name);
@@ -144,7 +144,7 @@ void Jikan::Jikan_start(const string& name, const int& mode)
     }
 }
 
-void Jikan::Jikan_end(const string& name)
+void Jikan::JikanEnd(const string& name)
 {    
     bool ExistFlag, ifStart;
     bool ifMPI, ifOpenMP, ifCUDA;
@@ -162,8 +162,8 @@ void Jikan::Jikan_end(const string& name)
         if((ifCUDA) && (!ifMPI) && (!ifOpenMP))
         {    
             #ifdef INCLUDE_GPU_TIMER
-                this->cuda_Jikan_end(name);
-                this->cuda_get_time(name);
+                this->EndCUDASync(name);
+                this->CUDAGetTime(name);
             #endif
         }
     }
@@ -262,7 +262,7 @@ void Jikan::StartEvent(const string& name)
     if((ifCUDA))
     {
         #ifdef INCLUDE_GPU_TIMER
-            this->cuda_Jikan_start(name);
+            this->StartCUDASync(name);
         #endif
     }
 
@@ -282,7 +282,7 @@ void Jikan::EndEvent(const string& name)
     if((ifCUDA))
     {
         #ifdef INCLUDE_GPU_TIMER
-            this->cuda_Jikan_end(name);
+            this->EndCUDASync(name);
         #endif
     }
 

JikanDepths.cu

@@ -9,18 +9,18 @@
 
 using namespace std;
 
-void Jikan::cuda_Jikan_start(const string& name)
+void Jikan::StartCUDASync(const string& name)
 {
 	cudaEventRecord ((this->Events)[name].gpu_start);
 }
 
-void Jikan::cuda_Jikan_end(const string& name)
+void Jikan::EndCUDASync(const string& name)
 {
     cudaEventRecord((this->Events)[name].gpu_end);
 	cudaEventSynchronize((this->Events)[name].gpu_end);
 }
 
-void Jikan::cuda_get_time(const string& name)
+void Jikan::CUDAGetTime(const string& name)
 {
     float GPUtime = 0.0;
     cudaEventElapsedTime(&GPUtime, (this->Events)[name].gpu_start, (this->Events)[name].gpu_end );

JikanDepths.h

@@ -14,44 +14,42 @@
 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;
+    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 ?
 
     Jikan();
     ~Jikan();
 
-    void Jikan_start(const std::string& name, const int& mode);
-    void Jikan_end(  const std::string& name);
+    void JikanStart(const std::string& name, const int& mode); // Start code block measurments
+    void JikanEnd(  const std::string& name); // End code block measurments
 
 #ifdef INCLUDE_GPU_TIMER
-    void cuda_Jikan_start(const std::string& name);
-    void cuda_Jikan_end(  const std::string& name);
+    void StartCUDASync(const std::string& name); // Start CUDA synchronization
+    void EndCUDASync(  const std::string& name); // End CUDA synchronization
 #endif
 
     void GenerateTypedOutputData(const std::string& EventType, std::string& EventTypeString);
     void GenerateOutputData();
 
 // private:
-    bool ifContains(const std::string& name);
+    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);
+    bool ifWriteProc(MPI_Comm comm, int id); // Check if current MPI proc ID == id
 #endif
 
     bool ifWriteProc();
-
-    void SetDumpFilename(const std::string& name);
+    void SetDumpFilename(const std::string& name); // Change dump filename to <name>
 
 private:
-    void StartTimer(const std::string& name);
-    void BarrierMPI();
+    void BarrierMPI(); // Start MPI barrier
     void StartEvent(const std::string& name); 
     void EndEvent(const std::string& name);
 
 #ifdef INCLUDE_GPU_TIMER
-    void cuda_get_time(const string& name);
+    void CUDAGetTime(const std::string& name);
 #endif
 };
\ No newline at end of file