blocks|key|1998963|text|这里有一条路。它测量例程解释时间，以毫秒为单位。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1998964|clock_t+begin=clock();在执行路由之前启动，而clock_t+end=clock();则在例程退出之后立即启动。|offset|length|style|CODE|1998965|然后两个时间集互相减去，结果是一个毫秒值。|1998966|#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%2B%2B)
++{
++++++++cout+<<+"\b\\"+<<+std::flush;
++++++++cout+<<+"\b%7C"+<<+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;
}|code-block|syntax|javascript|1998967|entityMap^0|0|0|M|X|K|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

Here's one way. It measures routine exeution time in milliseconds. 

<code>clock_t begin=clock();</code> starts before the route is executed and <code>clock_t end=clock();</code> starts right after the routine exits. 

The two time sets are then subtracted from each other and the result is a millisecod value.

<pre><code>#include &lt;stdio.h&gt;
#include &lt;iostream&gt;
#include &lt;time.h&gt;
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 &lt;&lt; "Standby.. measuring exeution time: ";

 for (int i=0; i&lt;10000;i++)
 {
 cout &lt;&lt; "\b\\" &lt;&lt; std::flush;
 cout &lt;&lt; "\b|" &lt;&lt; std::flush;
 cout &lt;&lt; "\b/" &lt;&lt; std::flush;
 cout &lt;&lt; "\b-" &lt;&lt; std::flush;
 }

 cout &lt;&lt; " \n\n";
}

int main (void)
{

 clock_t begin=clock();

 test_CPU_usage();

 clock_t end=clock();

 cout &lt;&lt; "Time elapsed: " &lt;&lt; double(get_CPU_time_usage(end,begin)) &lt;&lt; " ms ("&lt;&lt;double(get_CPU_time_usage(end,begin))/1000&lt;&lt;" sec) \n\n";
 return 0;
}
</code></pre>

blocks|key|1998979|text|__rdtscp内部特性将给您在CPU周期中的时间，并附带一些注意事项。这是MSDN文章|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1998980|这真的取决于你想要测量什么。为了获得更好的结果，平均需要几百万次(如果不是十亿次)迭代。|1998981|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb385235%2528v=vs.90%2529.aspx^0|0|8|12|6|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

The <code>__rdtscp</code> intrinsic will give you the time in CPU cycles with some caveats.
Here's <a href="http://msdn.microsoft.com/en-us/library/bb385235%28v=vs.90%29.aspx" rel="nofollow">the MSDN article</a>

It depends really what you want to measure. For better results take the average of a few million (if not billion) iterations.

blocks|key|1999012|text|如果您想知道进程使用的CPU总时间，那么clock或rdtsc+(直接或通过编译器内部)实际上都不是最佳选择，至少IMO是这样的。如果您需要代码是可移植的，那么最好的方法是使用clock，尽可能地在系统中进行测试，并希望得到最好的结果(但如果需要，请注意clock的分辨率是CLOCKS_PER_SEC，它可能是1000，也可能不是1000，即使是这样，您的实际定时分辨率通常不会那么好-它可能以毫秒为单位，但至少在一次中会提前数十毫秒)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1999013|但是，由于您似乎并不介意特定于Windows的代码，所以您可以做得更好。至少，如果我对您正在寻找的内容的理解是正确的，那么您真正想要的可能是GetProcessTimes，它将(分别)告诉您进程的内核模式和用户模式CPU的使用情况(以及启动时间和退出时间，如果您关心的话，可以从中计算使用的墙壁时间)。还有QueryProcessCycleTime，它将告诉您进程使用的CPU时钟周期的总数(所有线程中用户模式和内核模式的总数)。就我个人而言，我很难想象后者有多大用处--计数单个时钟周期对于需要进行密集优化的小部分代码是有用的，但我不太确定如何将其应用于一个完整的过程。GetProcessTimes使用FILETIME结构，它支持100纳秒的分辨率，但实际上，在大多数情况下，您将看到调度器的时间片的倍数(随windows版本的不同而变化，但大约在毫秒到几十毫秒之间)。|1999014|在任何情况下，如果您真的希望从头到尾都需要时间，GetProcessTimes将允许您这样做--如果您生成程序(例如，使用CreateProcess)，您将得到进程的句柄，当子进程退出时，该句柄将被发出信号。然后，您可以对该句柄调用GetProcessTimes，并检索时间，即使子句柄已经退出--只要进程的至少一个句柄仍处于打开状态，该句柄仍然有效。|1999015|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/windows/desktop/ms683223.aspx|1|http://msdn.microsoft.com/en-us/library/windows/desktop/ms684929.aspx^0|K|5|Q|5|2G|5|3J|5|3T|E|0|1Y|F|49|L|7Y|F|1Y|F|0|49|L|1|0|O|F|1P|D|38|F|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]]|E|$]]|$1|H|3|I|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

