only print out timer that is larger than 1 precent of total time

Author: mohanchen

source/module_base/mathzone_add1.cpp

@@ -138,7 +138,7 @@ void Mathzone_Add1::Cubic_Spline_Interpolation
 	double * const dy
 )
 {	
-	ModuleBase::timer::tick("Mathzone_Add1","Cubic_Spline_Interpolation");
+	ModuleBase::timer::tick("Mathzone","cubic_spline");
 
 #ifdef _OPENMP
 	#pragma omp parallel for schedule(static)
@@ -175,7 +175,7 @@ void Mathzone_Add1::Cubic_Spline_Interpolation
 		//ddy[m] = ddy_tmp;
 	}
 
-	ModuleBase::timer::tick("Mathzone_Add1","Cubic_Spline_Interpolation");
+	ModuleBase::timer::tick("Mathzone","cubic_spline");
 }
 
 /// Interpolation for Numerical Orbitals

source/module_base/timer.cpp

@@ -1,8 +1,3 @@
-//==========================================================
-// AUTHOR : fangwei , mohan
-// DATE : 2008-11-06,
-// UPDATE : Peize Lin at 2019-11-21
-//==========================================================
 #include "timer.h"
 
 #include <cmath>
@@ -53,19 +48,10 @@ double timer::cpu_time()
 // only first call can let t0 = 0,clock begin
 // when enter this function second time , t0 > 0
 //----------------------------------------------------------
-	// static clock_t t0 = clock();
-	// const clock_t t1 = clock() - t0;
-	// return (t1<0) ? 0 : (double)t1/CLOCKS_PER_SEC;
-
-	// static time_t t0 = time(NULL);
-	// const time_t t1 = time(NULL);
-	// double res = difftime(t1, t0);
-	// return (res<0) ? 0 : res;
 	static auto t1 = std::chrono::system_clock::now();
 	const auto t2 = std::chrono::system_clock::now();
 	auto duration = std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1);
 	return double(duration.count()) * std::chrono::microseconds::period::num / std::chrono::microseconds::period::den;
-		// mohan add, abandon the cross point time 2^32 ~ -2^32 .
 }
 
 void timer::tick(const std::string &class_name,const std::string &name)
@@ -118,13 +104,6 @@ void timer::tick(const std::string &class_name,const std::string &name)
 				timer_one.cpu_second += MPI_Wtime() - timer_one.cpu_start;
 			}
 #else
-			// if(class_name=="electrons"&&name=="c_bands")
-			// {
-			// 	cout<<"call times"<<timer_one.calls<<endl;
-			// 	cout<<"electrons c_bands cost time:"<<endl;
-			// 	cout<<cpu_time()<<"-"<<timer_one.cpu_start<<endl;
-			// }
-
 			timer_one.cpu_second += (cpu_time() - timer_one.cpu_start);
 #endif
 			timer_one.start_flag = true;
@@ -201,7 +180,9 @@ void timer::write_to_json(std::string file_name)
 		order_a ++;
 		// if calss_name == "", it means total time, so we skip it
 		if(timer_pool_A.first == "")
+		{
 			continue;
+		}
 		int order_b = 0;
 		const std::string class_name = timer_pool_A.first;
 		ofs << indent << indent << "{\n";
@@ -214,20 +195,32 @@ void timer::write_to_json(std::string file_name)
 			const Timer_One timer_one = timer_pool_B.second;
 			ofs << indent << indent << indent << indent << "{\n";
 			ofs << indent << indent << indent << indent << "\"name\": \"" << name << "\",\n";
-			ofs << indent << indent << indent << indent << "\"cpu_second\": " << std::setprecision(15) << timer_one.cpu_second << ",\n";
+			ofs << indent << indent << indent << indent << "\"cpu_second\": " 
+				<< std::setprecision(15) << timer_one.cpu_second << ",\n";
 			ofs << indent << indent << indent << indent << "\"calls\": " << timer_one.calls << ",\n";
-			ofs << indent << indent << indent << indent << "\"cpu_second_per_call\": " << double_to_string(timer_one.cpu_second/timer_one.calls) << ",\n";
-			ofs << indent << indent << indent << indent << "\"cpu_second_per_total\": " << double_to_string(timer_one.cpu_second/timer_pool[""]["total"].cpu_second) << "\n";
+			ofs << indent << indent << indent << indent << "\"cpu_second_per_call\": " 
+				<< double_to_string(timer_one.cpu_second/timer_one.calls) << ",\n";
+			ofs << indent << indent << indent << indent << "\"cpu_second_per_total\": " 
+				<< double_to_string(timer_one.cpu_second/timer_pool[""]["total"].cpu_second) << "\n";
+
 			if (order_b == timer_pool_A.second.size())
