производительность — вычисление процессорного времени в C ++ в Windows
Есть ли способ в C ++, чтобы рассчитать, сколько времени требуется для запуска данной программы или процедуры во время процессора?
Я работаю с Visual Studio 2008 под управлением Windows 7.
Решение
Если вы хотите узнать общее количество процессорного времени, используемого процессом, ни clock ни rdtsc (напрямую или через встроенный компилятор) — действительно лучший выбор, по крайней мере, IMO. Если вам нужен переносимый код, лучшее, что вы можете сделать, это использовать clockпротестируйте систему как можно тише и надейтесь на лучшее (но если это так, знайте, что разрешение clock является CLOCKS_PER_SEC, которое может быть или не быть 1000, и даже если это так, ваше фактическое временное разрешение часто не будет таким хорошим — оно может дать вам время в миллисекундах, но, по крайней мере, обычно увеличивается на десятки миллисекунд за раз).
Однако, поскольку вы, похоже, не возражаете против кода, специфичного для Windows, вы можете сделать это немного лучше. По крайней мере, если мое понимание того, что вы ищете, верно, то, что вы действительно хотите, это, вероятно, GetProcessTimes, который (отдельно) сообщит вам об использовании процессора процессом как в режиме ядра, так и в режиме пользователя (а также время начала и время выхода, из которого вы можете вычислить время, которое вы использовали на стене, если вам это нужно). Есть также QueryProcessCycleTime, которая сообщит вам общее количество тактов ЦП, использованных процессом (общее количество как в режиме пользователя, так и в режиме ядра во всех потоках). Лично мне трудно представить себе, что последнее очень полезно — подсчет отдельных тактов может быть полезен для маленький фрагменты кода подвергаются интенсивной оптимизации, но я менее уверен в том, как вы примените его к завершенному процессу. GetProcessTimes использует структуры FILETIME, которые поддерживают разрешение 100 наносекунд, но в действительности вы увидите, что в большинстве случаев это будет кратный временной интервал планировщика (который варьируется в зависимости от версии окон, но составляет порядка от миллисекунд до десятков миллисекунд).
В любом случае, если вы действительно хотите время от начала до конца, GetProcessTimes позволит вам сделать это — если вы порождаете программу (например, с CreateProcess), вы получите дескриптор процесса, который будет сигнализироваться при выходе из дочернего процесса. Вы можете позвонить GetProcessTimes на этом дескрипторе и извлекайте времена, даже если дочерний элемент уже вышел — дескриптор останется действительным, пока хотя бы один дескриптор процесса остается открытым.
Другие решения
Вот один из способов. Он измеряет обычное время ожидания в миллисекундах.
clock_t begin=clock(); начинается до выполнения маршрута и clock_t end=clock(); начинается сразу после выхода из рутины.
Два набора времени затем вычитаются друг из друга, и в результате получается значение в миллисекодах.
#include <stdio.h>
#include <iostream>
#include <time.h>
using namespace std;
double get_CPU_time_usage(clock_t clock1,clock_t clock2)
{
double diffticks=clock1-clock2;
double diffms=(diffticks*1000)/CLOCKS_PER_SEC;
return diffms;
}
void test_CPU_usage()
{
cout << "Standby.. measuring exeution time: ";
for (int i=0; i<10000;i++)
{
cout << "\b\\" << std::flush;
cout << "\b|" << std::flush;
cout << "\b/" << std::flush;
cout << "\b-" << std::flush;
}
cout << " \n\n";
}
int main (void)
{
clock_t begin=clock();
test_CPU_usage();
clock_t end=clock();
cout << "Time elapsed: " << double(get_CPU_time_usage(end,begin)) << " ms ("<<double(get_CPU_time_usage(end,begin))/1000<<" sec) \n\n";
return 0;
}
__rdtscp intrinsic даст вам время в циклах процессора с некоторыми оговорками.
Вот статья MSDN
Это действительно зависит от того, что вы хотите измерить. Для лучших результатов возьмите в среднем несколько миллионов (если не миллиард) итераций.
Функция clock () [как предусмотрено в Visual C ++ 2008] не возвращает процессорное время, используемое программой, пока должен (в соответствии со стандартом C и / или стандартом C ++). Тем не менее, для измерения процессорного времени в Windows у меня есть вспомогательный класс (который неизбежно является непереносимым):
class ProcessorTimer
{
public:
ProcessorTimer() { start(); }
void start() { ::GetProcessTimes(::GetCurrentProcess(), &ft_[3], &ft_[2], &ft_[1], &ft_[0]); }
std::tuple<double, double> stop()
{
::GetProcessTimes(::GetCurrentProcess(), &ft_[5], &ft_[4], &ft_[3], &ft_[2]);
ULARGE_INTEGER u[4];
for (size_t i = 0; i < 4; ++i)
{
u[i].LowPart = ft_[i].dwLowDateTime;
u[i].HighPart = ft_[i].dwHighDateTime;
}
double user = (u[2].QuadPart - u[0].QuadPart) / 10000000.0;
double kernel = (u[3].QuadPart - u[1].QuadPart) / 10000000.0;
return std::make_tuple(user, kernel);
}
private:
FILETIME ft_[6];
};class ScopedProcessorTimer
{
public:
ScopedProcessorTimer(std::ostream& os = std::cerr) : timer_(ProcessorTimer()), os_(os) { }
~ScopedProcessorTimer()
{
std::tuple<double, double> t = timer_.stop();
os_ << "user " << std::get<0>(t) << "\n";
os_ << "kernel " << std::get<1>(t) << "\n";
}
private:
ProcessorTimer timer_;
std::ostream& os_;
}
Например, можно измерить, сколько времени занимает выполнение блока, определив ScopedProcessorTimer в начале этого блока {}.
Этот код является процесс использования процессора
ULONGLONG LastCycleTime = NULL;
LARGE_INTEGER LastPCounter;
LastPCounter.QuadPart = 0; // LARGE_INTEGER Init
// cpu get core number
SYSTEM_INFO sysInfo;
GetSystemInfo(&sysInfo);
int numProcessors = sysInfo.dwNumberOfProcessors;
HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, Process::pid);
if (hProcess == NULL)
nResult = 0;
int count = 0;
while (true)
{
ULONG64 CycleTime;
LARGE_INTEGER qpcLastInt;
if (!QueryProcessCycleTime(hProcess, &CycleTime))
nResult = 0;
ULONG64 cycle = CycleTime - LastCycleTime;
if (!QueryPerformanceCounter(&qpcLastInt))
nResult = 0;
double Usage = cycle / ((double)(qpcLastInt.QuadPart - LastPCounter.QuadPart));
// Scaling
Usage *= 1.0 / numProcessors;
Usage *= 0.1;
LastPCounter = qpcLastInt;
LastCycleTime = CycleTime;
if (count > 3)
{
printf("%.1f", Usage);
break;
}
Sleep(1); // QueryPerformanceCounter Function Resolution is 1 microsecond
count++;
}
CloseHandle(hProcess);
detector