C++ programımda belirli bir fonksiyonun Linux üzerinde ne kadar sürede çalıştığını öğrenmek istiyorum. Daha sonra bir hız karşılaştırması yapmak istiyorum. Birkaç zaman fonksiyonu gördüm ama boost'tan bununla sonuçlandım. Chrono:
process_user_cpu_clock, captures user-CPU time spent by the current process
Şimdi, yukarıdaki işlevi kullanırsam, CPU'nun bu işlev için harcadığı tek zamanı mı alacağım?
İkinci olarak, yukarıdaki fonksiyonun kullanımına ilişkin herhangi bir örnek bulamadım. Lütfen yukarıdaki fonksiyonu nasıl kullanacağım konusunda bana yardımcı olabilir misiniz?
Not: Şu anda, zamanı saniye cinsinden almak için std::chrono::system_clock::now()
kullanıyorum, ancak bu bana her seferinde farklı CPU yükü nedeniyle farklı sonuçlar veriyor.
C++11'de kullanımı çok kolay bir yöntemdir. <chrono>
başlığından std::chrono::high_resolution_clock
kullanmanız gerekir.
Bu şekilde kullanın:
#include <iostream>
#include <chrono>
void function()
{
long long number = 0;
for( long long i = 0; i != 2000000; ++i )
{
number += 5;
}
}
int main()
{
auto t1 = std::chrono::high_resolution_clock::now();
function();
auto t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count();
std::cout << duration;
return 0;
}
Bu, fonksiyonun süresini ölçecektir.
NOT: Bir fonksiyon için her zaman aynı zamanlamayı elde edemezsiniz. Bunun nedeni, makinenizin CPU'sunun bilgisayarınızda çalışan diğer işlemler tarafından daha az veya daha fazla kullanılabilmesidir, tıpkı bir matematik alıştırmasını çözerken zihninizin daha fazla veya daha az konsantre olabileceği gibi. İnsan zihninde bir matematik probleminin çözümünü hatırlayabiliriz, ancak bir bilgisayar için aynı işlem her zaman yeni bir şey olacaktır; bu nedenle, dediğim gibi, her zaman aynı sonucu elde edemezsiniz!
İşte argüman olarak aktarılan herhangi bir fonksiyonun yürütme süresini ölçecek bir fonksiyon:
#include <chrono>
#include <utility>
typedef std::chrono::high_resolution_clock::time_point TimeVar;
#define duration(a) std::chrono::duration_cast<std::chrono::nanoseconds>(a).count()
#define timeNow() std::chrono::high_resolution_clock::now()
template<typename F, typename... Args>
double funcTime(F func, Args&&... args){
TimeVar t1=timeNow();
func(std::forward<Args>(args)...);
return duration(timeNow()-t1);
}
Örnek kullanım:
#include <iostream>
#include <algorithm>
typedef std::string String;
//first test function doing something
int countCharInString(String s, char delim){
int count=0;
String::size_type pos = s.find_first_of(delim);
while ((pos = s.find_first_of(delim, pos)) != String::npos){
count++;pos++;
}
return count;
}
//second test function doing the same thing in different way
int countWithAlgorithm(String s, char delim){
return std::count(s.begin(),s.end(),delim);
}
int main(){
std::cout<<"norm: "<<funcTime(countCharInString,"precision=10",'=')<<"\n";
std::cout<<"algo: "<<funcTime(countWithAlgorithm,"precision=10",'=');
return 0;
}
Çıktı:
norm: 15555
algo: 2976
Bir fonksiyonun yürütme süresini bulmak için basit bir program.
#include <iostream>
#include <ctime> // time_t
#include <cstdio>
void function()
{
for(long int i=0;i<1000000000;i++)
{
// do nothing
}
}
int main()
{
time_t begin,end; // time_t is a datatype to store time values.
time (&begin); // note time before execution
function();
time (&end); // note time after execution
double difference = difftime (end,begin);
printf ("time taken for function() %.2lf seconds.\n", difference );
return 0;
}