blocks|key|2067277|text|你的问题是没有意义的:你不会得到重复的测量，即使在毫秒的时间报告。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2067278|添加更多的数字只会增加噪声。你也可以从/dev/random中提取额外的数字。|offset|length|style|CODE|2067279|entityMap^0|0|J|B|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Your question is meaningless: you will not get repeated measurements even within milliseconds time does report.

Adding more digits will just add noise. You might as well pull the extra digits from <code>/dev/random</code>.

blocks|key|2072809|text|看看current_kernel_time()对您的需求是否有帮助。我用过它，发现它很有用，因为它提供了纳秒级别的粒度。更多细节请访问here。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2072810|entityMap|0|LINK|mutability|MUTABLE|url|http://mycottonsilk.wordpress.com/2011/01/11/benchmarking-android-driver/^0|1V|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

See if current_kernel_time() is helpful for you in your requirement.
I have used it and found useful as it gives granularity to nanosecond level..
More details are <a href="http://mycottonsilk.wordpress.com/2011/01/11/benchmarking-android-driver/" rel="nofollow">here</a>.

blocks|key|2067305|text|我确实同意Employed+Russian's+answer的观点。对于这样的测量，想要微秒级的精度是没有多大意义的。所以你得到的任何额外的数字都是没有意义的(本质上是随机的)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2067306|如果您有要测量的应用程序源代码，则可以使用clock或clock_gettime函数，但不要期望超过12微秒的精确度。还有RDTSC机器指令。|2067307|阅读linux+clock+howto。|2067308|不要忘记，从应用程序的角度来看，执行的时间是不确定的和不可重现的(考虑上下文切换、缓存未命中、中断等)。在随机时间发生)。|2067309|如果你想测量整个程序的性能，让它至少运行几秒钟，并测量几次(例如8次)时间，然后取平均值(可能会去掉最佳和最差的时间)。|2067310|如果你想测量特定功能的计时，学习如何profile你的应用程序(gprof，oprofile等)另请参阅this+question|style|CODE|2067311|别忘了阅读time(7)|2067312|请注意，在当前(笔记本电脑、台式机、服务器)具有复杂CPU+caches、TLB和branch+predictors的out-of-order+pipelined+superscalar处理器上，一些微循环或机器指令序列的执行时间是不可重现的(每次运行纳秒计数都会有所不同)。操作系统还增加了随机性(scheduling、context+switches、interrupts、page+cache、copy-on-write、demand-paging+...)因此，用超过1毫秒的-or来测量某些命令的执行是没有任何意义的，如果幸运的话可能是100µs+-精度。您应该对您的命令进行多次基准测试。|2067313|要获得重要的衡量标准，您应该将经过基准测试的应用程序更改为在几秒钟内运行(可能在main中添加一些循环，或者使用更大的数据集运行)，并重复执行经过基准测试的命令12次。取平均值(或最差，或最好，取决于您追求的是什么)的度量。|2067314|如果系统time(1)不够，您可以制作自己的测量工具；另请参阅getrusage(2)；我对您获得更准确的测量结果持怀疑态度。|2067315|顺便说一下，在我的i3770K最近的GNU/Linux+(4.2内核，Debian/Sid/x86-64)台式计算机上，像time(2)或clock_gettime(2)这样的“系统”-calls运行大约3或4纳秒(多亏了vdso(7)，它避免了真正的syscall的负担……)所以你可以经常在你的程序中使用它们。|2067316|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/8586421/841108|1|http://linux.die.net/man/3/clock|2|http://linux.die.net/man/3/clock_gettime|3|http://en.wikipedia.org/wiki/RDTSC|4|http://tldp.org/HOWTO/Clock.html#toc2|5|http://www.pixelbeat.org/programming/profiling/|6|https://stackoverflow.com/questions/182554/microsecond-accurate-or-better-process-timing-in-linux|7|http://man7.org/linux/man-pages/man7/time.7.html|8|https://en.wikipedia.org/wiki/CPU_cache|9|https://en.wikipedia.org/wiki/Translation_lookaside_buffer|10|https://en.wikipedia.org/wiki/Branch_predictor|11|https://en.wikipedia.org/wiki/Out-of-order_execution|12|https://en.wikipedia.org/wiki/Instruction_pipeline|13|https://en.wikipedia.org/wiki/Superscalar_processor|14|https://en.wikipedia.org/wiki/Scheduling_%2528computing%2529|15|https://en.wikipedia.org/wiki/Context_switch|16|https://en.wikipedia.org/wiki/Interrupt|17|https://en.wikipedia.org/wiki/Page_cache|18|https://en.wikipedia.org/wiki/Copy-on-write|19|https://en.wikipedia.org/wiki/Demand_paging|20|http://man7.org/linux/man-pages/man1/time.1.html|21|http://man7.org/linux/man-pages/man2/getrusage.2.html|22|http://man7.org/linux/man-pages/man2/time.2.html|23|http://man7.org/linux/man-pages/man2/clock_gettime.2.html|24|http://man7.org/linux/man-pages/man7/vdso.7.html|25|https://en.wikipedia.org/wiki/System_call^0|5|P|0|0|L|5|1|R|D|2|1P|5|3|0|2|H|4|0|0|0|W|5|12|8|I|7|5|1G|D|6|0|5|7|7|0|Q|A|8|11|3|9|15|H|A|1N|C|B|20|9|C|2A|B|D|46|A|E|4H|G|F|4Y|A|G|59|A|H|5K|D|I|5Y|D|J|0|14|4|0|4|7|K|V|C|L|0|1P|7|M|1X|G|N|33|7|O|3I|7|P|0^^$0|@$1|2|3|4|5|6|7|2L|8|@]|9|@$A|2M|B|2N|1|2O]]|C|$]]|$1|D|3|E|5|6|7|2P|8|@]|9|@$A|2Q|B|2R|1|2S]|$A|2T|B|2U|1|2V]|$A|2W|B|2X|1|2Y]]|C|$]]|$1|F|3|G|5|6|7|2Z|8|@]|9|@$A|30|B|31|1|32]]|C|$]]|$1|H|3|I|5|6|7|33|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|34|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|35|8|@$A|36|B|37|N|O]|$A|38|B|39|N|O]]|9|@$A|3A|B|3B|1|3C]|$A|3D|B|3E|1|3F]]|C|$]]|$1|P|3|Q|5|6|7|3G|8|@]|9|@$A|3H|B|3I|1|3J]]|C|$]]|$1|R|3|S|5|6|7|3K|8|@]|9|@$A|3L|B|3M|1|3N]|$A|3O|B|3P|1|3Q]|$A|3R|B|3S|1|3T]|$A|3U|B|3V|1|3W]|$A|3X|B|3Y|1|3Z]|$A|40|B|41|1|42]|$A|43|B|44|1|45]|$A|46|B|47|1|48]|$A|49|B|4A|1|4B]|$A|4C|B|4D|1|4E]|$A|4F|B|4G|1|4H]|$A|4I|B|4J|1|4K]]|C|$]]|$1|T|3|U|5|6|7|4L|8|@$A|4M|B|4N|N|O]]|9|@]|C|$]]|$1|V|3|W|5|6|7|4O|8|@]|9|@$A|4P|B|4Q|1|4R]|$A|4S|B|4T|1|4U]]|C|$]]|$1|X|3|Y|5|6|7|4V|8|@]|9|@$A|4W|B|4X|1|4Y]|$A|4Z|B|50|1|51]|$A|52|B|53|1|54]|$A|55|B|56|1|57]]|C|$]]|$1|Z|3|-4|5|6|7|58|8|@]|9|@]|C|$]]]|10|$11|$5|12|13|14|C|$15|16]]|17|$5|12|13|14|C|$15|18]]|19|$5|12|13|14|C|$15|1A]]|1B|$5|12|13|14|C|$15|1C]]|1D|$5|12|13|14|C|$15|1E]]|1F|$5|12|13|14|C|$15|1G]]|1H|$5|12|13|14|C|$15|1I]]|1J|$5|12|13|14|C|$15|1K]]|1L|$5|12|13|14|C|$15|1M]]|1N|$5|12|13|14|C|$15|1O]]|1P|$5|12|13|14|C|$15|1Q]]|1R|$5|12|13|14|C|$15|1S]]|1T|$5|12|13|14|C|$15|1U]]|1V|$5|12|13|14|C|$15|1W]]|1X|$5|12|13|14|C|$15|1Y]]|1Z|$5|12|13|14|C|$15|20]]|21|$5|12|13|14|C|$15|22]]|23|$5|12|13|14|C|$15|24]]|25|$5|12|13|14|C|$15|26]]|27|$5|12|13|14|C|$15|28]]|29|$5|12|13|14|C|$15|2A]]|2B|$5|12|13|14|C|$15|2C]]|2D|$5|12|13|14|C|$15|2E]]|2F|$5|12|13|14|C|$15|2G]]|2H|$5|12|13|14|C|$15|2I]]|2J|$5|12|13|14|C|$15|2K]]]]