+			{
 				ofs << indent << indent << indent << indent << "}\n";
+			}
 			else
+			{
 				ofs << indent << indent << indent << indent << "},\n";
+			}
 		}
 		ofs << indent << indent << indent << "]\n";
 		if (order_a == timer_pool.size())
+		{
 			ofs << indent << indent << "}\n";
+		}
 		else
+		{
 			ofs << indent << indent << "},\n";
+		}
 	}
 	ofs << indent << "]\n";
 	ofs << "}\n";
@@ -248,9 +241,12 @@ void timer::print_all(std::ofstream &ofs)
 			const std::string name = timer_pool_B.first;
 			const Timer_One timer_one = timer_pool_B.second;
 			if(timer_pool_order.size() < timer_one.order+1)
+			{
 				timer_pool_order.resize(timer_one.order+1);
+			}
 			//timer_pool_order[timer_one.order] = {{class_name, name}, timer_one}; //qianrui change it to make it compatible with old compiler version
-			timer_pool_order[timer_one.order] = std::pair<std::pair<std::string,std::string>, Timer_One> {std::pair<std::string,std::string >{class_name,name}, timer_one};
+			timer_pool_order[timer_one.order] = std::pair<std::pair<std::string,std::string>, Timer_One> {
+            std::pair<std::string,std::string >{class_name,name}, timer_one};
 		}
 	}
 	std::vector<std::string> class_names;
@@ -266,25 +262,42 @@ void timer::print_all(std::ofstream &ofs)
 		const Timer_One &timer_one = timer_pool_order_A.second;
 
 		if(timer_one.cpu_second < 0)
+		{
 			continue;
+		}
+
+		// only print out timers that are larger than 1%
+		// mohan add 2025-03-09
+		const double percentage_thr = 1.0;
+        const double percentage = timer_one.cpu_second / timer_pool_order[0].second.cpu_second * 100;
+		if(percentage<percentage_thr)
+		{
+			continue;
+		}
+
 		class_names.push_back(class_name);
 		names.push_back(name);
 		times.push_back(timer_one.cpu_second);
 		calls.push_back(timer_one.calls);
 		avgs.push_back(timer_one.cpu_second/timer_one.calls);
 
+
 		// if the total time is too small, we do not calculate the percentage
-		if (timer_pool_order[0].second.cpu_second < 1e-9) {
-    		pers.push_back(0);
-		} else {
-    		pers.push_back(timer_one.cpu_second / timer_pool_order[0].second.cpu_second * 100);
+		if (timer_pool_order[0].second.cpu_second < 1e-9) 
+		{
+			pers.push_back(0);
+		} 
+		else 
+		{
+			pers.push_back(percentage);
 		}
 	}
 	assert(class_names.size() == names.size());
 	assert(class_names.size() == times.size());
 	assert(class_names.size() == calls.size());
 	assert(class_names.size() == avgs.size());
 	assert(class_names.size() == pers.size());
+
 	std::vector<std::string> titles = {"CLASS_NAME", "NAME", "TIME/s", "CALLS", "AVG/s", "PER/%"};
 	std::vector<std::string> formats = {"%-10s", "%-10s", "%6.2f", "%8d", "%6.2f", "%6.2f"};
 	FmtTable time_statistics(titles, pers.size(), formats, {FmtTable::Align::LEFT, FmtTable::Align::CENTER});
@@ -293,107 +306,6 @@ void timer::print_all(std::ofstream &ofs)
 	std::cout<<table<<std::endl;
 	ofs<<table<<std::endl;
 	write_to_json("time.json");
-}
-}
 