If you want to know the total amount of CPU time used by a process, neither <code>clock</code> nor <code>rdtsc</code> (either directly or via a compiler intrinsic) is really the best choice, at least IMO. If you need the code to be portable, about the best you can do is use <code>clock</code>, test with the system as quiescent as possible, and hope for the best (but if you do, be aware that the resolution of <code>clock</code> is <code>CLOCKS_PER_SEC</code>, which may or may not be 1000, and even if it is, your actual timing resolution often won't be that good -- it may give you times in milliseconds, but at least normally advance tens of milliseconds at a time).

Since, however, you don't seem to mind the code being specific to Windows, you can do quite a bit better. At least if my understanding of what you're looking for is correctly, what you really want is probably <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms683223.aspx" rel="noreferrer"><code>GetProcessTimes</code></a>, which will (separately) tell you both kernel-mode and user-mode CPU usage of the process (as well as the start time and exit time, from which you can compute wall time used, if you care). There's also <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms684929.aspx" rel="noreferrer"><code>QueryProcessCycleTime</code></a>, which will tell you the total number of CPU clock cycles used by the process (total of both user and kernel mode in all threads). Personally, I have a hard time imagining much use for the latter though -- counting individual clock cycles can be useful for small sections of code subject to intensive optimization, but I'm less certain about how you'd apply it to a complete process. <code>GetProcessTimes</code> uses FILETIME structures, which support resolutions of 100 nanoseconds, but in reality most times you'll see will be multiples of the scheduler's time slice (which varies with the version of windows, but is on the order of milliseconds to tens of milliseconds).

In any case, if you truly want time from beginning to end, <code>GetProcessTimes</code> will let you do that -- if you spawn the program (e.g., with <code>CreateProcess</code>), you'll get a handle to the process which will be signaled when the child process exits. You can then call <code>GetProcessTimes</code> on that handle, and retrieve the times even though the child has already exited -- the handle will remain valid as long as at least one handle to the process remains open.

blocks|key|1522212|text|Visual+C%2B%2B+2008提供的clock()函数不返回程序使用的处理器时间，而它应该返回(根据C标准和/或C%2B%2B标准)。尽管如此，为了测量Windows上的CPU时间，我有这个助手类(这不可避免地是不可移植的)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522213|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;+%2B%2Bi)
++++++++{
++++++++++++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_;
}|code-block|syntax|javascript|1522214|例如，可以通过在{}块的开头定义一个ScopedProcessorTimer来度量一个块执行所需的时间。|1522215|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The clock() function [as provided by Visual C++ 2008] doesn't return processor time used by the program, while it should (according to the C standard and/or C++ standard). That said, to measure CPU time on Windows, I have this helper class (which is inevitably non-portable):

<pre><code>class ProcessorTimer
{
 public:
 ProcessorTimer() { start(); }
 void start() { ::GetProcessTimes(::GetCurrentProcess(), &amp;ft_[3], &amp;ft_[2], &amp;ft_[1], &amp;ft_[0]); }
 std::tuple&lt;double, double&gt; stop()
 {
 ::GetProcessTimes(::GetCurrentProcess(), &amp;ft_[5], &amp;ft_[4], &amp;ft_[3], &amp;ft_[2]);
 ULARGE_INTEGER u[4];
 for (size_t i = 0; i &lt; 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&amp; os = std::cerr) : timer_(ProcessorTimer()), os_(os) { }
 ~ScopedProcessorTimer()
 {
 std::tuple&lt;double, double&gt; t = timer_.stop();
 os_ &lt;&lt; "user " &lt;&lt; std::get&lt;0&gt;(t) &lt;&lt; "\n";
 os_ &lt;&lt; "kernel " &lt;&lt; std::get&lt;1&gt;(t) &lt;&lt; "\n";
 }
 private:
 ProcessorTimer timer_;
 std::ostream&amp; os_;
}
</code></pre>

For example, one can measure how long it takes a block to execute, by defining a ScopedProcessorTimer at the beginning of that {} block.

blocks|key|991322|text|此代码是进程Cpu使用情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|991323|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+%7C+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("%25.1f",+Usage);
++++++++break;
++++}

++++Sleep(1);+//+QueryPerformanceCounter+Function+Resolution+is+1+microsecond

++++count%2B%2B;
}

CloseHandle(hProcess);|code-block|syntax|javascript|991324|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This Code is Process Cpu Usage 

<pre><code>ULONGLONG LastCycleTime = NULL;
LARGE_INTEGER LastPCounter;
LastPCounter.QuadPart = 0; // LARGE_INTEGER Init

 // cpu get core number
SYSTEM_INFO sysInfo;
GetSystemInfo(&amp;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, &amp;CycleTime))
 nResult = 0;

 ULONG64 cycle = CycleTime - LastCycleTime;

 if (!QueryPerformanceCounter(&amp;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 &gt; 3)
 {
 printf("%.1f", Usage);
 break;
 }

 Sleep(1); // QueryPerformanceCounter Function Resolution is 1 microsecond

 count++;
}

CloseHandle(hProcess);
</code></pre>

Is there any way in C++ to calculate how long does it take to run a given program or routine in CPU time?

I work with Visual Studio 2008 running on Windows 7.

Computing CPU time in C++ on Windows

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在C++中有任何方法来计算在CPU time中运行给定程序或例程需要多长时间吗？我使用运行在Windows 7上的Visual 2008。

问在Windows环境下计算C++中的CPU时间
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Windows环境下计算C++中的CPU时间EN