I do agree with <a href="https://stackoverflow.com/a/8586421/841108">Employed Russian's answer</a>. It does not have much sense to want microsecond accuracy for such measures. So any additional digit you've got is meaningless (and essentially random). 

If you have the source code of the application to measure, you might use the <a href="http://linux.die.net/man/3/clock" rel="nofollow noreferrer">clock</a> or <a href="http://linux.die.net/man/3/clock_gettime" rel="nofollow noreferrer">clock_gettime</a> functions, but don't hope for better than a dozen of microseconds of accuracy. There is also the <a href="http://en.wikipedia.org/wiki/RDTSC" rel="nofollow noreferrer">RDTSC</a> machine instruction.

Read the <a href="http://tldp.org/HOWTO/Clock.html#toc2" rel="nofollow noreferrer">linux clock howto</a>.

And don't forget that the timing of execution, is from an application point of view, non deterministic and non reproductible (think about context switches, cache misses, interrupts, etc... happenning at random time).

If you want to measure the performance of a whole program, make it run for at least several seconds, and measure the time several (e.g. 8) times, and take the average (perhaps dropping the best &amp; worst timing).

If you want to measure timing for particular functions, learn how to <a href="http://www.pixelbeat.org/programming/profiling/" rel="nofollow noreferrer">profile</a> your application (<code>gprof</code>, <code>oprofile</code> etc etc...)
See also <a href="https://stackoverflow.com/questions/182554/microsecond-accurate-or-better-process-timing-in-linux">this question</a>

