标签: timing

我有一个实验性的库,我试图测量它的性能.为此,我写了以下内容:

struct timeval begin;
gettimeofday(&begin, NULL);
{
    // Experiment!
}
struct timeval end;
gettimeofday(&end, NULL);

// Print the time it took!
std::cout << "Time: " << 100000 * (end.tv_sec - begin.tv_sec) + (end.tv_usec - begin.tv_usec) << std::endl;

偶尔,我的结果包括负面时间,其中一些是荒谬的.例如:

Time: 226762
Time: 220222
Time: 210883
Time: -688976

这是怎么回事？

我想自动调整我的代码,因此必须测量某些代码段所需的时间

auto t0 = std::chrono::high_resolution_clock::now();
section_of_code_to_be_timed(arguments);
auto dt = std::chrono::duration_cast<std::chrono::nanoseconds>
         (std::chrono::high_resolution_clock::now()-t0).counts();
// ... using dt to tweak auto-tuning parameters

我担心的是,编译器可能会重新安排的呼吁std::chrono::high_resolution_clock::now()和section_of_code_to_be_timed(),因此无效我定时测量.这是一个有效的担心吗？如果是这样,我可以通过声明t0 volatile或其他方式(如何)来阻止它吗？

(我注意到我可以使用RAII成语,类似于std::lock_guard,似乎没有用volatile...)

我有一个scala代码一次运行多个期货.我想分析执行每个时间所花费的时间.例如:

for (i <- 1 to 100) {
   val f = future { runAndTime(doSomething()) }
   f.onComplete {
       case Success(timeTaken) => println(timeTaken)
       case Failure(t) => println(t.getMessage())
    }
}

一个天真的实现runAndTime可能是:

   def runAndTime(func: => Unit) = {
     var time = System.currentTimeMillis()
     func
     System.currentTimeMillis() - time
   }

这个问题runAndTime是当线程没有执行时(例如,如果在func的中间它从cpu中出队并且其他一些线程开始运行)系统仍在花费时间,所以我们没有花时间在该特定线程中但是线程启动和线程结束之间的总时间差.

如何编写一个runAndTime将计算未来在CPU中实际执行的时间？

我正在尝试用C++编写的代码.我有一个内部和外部循环,我想分开时间,但同时.由于某种原因,当我这样做时,其中一个实例返回1.84467e + 13并且总是这个确切的数字.

为什么会这样？

这是一个在我的机器上复制效果的最小工作示例:

#include <iostream>
#include <stdlib.h>
#include <time.h>

using namespace std;