-/*
-void timer::print_all(std::ofstream &ofs)
-{
-//	std::cout<<"\n timer::print_all()"<<std::endl;
-	const double small = 0.1; // cpu = 10^6
-	// if want to print > 1s , set small = 10^6
-
-	std::cout << std::setprecision(2);
-
-	// prepare
-	bool *print_flag = new bool[n_clock];
-	for(int i=0; i<n_clock; i++)
-	{
-		print_flag[i] = false;
-	}
-
-	int type = 1; // 2:calls 1:total_time
-	bool non_reorder = 1;
-
-	std::cout<<"\n  |CLASS_NAME---------|NAME---------------|TIME(Sec)-----|CALLS----|AVG------|PER%-------" << std::endl;
-	ofs <<"\n\n\n\n  |CLASS_NAME---------|NAME---------------|TIME(Sec)-----|CALLS----|AVG------|PER%-------" << std::endl;
-	ofs << std::setprecision(3);
-	for (int i=0; i<n_clock; i++)
-	{
-		int k = 0;
-		double tmp = -1.0;
-
-		if(non_reorder)
-		{
-			k = i;
-		}
-		else
-		{
-			// search in all clocks
-			for(int j=0; j<n_clock; j++)
-			{
-				if(print_flag[j])
-				{
-					continue;
-				}
-				if(type==1)
-				{
-					if(tmp < cpu_second[j])
-					{
-						k = j;
-						tmp = cpu_second[j];
-					}
-				}
-				else if(type==2)
-				{
-					if(tmp < calls[j])
-					{
-						k = j;
-						tmp = calls[j];
-					}
-				}
-			}
-		}
-		print_flag[k]=true;
-
-		if ((cpu_second[k] >= 0 && cpu_second[k] < small) ||
-		        (cpu_second[k] <= 0 && cpu_second[k] > -small))
-		{
-			continue;
-		}
-
-		if( level[k] > 'X' ) continue;
-
-
-		const long double spend_time = cpu_second[k];
-		const double average_spend_time = spend_time/calls[k];
-
-
-		ofs  << " "
-			 << std::setw(2) << level[k]
-			 << std::setw(20) << class_name[k]
-			 << std::setw(20) << name[k]
-			 << std::setw(15) << spend_time
-			 << std::setw(10) << calls[k]
-			 << std::setw(10) << std::setprecision(2) << average_spend_time
-			 << std::setw(10) << spend_time / cpu_second[0] * 100 << "%" << std::endl;
-
-
-		std::cout << std::resetiosflags(ios::scientific);
-
-		std::cout  << " "
-		     << std::setw(2) << level[k]
-			 << std::setw(20) << class_name[k]
-			 << std::setw(20) << name[k]
-			 << std::setw(15) << spend_time
-			 << std::setw(10) << calls[k]
-			 << std::setw(10) << std::setprecision(2) << average_spend_time
-			 << std::setw(10) << spend_time / cpu_second[0] * 100 << "%" << std::endl;
-
-	}
-	std::cout<<" ----------------------------------------------------------------------------------------"<<std::endl;
-	ofs <<" ----------------------------------------------------------------------------------------"<<std::endl;
-	delete[] print_flag;
-	return;
 }
-*/
+}

source/module_esolver/esolver_ks_lcao_tddft.cpp

@@ -41,7 +41,7 @@ namespace ModuleESolver
 template <typename Device>
 ESolver_KS_LCAO_TDDFT<Device>::ESolver_KS_LCAO_TDDFT()
 {
-    classname = "ESolver_KS_LCAO_TDDFT";
+    classname = "ESolver_rtTDDFT";
     basisname = "LCAO";
 
     // If the device is GPU, we must open use_tensor and use_lapack
@@ -326,26 +326,25 @@ void ESolver_KS_LCAO_TDDFT<Device>::update_pot(UnitCell& ucell,
     // print "eigen value" for tddft
     if (conv_esolver)
     {
-        GlobalV::ofs_running << "---------------------------------------------------------------"
-                                "---------------------------------"
+        GlobalV::ofs_running << "----------------------------------------------------------"
+                             << std::endl;
+        GlobalV::ofs_running << " Print E=<psi_i|H|psi_i> " << std::endl;
+        GlobalV::ofs_running << " k-point  state    energy (eV)" << std::endl;
+        GlobalV::ofs_running << "----------------------------------------------------------"
                              << std::endl;
-        GlobalV::ofs_running << "Eii : " << std::endl;
-        GlobalV::ofs_running << "ik  iband    Eii (eV)" << std::endl;
         GlobalV::ofs_running << std::setprecision(6);
         GlobalV::ofs_running << std::setiosflags(std::ios::showpoint);
 
         for (int ik = 0; ik < kv.get_nks(); ik++)
         {
             for (int ib = 0; ib < PARAM.inp.nbands; ib++)
             {
-                GlobalV::ofs_running << ik + 1 << "     " << ib + 1 << "      "
-                                     << this->pelec->ekb(ik, ib) * ModuleBase::Ry_to_eV << std::endl;
+                GlobalV::ofs_running << " " << std::setw(7) << ik + 1 
+                                     << std::setw(7) << ib + 1 
+                                     << std::setw(10) << this->pelec->ekb(ik, ib) * ModuleBase::Ry_to_eV 
+                                     << std::endl;
             }
         }
-        GlobalV::ofs_running << std::endl;
-        GlobalV::ofs_running << "---------------------------------------------------------------"
-                                "---------------------------------"
-                             << std::endl;
     }
 }