Don't forget to read <a href="http://man7.org/linux/man-pages/man7/time.7.html" rel="nofollow noreferrer">time(7)</a>

Be aware that on current (laptop, desktop, server) <a href="https://en.wikipedia.org/wiki/Out-of-order_execution" rel="nofollow noreferrer">out-of-order</a> <a href="https://en.wikipedia.org/wiki/Instruction_pipeline" rel="nofollow noreferrer">pipelined</a> <a href="https://en.wikipedia.org/wiki/Superscalar_processor" rel="nofollow noreferrer">superscalar</a> processors with complex <a href="https://en.wikipedia.org/wiki/CPU_cache" rel="nofollow noreferrer">CPU caches</a> and <a href="https://en.wikipedia.org/wiki/Translation_lookaside_buffer" rel="nofollow noreferrer">TLB</a> and <a href="https://en.wikipedia.org/wiki/Branch_predictor" rel="nofollow noreferrer">branch predictors</a>, the execution time of some tiny loop or sequence of machine instruction is not reproducible (the nanosecond count will vary from one run to the next). And the OS also adds randomness (<a href="https://en.wikipedia.org/wiki/Scheduling_%28computing%29" rel="nofollow noreferrer">scheduling</a>, <a href="https://en.wikipedia.org/wiki/Context_switch" rel="nofollow noreferrer">context switches</a>, <a href="https://en.wikipedia.org/wiki/Interrupt" rel="nofollow noreferrer">interrupts</a>, <a href="https://en.wikipedia.org/wiki/Page_cache" rel="nofollow noreferrer">page cache</a>, <a href="https://en.wikipedia.org/wiki/Copy-on-write" rel="nofollow noreferrer">copy-on-write</a>, <a href="https://en.wikipedia.org/wiki/Demand_paging" rel="nofollow noreferrer">demand-paging</a> ...) so it does not make any sense to measure the execution of some command with more than one millisecond -or perhaps 100µs if you are lucky- of precision. You should benchmark your command several times.

To get significant measures, you should change the benchmarked application to run in more than a few seconds (perhaps adding some loop in <code>main</code>, or run with a bigger data set...), and repeat the benchmarked command a dozen times. That take the mean (or the worst, or the best, depending what you are after) of the measures.

If the system <a href="http://man7.org/linux/man-pages/man1/time.1.html" rel="nofollow noreferrer">time(1)</a> is not enough, you might make your own measurement facility; see also <a href="http://man7.org/linux/man-pages/man2/getrusage.2.html" rel="nofollow noreferrer">getrusage(2)</a>; I'm skeptical about you getting more accurate measures. 

BTW on my i3770K recent GNU/Linux (4.2 kernel, Debian/Sid/x86-64) desktop computer, "system"-calls like <a href="http://man7.org/linux/man-pages/man2/time.2.html" rel="nofollow noreferrer">time(2)</a> or <a href="http://man7.org/linux/man-pages/man2/clock_gettime.2.html" rel="nofollow noreferrer">clock_gettime(2)</a> runs in about 3 or 4 nanoseconds (thanks to <a href="http://man7.org/linux/man-pages/man7/vdso.7.html" rel="nofollow noreferrer">vdso(7)</a> which avoid the burden of a real <a href="https://en.wikipedia.org/wiki/System_call" rel="nofollow noreferrer">syscall</a>...) so you could use them inside your program quite often.

blocks|key|2067321|text|使用gettimeofday+-提供微秒精度|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2067322|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Use gettimeofday -- gives microsecond accuracy

I wish to know the amount of time taken for execution of a program under linux in microseconds (or better accuracy). Currently I am using the <code>time</code> command, but it gives me at the max milliseconds accuracy. Is there some way to tweak the <code>time</code> command to give better accuracy or is there some other command for the same?

linux time command microseconds or better accuracy

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想知道在linux下执行一个程序所需的时间(以微秒为单位)(或更准确)。目前我使用的是time命令，但它给我的最大精度是毫秒。有没有办法调整time命令以提供更好的准确性，或者是否有其他命令可以做到这一点？

问linux时间命令微秒或更高的精度
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问linux时间命令微秒或更高的精度EN