C++를 사용하여 나노초 단위로 시간을 제공하는 타이머 기능
API가 값을 반환하는 데 걸린 시간을 계산하고 싶습니다.이러한 동작에 걸리는 시간은 나노초입니다.API는 C++ 클래스/함수이기 때문에 timer.h를 사용하여 같은 값을 계산합니다.
#include <ctime>
#include <iostream>
using namespace std;
int main(int argc, char** argv) {
clock_t start;
double diff;
start = clock();
diff = ( std::clock() - start ) / (double)CLOCKS_PER_SEC;
cout<<"printf: "<< diff <<'\n';
return 0;
}
위의 코드는 초단위로 시간을 나타냅니다.어떻게 하면 나노초 안에 정확하게 같은 것을 얻을 수 있을까요?
루프에서 함수를 반복적으로 실행하는 것에 대해 다른 사람이 올린 글은 정확합니다.
Linux(및 BSD)의 경우 clock_gettime()을 사용합니다.
#include <sys/time.h>
int main()
{
timespec ts;
// clock_gettime(CLOCK_MONOTONIC, &ts); // Works on FreeBSD
clock_gettime(CLOCK_REALTIME, &ts); // Works on Linux
}
윈도우의 경우 Query Performance Counter를 사용합니다.QPC에 대한 자세한 내용은 다음과 같습니다.
일부 칩셋에서는 QPC에 이미 알려진 문제가 있기 때문에 칩셋이 없는 것을 확인하는 것이 좋습니다.또한 일부 듀얼 코어 AMD에서도 문제가 발생할 수 있습니다.sebbi의 두 번째 투고를 참조해 주십시오.여기서 그는 다음과 같이 말하고 있습니다.
Query Performance Counter()와 Query Performance Frequency()는 조금 더 나은 해상도를 제공하지만 다른 문제가 있습니다.예를 들어 Windows XP에서는 문제를 해결하기 위해 특별히 AMD 듀얼 코어 드라이버 패키지를 설치하지 않는 한 모든 AMD Athlon X2 듀얼 코어 CPU는 "랜덤하게" 코어 중 하나의 PC를 반환합니다(PC가 약간 뒤로 점프하는 경우도 있습니다).유사한 문제가 있는 다른 듀얼+코어 CPU(p4 dual, p4 ht, core2 dual, core2 quad, phenom quad)는 발견되지 않았습니다.
2013/07/16 편집:
http://msdn.microsoft.com/en-us/library/windows/desktop/ee417693(v=vs.85).aspx에 기재되어 있듯이 특정 상황에서 QPC의 유효성에 대해서는 논란이 있는 것으로 보입니다.
...Query Performance Counter 및 Query Performance Frequency는 일반적으로 여러 프로세서에 대해 조정되지만, BIOS 또는 드라이버의 버그로 인해 스레드가 프로세서에서 다른 프로세서로 이동할 때 이러한 루틴이 다른 값을 반환할 수 있습니다.
단, 이 StackOverflow 응답 https://stackoverflow.com/a/4588605/34329에서는 QPC가 Win XP 서비스 팩2 이후의 모든 MS OS에서 정상적으로 동작할 것이라고 기재되어 있습니다.
이 문서에서는 Windows 7이 프로세서에 불변 TSC가 있는지 여부를 판별할 수 있으며, 없을 경우 외부 타이머로 폴백할 수 있음을 보여 줍니다.http://performancebydesign.blogspot.com/2012/03/high-resolution-clocks-and-timers-for.html 프로세서를 통한 동기화는 아직 문제가 있습니다.
타이머와 관련된 기타 정밀 판독치:
- https://blogs.oracle.com/dholmes/entry/inside_the_hotspot_vm_clocks
- http://lwn.net/Articles/209101/
- http://performancebydesign.blogspot.com/2012/03/high-resolution-clocks-and-timers-for.html
- Query Performance Counter 상태?
상세한 것에 대하여는, 코멘트를 참조해 주세요.
은 CC++11을 합니다.<chrono>그 에도 사용법을 알 수 있는 .<chrono> 중 않습니다.<chrono>RDTSC여기 있는 몇 가지 다른 답변에 언급된 기능. 어떻게 요.RDTSC<chrono> 하는 방법에 , ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★」이것에 의해, 테스트 코드를 신속히 전환할 수 있습니다.RDTSC 「」에 하고 있을 입니다).clock(),clock_gettime() "/"/"QueryPerformanceCounter.
에 주의:RDTSCx86을 사용하다.x86 86고다다다다8686 。 QueryPerformanceCounterwindows Windows の 다다다다다 。 ★★★★★★★★★★★★★★★★★.clock_gettime() 전용입니다에서는 두 가지 시계를 합니다. 바로 '보다'입니다.std::chrono::high_resolution_clock ★★★★★★★★★★★★★★★★★」std::chrono::system_clockC++11이 크로스 플랫폼이라고 가정할 수 있습니다.
C++에서 C을 작성하는 .rdtsc★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★」x::clock:
#include <chrono>
namespace x
{
struct clock
{
typedef unsigned long long rep;
typedef std::ratio<1, 2'800'000'000> period; // My machine is 2.8 GHz
typedef std::chrono::duration<rep, period> duration;
typedef std::chrono::time_point<clock> time_point;
static const bool is_steady = true;
static time_point now() noexcept
{
unsigned lo, hi;
asm volatile("rdtsc" : "=a" (lo), "=d" (hi));
return time_point(duration(static_cast<rep>(hi) << 32 | lo));
}
};
} // x
이 클럭은 CPU 사이클을 카운트하여 부호 없는 64비트 정수에 저장하는 것 뿐입니다.컴파일러의 어셈블리 언어 구문을 조정해야 할 수 있습니다.또는 컴파일러가 대신 사용할 수 있는 내재를 제공할 수도 있습니다(예:now() {return __rdtsc();}를 참조해 주세요.
클럭을 작성하려면 클럭에 표현(스토리지 유형)을 지정해야 합니다.또, 다른 전원 모드로 클럭 속도를 변경할 수 있는 경우에도, 클럭 기간을 지정할 필요가 있습니다.이것은 컴파일 시간 상수여야 합니다.또한 이러한 기본 개념에 따라 클럭의 "원어민" 시간 지속 시간 및 시점을 쉽게 정의할 수 있습니다.
클럭 틱 수를 출력하기만 하면 클럭 주기에 대해 어떤 수를 지정하든 상관없습니다.이 상수는 클럭틱 수를 나노초 등의 실시간 단위로 변환하는 경우에만 적용됩니다.이 경우 클럭 속도를 정확하게 제공할수록 나노초(밀리초)로 변환하는 정확도가 높아집니다.
은 사용법을 입니다.x::clock같은 구문을 가진 많은 다른 클럭을 어떻게 사용할 수 있는지 보여드리고 싶기 때문에 실제로 시계의 코드를 템플릿으로 만들었습니다. 테스트에서는할 때 인지 보여 .
#include <iostream>
template <class clock>
void
test_empty_loop()
{
// Define real time units
typedef std::chrono::duration<unsigned long long, std::pico> picoseconds;
// or:
// typedef std::chrono::nanoseconds nanoseconds;
// Define double-based unit of clock tick
typedef std::chrono::duration<double, typename clock::period> Cycle;
using std::chrono::duration_cast;
const int N = 100000000;
// Do it
auto t0 = clock::now();
for (int j = 0; j < N; ++j)
asm volatile("");
auto t1 = clock::now();
// Get the clock ticks per iteration
auto ticks_per_iter = Cycle(t1-t0)/N;
std::cout << ticks_per_iter.count() << " clock ticks per iteration\n";
// Convert to real time units
std::cout << duration_cast<picoseconds>(ticks_per_iter).count()
<< "ps per iteration\n";
}
이 코드의 첫 번째 동작은 결과를 표시하는 "실시간" 단위를 만드는 것입니다.피코초를 선택했지만 적분 또는 부동소수점 기준으로 원하는 단위를 선택할 수 있습니다.를 들면, 미리 것이 .std::chrono::nanoseconds★★★★★★★★★★★★★★★★★」
단위('보다'라고 함)를 다른 합니다.Cycle을 사용법
는, 「」에의 타임 .clock::now()이 을 붙이는 다음과 같습니다.
typename clock::time_point t0 = clock::now();
명확하게 )x::clock(시스템에 의해 제공되는 클럭에도 해당됩니다).
부동소수점 클럭틱의 관점에서 지속시간을 얻으려면 2개의 시점을 빼고 반복당 값을 얻으려면 해당 지속시간을 반복 횟수로 나눕니다.
는 어떤 할 수 .count()표현을 합니다.내부 표현을 반환합니다.으로 하겠습니다.std::chrono::duration_cast을 Cycle picoseconds출력해 주세요.
이 코드를 사용하는 방법은 간단합니다.
int main()
{
std::cout << "\nUsing rdtsc:\n";
test_empty_loop<x::clock>();
std::cout << "\nUsing std::chrono::high_resolution_clock:\n";
test_empty_loop<std::chrono::high_resolution_clock>();
std::cout << "\nUsing std::chrono::system_clock:\n";
test_empty_loop<std::chrono::system_clock>();
}
에서 저는 집에서 시험을 합니다.x::clock 결과를 클럭의 합니다.「 」 、 「 」 、 「 2 」 。std::chrono::high_resolution_clock ★★★★★★★★★★★★★★★★★」std::chrono::system_clock
Using rdtsc:
1.72632 clock ticks per iteration
616ps per iteration
Using std::chrono::high_resolution_clock:
0.620105 clock ticks per iteration
620ps per iteration
Using std::chrono::system_clock:
0.00062457 clock ticks per iteration
624ps per iteration
이는 클럭마다 틱이 크게 다르기 때문에 이들 클럭마다 틱 주기가 다르다는 것을 나타냅니다.그러나 알려진 시간 단위(예: 피코초)로 환산하면 각 클럭에 대해 거의 동일한 결과를 얻을 수 있습니다(마일리지가 다를 수 있음).
내 코드에는 "매직 변환 상수"가 전혀 없습니다.실제로 전체 예에서 매직 번호는 두 개뿐입니다.
- 클럭 속도를 합니다.
x::clock. - 테스트할 반복 횟수입니다.이 수를 변경하면 결과가 크게 달라지는 경우에는 반복 횟수를 늘리거나 테스트 중에 컴퓨터에 경쟁 프로세스가 없는지 확인해야 합니다.
이 정도 정밀도라면 clock()과 같은 시스템콜이 아닌 CPU 틱으로 추론하는 것이 좋습니다.그리고 명령을 실행하는 데 1나노초 이상이 걸린다면...나노초의 정확도를 갖는 것은 거의 불가능합니다.
CPU가 마지막으로 시작된 이후 경과한 80x86 CPU 클럭틱 수를 취득하기 위한 실제 코드를 다음에 나타냅니다.Pentium 이상에서는 동작합니다(386/486은 지원되지 않습니다).이 코드는 실제로는 MS Visual C++에 고유하지만 인라인어셈블리를 지원하는 한 다른 어떤 코드에도 쉽게 이식할 수 있습니다.
inline __int64 GetCpuClocks()
{
// Counter
struct { int32 low, high; } counter;
// Use RDTSC instruction to get clocks count
__asm push EAX
__asm push EDX
__asm __emit 0fh __asm __emit 031h // RDTSC
__asm mov counter.low, EAX
__asm mov counter.high, EDX
__asm pop EDX
__asm pop EAX
// Return result
return *(__int64 *)(&counter);
}
이 기능은 매우 빠르다는 이점도 있습니다. 보통 50개 이상의 CPU 사이클이 필요하지 않습니다.
타이밍 수치 사용:
클럭 카운트를 실제 경과 시간으로 변환할 필요가 있는 경우 결과를 칩의 클럭 속도로 나눕니다."정격" GHz는 칩의 실제 속도와 약간 다를 수 있습니다.칩의 실제 속도를 확인하려면 몇 가지 매우 좋은 유틸리티 또는 Win32 호출인 Query Performance Frequency()를 사용할 수 있습니다.
원하는 결과를 얻기 위해 다음을 사용하고 있습니다.
#include <time.h>
#include <iostream>
using namespace std;
int main (int argc, char** argv)
{
// reset the clock
timespec tS;
tS.tv_sec = 0;
tS.tv_nsec = 0;
clock_settime(CLOCK_PROCESS_CPUTIME_ID, &tS);
...
... <code to check for the time to be put here>
...
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &tS);
cout << "Time taken is: " << tS.tv_sec << " " << tS.tv_nsec << endl;
return 0;
}
두 방법 중 합니다.RDTSC ★★★★★★★★★★★★★★★★★★★★★★.clock_gettime()두 번째는 약 2배 빠르고 절대적인 시간을 줄 수 있는 장점이 있습니다.「 」의 경우는, 을해 주세요.RDTSC올바르게 동작하려면 , 표시된 대로 사용할 필요가 있습니다(이 페이지의 다른 코멘트에 에러가 있어, 특정의 프로세서에서 타이밍 값이 잘못되어 있을 가능성이 있습니다).
inline uint64_t rdtsc()
{
uint32_t lo, hi;
__asm__ __volatile__ (
"xorl %%eax, %%eax\n"
"cpuid\n"
"rdtsc\n"
: "=a" (lo), "=d" (hi)
:
: "%ebx", "%ecx" );
return (uint64_t)hi << 32 | lo;
}
clock_gettime: (마이크로초 해상도를 임의로 선택)
#include <time.h>
#include <sys/timeb.h>
// needs -lrt (real-time lib)
// 1970-01-01 epoch UTC time, 1 mcs resolution (divide by 1M to get time_t)
uint64_t ClockGetTime()
{
timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
return (uint64_t)ts.tv_sec * 1000000LL + (uint64_t)ts.tv_nsec / 1000LL;
}
생성된 타이밍 및 값:
Absolute values:
rdtsc = 4571567254267600
clock_gettime = 1278605535506855
Processing time: (10000000 runs)
rdtsc = 2292547353
clock_gettime = 1031119636
C++11 의 경우는, 다음의 간단한 래퍼를 참조해 주세요.
#include <iostream>
#include <chrono>
class Timer
{
public:
Timer() : beg_(clock_::now()) {}
void reset() { beg_ = clock_::now(); }
double elapsed() const {
return std::chrono::duration_cast<second_>
(clock_::now() - beg_).count(); }
private:
typedef std::chrono::high_resolution_clock clock_;
typedef std::chrono::duration<double, std::ratio<1> > second_;
std::chrono::time_point<clock_> beg_;
};
또는 *nix의 C++03의 경우,
class Timer
{
public:
Timer() { clock_gettime(CLOCK_REALTIME, &beg_); }
double elapsed() {
clock_gettime(CLOCK_REALTIME, &end_);
return end_.tv_sec - beg_.tv_sec +
(end_.tv_nsec - beg_.tv_nsec) / 1000000000.;
}
void reset() { clock_gettime(CLOCK_REALTIME, &beg_); }
private:
timespec beg_, end_;
};
사용 예:
int main()
{
Timer tmr;
double t = tmr.elapsed();
std::cout << t << std::endl;
tmr.reset();
t = tmr.elapsed();
std::cout << t << std::endl;
return 0;
}
https://gist.github.com/gongzhitaao/7062087 에서
최소한의 복사 & 붙여넣기 구조 + 느린 사용
간단한 테스트에 사용할 수 있는 미니멀리즘 구조를 갖추는 것이 목적이라면, C++ 파일내의 임의의 장소에 카피앤 페이스트 하는 것을 추천합니다.#include'을 희생한 올맨 스타일의 포맷을 희생한 유일한 사례입니다.
구조물의 첫 번째 줄에서 정밀도를 쉽게 조정할 수 있습니다.할 수 있는 값은 다음과 같습니다.nanoseconds,microseconds,milliseconds,seconds,minutes , 「」hours.
#include <chrono>
struct MeasureTime
{
using precision = std::chrono::microseconds;
std::vector<std::chrono::steady_clock::time_point> times;
std::chrono::steady_clock::time_point oneLast;
void p() {
std::cout << "Mark "
<< times.size()/2
<< ": "
<< std::chrono::duration_cast<precision>(times.back() - oneLast).count()
<< std::endl;
}
void m() {
oneLast = times.back();
times.push_back(std::chrono::steady_clock::now());
}
void t() {
m();
p();
m();
}
MeasureTime() {
times.push_back(std::chrono::steady_clock::now());
}
};
사용.
MeasureTime m; // first time is already in memory
doFnc1();
m.t(); // Mark 1: next time, and print difference with previous mark
doFnc2();
m.t(); // Mark 2: next time, and print difference with previous mark
doStuff = doMoreStuff();
andDoItAgain = doStuff.aoeuaoeu();
m.t(); // prints 'Mark 3: 123123' etc...
표준출력결과
Mark 1: 123
Mark 2: 32
Mark 3: 433234
실행 후 요약을 원하는 경우
예를 들어 중간 코드도 표준 출력에 쓰기 때문에 나중에 보고서를 작성해야 합니다.다음으로 다음 함수를 구조체에 추가합니다(Measure Time() 직전).
void s() { // summary
int i = 0;
std::chrono::steady_clock::time_point tprev;
for(auto tcur : times)
{
if(i > 0)
{
std::cout << "Mark " << i << ": "
<< std::chrono::duration_cast<precision>(tprev - tcur).count()
<< std::endl;
}
tprev = tcur;
++i;
}
}
그 후 다음 기능을 사용할 수 있습니다.
MeasureTime m;
doFnc1();
m.m();
doFnc2();
m.m();
doStuff = doMoreStuff();
andDoItAgain = doStuff.aoeuaoeu();
m.m();
m.s();
이전과 마찬가지로 모든 마크가 나열되지만 다른 코드가 실행된 후에는 표시됩니다., 둘 다 안 요.m.s() ★★★★★★★★★★★★★★★★★」m.t().
간단한 클래스와 함께 Brock Adams의 방법을 사용합니다.
int get_cpu_ticks()
{
LARGE_INTEGER ticks;
QueryPerformanceFrequency(&ticks);
return ticks.LowPart;
}
__int64 get_cpu_clocks()
{
struct { int32 low, high; } counter;
__asm cpuid
__asm push EDX
__asm rdtsc
__asm mov counter.low, EAX
__asm mov counter.high, EDX
__asm pop EDX
__asm pop EAX
return *(__int64 *)(&counter);
}
class cbench
{
public:
cbench(const char *desc_in)
: desc(strdup(desc_in)), start(get_cpu_clocks()) { }
~cbench()
{
printf("%s took: %.4f ms\n", desc, (float)(get_cpu_clocks()-start)/get_cpu_ticks());
if(desc) free(desc);
}
private:
char *desc;
__int64 start;
};
사용 예:
int main()
{
{
cbench c("test");
... code ...
}
return 0;
}
결과:
테스트 완료: 0.0002 ms
일부 함수 콜 오버헤드가 있지만 여전히 충분히 빠를 것입니다.
일반적으로 함수를 호출하는 데 걸리는 시간을 측정하기 위해 한 번이 아니라 여러 번 반복해야 합니다.함수를 한 번만 호출하고 실행하는 데 매우 짧은 시간이 걸리면 실제로 타이머 함수를 호출하는 오버헤드가 남아 시간이 얼마나 걸리는지 알 수 없습니다.
예를 들어 함수를 실행하는 데 800ns가 걸릴 것으로 예상되는 경우 루프에서 호출합니다(그 후 약 8초 소요).총 시간을 1,000만으로 나누어 통화당 시간을 구합니다.
x86 프로세서에서 실행되는 gcc에서는 다음 기능을 사용할 수 있습니다.
unsigned long long rdtsc()
{
#define rdtsc(low, high) \
__asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))
unsigned int low, high;
rdtsc(low, high);
return ((ulonglong)high << 32) | low;
}
Digital Mars C++를 사용하는 경우:
unsigned long long rdtsc()
{
_asm
{
rdtsc
}
}
칩의 하이 퍼포먼스 타이머를 읽어냅니다.프로파일링을 할 때 이걸 써요.
정밀도가 1초 미만인 경우 시스템 고유의 확장을 사용해야 하며 운영 체제 설명서를 확인해야 합니다.POSIX는 gettime of day를 최대 마이크로초까지 지원하지만 컴퓨터의 주파수가 1GHz를 넘지 않았기 때문에 이보다 더 정확한 것은 없습니다.
Boost를 사용하는 경우 boost::posix_time을 확인할 수 있습니다.
나는 여기서 볼랜드 코드를 사용하고 있다.이것은 코드 ti_hund가 나에게 음의 숫자를 몇 번 주지만 타이밍은 꽤 좋다.
#include <dos.h>
void main()
{
struct time t;
int Hour,Min,Sec,Hun;
gettime(&t);
Hour=t.ti_hour;
Min=t.ti_min;
Sec=t.ti_sec;
Hun=t.ti_hund;
printf("Start time is: %2d:%02d:%02d.%02d\n",
t.ti_hour, t.ti_min, t.ti_sec, t.ti_hund);
....
your code to time
...
// read the time here remove Hours and min if the time is in sec
gettime(&t);
printf("\nTid Hour:%d Min:%d Sec:%d Hundreds:%d\n",t.ti_hour-Hour,
t.ti_min-Min,t.ti_sec-Sec,t.ti_hund-Hun);
printf("\n\nAlt Ferdig Press a Key\n\n");
getch();
} // end main
멀티플랫폼타이머(프로세서 사이클 수)에 대한 인터페이스가 있는 Embedded Profiler(Windows 및 Linux의 경우 무료)를 사용할 수 있으며 초당 사이클 수를 제공할 수 있습니다.
EProfilerTimer timer;
timer.Start();
... // Your code here
const uint64_t number_of_elapsed_cycles = timer.Stop();
const uint64_t nano_seconds_elapsed =
mumber_of_elapsed_cycles / (double) timer.GetCyclesPerSecond() * 1000000000;
CPU 주파수가 동적으로 변경될 수 있는 최신 프로세서에서는 사이클 카운트를 시간 단위로 재계산하는 것은 위험한 작업일 수 있습니다.따라서 변환된 시간이 올바른지 확인하기 위해 프로파일링 전에 프로세서 주파수를 변경해야 합니다.
Linux의 경우 "gettimeofday" 함수를 사용하고 있습니다.이 함수는 Epoch 이후 초 및 마이크로초를 나타내는 구조를 반환합니다.그런 다음 timersub를 사용하여 두 개의 시간을 빼서 원하는 시간 정밀도로 변환할 수 있습니다.단, nanoseconds를 지정하면 clock_gettime() 함수가 원하는 것처럼 보입니다.초 단위와 나노초 단위로 시간을 흘려보내는 구조입니다.
이에 대해 어떻게 생각하십니까?
int iceu_system_GetTimeNow(long long int *res)
{
static struct timespec buffer;
//
#ifdef __CYGWIN__
if (clock_gettime(CLOCK_REALTIME, &buffer))
return 1;
#else
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &buffer))
return 1;
#endif
*res=(long long int)buffer.tv_sec * 1000000000LL + (long long int)buffer.tv_nsec;
return 0;
}
여기 제대로 작동하는 좋은 부스트 타이머가 있습니다.
//Stopwatch.hpp
#ifndef STOPWATCH_HPP
#define STOPWATCH_HPP
//Boost
#include <boost/chrono.hpp>
//Std
#include <cstdint>
class Stopwatch
{
public:
Stopwatch();
virtual ~Stopwatch();
void Restart();
std::uint64_t Get_elapsed_ns();
std::uint64_t Get_elapsed_us();
std::uint64_t Get_elapsed_ms();
std::uint64_t Get_elapsed_s();
private:
boost::chrono::high_resolution_clock::time_point _start_time;
};
#endif // STOPWATCH_HPP
//Stopwatch.cpp
#include "Stopwatch.hpp"
Stopwatch::Stopwatch():
_start_time(boost::chrono::high_resolution_clock::now()) {}
Stopwatch::~Stopwatch() {}
void Stopwatch::Restart()
{
_start_time = boost::chrono::high_resolution_clock::now();
}
std::uint64_t Stopwatch::Get_elapsed_ns()
{
boost::chrono::nanoseconds nano_s = boost::chrono::duration_cast<boost::chrono::nanoseconds>(boost::chrono::high_resolution_clock::now() - _start_time);
return static_cast<std::uint64_t>(nano_s.count());
}
std::uint64_t Stopwatch::Get_elapsed_us()
{
boost::chrono::microseconds micro_s = boost::chrono::duration_cast<boost::chrono::microseconds>(boost::chrono::high_resolution_clock::now() - _start_time);
return static_cast<std::uint64_t>(micro_s.count());
}
std::uint64_t Stopwatch::Get_elapsed_ms()
{
boost::chrono::milliseconds milli_s = boost::chrono::duration_cast<boost::chrono::milliseconds>(boost::chrono::high_resolution_clock::now() - _start_time);
return static_cast<std::uint64_t>(milli_s.count());
}
std::uint64_t Stopwatch::Get_elapsed_s()
{
boost::chrono::seconds sec = boost::chrono::duration_cast<boost::chrono::seconds>(boost::chrono::high_resolution_clock::now() - _start_time);
return static_cast<std::uint64_t>(sec.count());
}
plf::nanotimer는 이를 위한 경량 옵션으로 Windows, Linux, Mac 및 BSD 등에서 작동합니다.OS에 따라 최대 마이크로초 정확도:
#include "plf_nanotimer.h"
#include <iostream>
int main(int argc, char** argv)
{
plf::nanotimer timer;
timer.start()
// Do something here
double results = timer.get_elapsed_ns();
std::cout << "Timing: " << results << " nanoseconds." << std::endl;
return 0;
}
언급URL : https://stackoverflow.com/questions/275004/timer-function-to-provide-time-in-nano-seconds-using-c
'programing' 카테고리의 다른 글
| RGB를 HSV로 변환하고 HSV를 RGB로 변환하는 알고리즘(0~255) (0) | 2022.05.29 |
|---|---|
| 형식 스크립트별로 Vue2의 구성 API와 함께 vue 클래스 구성 요소를 사용하는 방법 (0) | 2022.05.29 |
| 음수를 양수로 하다 (0) | 2022.05.29 |
| vuex를 사용할 때 typescript 구문에서 mapState 함수를 사용하는 방법 (0) | 2022.05.28 |
| 어레이에서 Array List를 만듭니다. (0) | 2022.05.28 |