int main()
{
    long int i, j;
    clock_t start, finish, tick, tock;
    double a = 0.0;
    double adding_time, runtime;

    start = clock();
    for(i=0; i<10; i++)
    {
        a=0.0;
        tick =clock();
        for(j=0; j<10000000; j++)
        {
            a+=1;
        }
        tock= clock();
        adding_time = (double)(tick - tock)/CLOCKS_PER_SEC;
        cout << "Computation time:" << adding_time << endl;

    }
    finish = clock();
    runtime = (double)(finish - start)/CLOCKS_PER_SEC;
    cout << "Total computation time:" << runtime …

我正在用 Java 编写一个游戏，并将 FPS 限制为 60。我想出了两种不同的方法来获得相同的结果，但我想知道其中哪一种是更好/更干净的方法。或者也许你有不同的想法。

while(System.nanoTime() - thisFrame < fps_limit);

或者

Thread.sleep(sleepingTime);

我的想法是while 循环对 CPU 的影响大于Thread.sleep，我是对的吗？

在此先感谢您的帮助！

多姆

我想要一个程序，让用户有10秒钟的时间输入密码。如果计时器超过10秒，程序将显示一条消息。我当前的代码是这样的：

 #include <iostream>
 #include <ctime>
 #include <string>

int main(){
std::string password;

int start_s=clock();

int stop_s=clock();
if(stop_s-start_s <= 0){

    std::cout << "TIME RAN OUT!";
}
std::cout << "Enter your password! \n";
std::cout << "Password: ";
std::cin >> password;
std::cout << "\n \n";

if (password == "password123"){

    std::cout << "Correct!";
} else {
    std::cout << "Wrong!";
}

}

这当然是行不通的...但是我不确定下一步该怎么做...有什么想法吗？

如果您需要更多详细信息，请在评论中提问。

编辑：

我刚刚意识到问题出在哪里……花了一个时间戳，然后迅速制作了另一个时间戳。当发现差异时，它低于0 ...

但是我仍然不知道下一步该怎么做...

我要实现的是检测屏幕上出现某些更改的准确时间（主要是使用Google Chrome浏览器）。例如，我使用显示项目$("xelement").show();或使用进行更改$("#xelement").text("sth new");，然后我想查看Performance.now（）到底是什么，当更改以给定的屏幕重新绘制出现在用户的屏幕上时。因此，我完全可以接受任何解决方案-在下文中，我主要指的是requestAnimationFrame（rAF），因为这是应该帮助实现此功能的函数，只是似乎没有实现。见下文。

基本上，正如我所想象的，rAF应该在0-17毫秒内执行其中的所有操作（每当下一帧出现在我的标准60 Hz屏幕上）。此外，timestamp参数应提供此执行时间的值（并且该值基于与performance.now（）相同的DOMHighResTimeStamp度量）。

现在，这是我为此进行的众多测试之一：https : //jsfiddle.net/gasparl/k5nx7zvh/31/

function item_display() {
    var before = performance.now();
    requestAnimationFrame(function(timest){
        var r_start = performance.now();
        var r_ts = timest;
        console.log("before:", before);
        console.log("RAF callback start:", r_start);
        console.log("RAF stamp:", r_ts);
        console.log("before vs. RAF callback start:", r_start - before);
        console.log("before vs. RAF stamp:", r_ts - before);
        console.log("")
    });
}
setInterval(item_display, Math.floor(Math.random() * (1000 - 500 + 1)) + 500);

我在Chrome中看到的是：rAF内的函数总是在大约0到3毫秒内执行（从紧接其前的performance.now（）开始），最奇怪的是，rAF时间戳与我得到的完全不同rAF内的performance.now（）通常比在rAF 之前调用的performance.now（）早大约0-17毫秒（但有时在之后0-1毫秒）。

这是一个典型的例子：

before: 409265.00000001397
RAF callback start: 409266.30000001758
RAF stamp: 409260.832 
before …

我最近安装了 macOS 10.15 Catalina 的开发者测试版，它默认使用 ZSH 而不是 BASH。

我已time作为二进制文件安装在 中/usr/bin/time，并使用它来计时我的一些脚本。然而，ZSH 将此作为内置命令。我的问题是我通常用time -p我喜欢的方式格式化其输出，但这在 ZSH 上似乎不可能。

根据man time：

     -p      The output is formatted as specified by IEEE Std 1003.2-1992 (``POSIX.2'').

Run Code Online (Sandbox Code Playgroud)

这似乎不适用于 ZSH 的内置，并且 ZSH 似乎没有使用我安装的time二进制文件：

巴什

     -p      The output is formatted as specified by IEEE Std 1003.2-1992 (``POSIX.2'').

中兴

is-mbp-bleggiero% which time
time: shell reserved word
is-mbp-bleggiero% time echo hello; echo $?
hello
0
is-mbp-bleggiero% time -p echo hello; echo $? …

我们的客户遇到“请求已发送”值为 2.51 秒的问题。

谷歌说，“请求已发送”是：

发出网络请求所花费的时间。通常只有几分之一毫秒。

发送这么长的请求可能是什么原因？

我从事编程语言分析器工作，正在寻找分辨率优于 100 ns 的 Windows 计时器解决方案。

• QueryPerformanceCounter应该是一个答案，但在 Windows 10 上返回的频率为QueryPerformanceFrequency10 MHz，在 Windows 7 上甚至更低

• GetSystemTimePreciseAsFileTime有 100 ns 刻度/步

• RDTSC分辨率优于1ns，但随频率变化

我的目标分辨率至少为 10 ns。

目前最好的解决方案是什么？

如何QueryPerformanceCounter实施？是否可以轻松拆卸并提高分辨率？

是否可以RDTSC在每次频率变化时直接使用并跟踪/中断？