标签: timing

我在Java应用程序中计算各种事务.在事务开始时,我通过实例化日历然后获取小时,分钟,秒和毫秒来获得开始时间.我完成了事务,实例化了一个新日历并得到了一个新的小时,分​​钟,秒和毫秒.我的理由是,开始时间和结束时间之间的差异是交易的时间.这似乎在大多数时间都有效,但只有一小部分时间,结束时间早于开始时间.为什么会发生这种情况,我该如何预防呢？

有很多关于如何每 N 秒执行某些操作的提示，但我没有发现任何明确说明这些方法中的任何一个是否由于延迟而慢慢地与系统时钟不同步。

我有一个在 Windows 上运行的多线程应用程序。我需要知道，在较高优先级任务和线程允许的几毫秒内，一个特定线程将根据系统时钟“精确地”在凌晨 1 点可靠地执行，然后在凌晨 1 点 + N 秒、凌晨 1 点 + 2N 秒等处执行。 ..并在晚上 11 点、晚上 11 点 + N、晚上 11 点 + 2N 等无限期地继续可靠地执行此操作。是的 - 情况是这样的（无论如何对我来说）每小时有整数个 N 秒周期。

我完全期望线程执行的实际时间为 1am + d1、1am + N + d2、1am + 2N + d3，...其中每个 d(i) 都是一些延迟增量。这也没什么问题，只要增量值的分布保持相当一致且相当低——通常最多几十毫秒，很少有高于该值的峰值。我不介意系统时钟是否与全球时间标准不同步。

我可以使用什么计时结构来实现此目的？是否有什么东西可以保持同步本身，或者我是否必须编写一些东西来随着处理器负载在白天的上升和下降而不断调整自身以保持同步？

我正在尝试测量并行端口上 2 个信号之间的时间差，但首先我要知道我的测量系统（AMD Athlon(tm) 64 X2 双核处理器 5200+ \xc3\x97 2) 在 SUSE 12.1 x64 上。

因此，经过一番阅读后，我决定使用clock_gettime()，首先我使用以下代码获取clock_getres()值：

/*\n * This program prints out the clock resolution.\n */\n#include <stdio.h>\n#include <stdlib.h>\n#include <time.h>\n\nint main( void )\n  {\n    struct timespec res;\n\n    if ( clock_getres( CLOCK_REALTIME, &res) == -1 ) {\n      perror( "clock get resolution" );\n      return EXIT_FAILURE;\n    }\n    printf( "Resolution is %ld nano seconds.\\n",\n          res.tv_nsec);\n    return EXIT_SUCCESS;\n  }\n

结果是：1 纳秒。我很高兴！

但这是我的问题，当我尝试用其他代码检查这一事实时：

#include <iostream>\n#include <time.h>\nusing namespace std;\n\ntimespec diff(timespec start, timespec end);\n\nint …

我试图让我的Arduino 草图在每次执行该loop函数时休眠1秒钟.

循环中涉及的方法可能会改变它们的执行时间,这就是我实现millis的原因.

我正在做以下事情:

unsigned long ejecucionExcedida = 0;

int calcularExceso(int tiempo) {
    if (tiempo>1000) {
        ejecucionExcedida = ejecucionExcedida + (tiempo-1000);
        // TO DO agregar alarma si el exceso se incrementa mucho
        if(ejecucionExcedida > 20000) {
            alertas(9);
        }
        // Listo las alertas :D
        return 1000;
    }
    else {
        if(ejecucionExcedida == 0) {
            return tiempo;
        }
        else {
            if (ejecucionExcedida + tiempo < 1000) {
                ejecucionExcedida = 0;
                return ejecucionExcedida + tiempo;
            }
            else {
                int exceso = …

我的AngularJS指令遇到了绑定时间问题.它的控制器看起来像这样:

controller: function($element, $scope)
{
    $element.find("input").bind("blur", function()
    {
        SendUpdate();
    });

    $scope.Subtract = function()
    {
         Add(-$scope.step);
    }

    $scope.Add = function()
    {
        Add($scope.step);
    }

    function Add(amount)
    {
        $scope.model = parseInt($scope.model) + parseInt(amount);
        console.log("Model: " + $scope.model);
        SendUpdate();
    }

    function SendUpdate()
    {
        $scope.$emit("ProcessUpdate");
    }
}

到目前为止,一切正常,从100开始,加10,打印出Model:110,如预期的那样.但是,当事件由提供模型绑定的变量的父范围处理时,它在事件触发时尚未收到更新的值:

$scope.$on("ProcessUpdate", function()
{
    console.log("MyValue: " + $scope.MyValue);
});

打印出MyValue:100,即使它是$ scope.MyValue,它绑定到指令的模型变量(我也使用"="绑定字符).

事实上,该值正在更新.如果我按下一个打印出相同内容的按钮:

console.log("MyValue: " + $scope.MyValue);

它打印出MyValue的正确值:110.所以这显然是一个时间问题.看起来事情按此顺序发生:

1. 更新指令的$ scope.model.
2. 点燃活动.
3. 处理活动.
4. 更新父级的$ scope.model.

我需要的是4在1之后立即发生,因为当事件被触发时我需要父范围是最新的.

我应该采用不同的方式吗？我不想通过事件传递更新的值,因为任何数量的这些指令都可以触发,并且它们需要全部处理父范围.我不想弄清楚改变了什么,并相应地注入它.我只想在父作用域收到指令的新值后触发事件.

谢谢.

当我想编写像此平台上不存在的GetTicketCount64这样的函数时,Windows XP下会出现问题.这是我的测试代码:

uint64_t GetTickCountEx()
{
#if _WIN32_WINNT > _WIN32_WINNT_WINXP
    return GetTickCount64();
#else
    // http://msdn.microsoft.com/en-us/library/windows/desktop/dn553408.aspx
    LARGE_INTEGER Frequency = {};
    LARGE_INTEGER Counter = {};
    BOOST_VERIFY(QueryPerformanceFrequency(&Frequency));
    BOOST_VERIFY(QueryPerformanceCounter(&Counter));

    return 1000 * Counter.QuadPart / Frequency.QuadPart;
#endif
}

for (int i = 0; ++i < 1000; Sleep(30000))
{
    const auto utc = time(nullptr); // System time
    const auto xp = GetTickCount(); // API of Windows XP SP3
    const auto ex = GetTickCountEx(); // Performance counter
    const auto diff = ex - xp;
    printf("%lld %I32u %I64u %I64u …

这些方法是衡量脚本的可靠方法吗？

$time = ($_SERVER['REQUEST_TIME_FLOAT'] - $_SERVER['REQUEST_TIME']);

要么

$time = (microtime(true) - $_SERVER['REQUEST_TIME_FLOAT']);

应该使用哪一个？

每个有什么区别？

他们返回非常不同的测量结果。

我正在尝试创建一个Android应用程序,每秒记录一个跑步者的位置.但是,我发现它完成后需要稍微超过一秒钟.

这是我的代码:

Runnable run = new Runnable() {
    @Override
    public void run() {
        Long start = SystemClock.elapsedRealtime();
        if (getIfRunning() == true) {
            try {
                if (location2 != null) {
                    Float distanceFromLast = totalDistance(location2);
                    addToDistance(distanceFromLast);
                }
                getCoords();
                mMap.clear();
                markOldCoords();
                writeCoords();
                setCount();
                updateScreen();
            } catch (Exception e) {
            }
        }
        Long time = SystemClock.elapsedRealtime() - start;
        handler.postDelayed(this, 1000 - time);
    }
};
handler.post(run);

我有一个计算总和的函数，并根据总和的结果执行某些任务或给出警告消息。我需要在粒子轨迹模拟中运行此功能数百万次（它计算时间和位置相关的力），并注意到我的代码非常慢。

这是我的MWE：

#include <stdio.h>
#include <math.h>

int foo()
{
    double sum =0;
    double dummy_sum = 0;

    for (size_t i=0; i<40; i++)
    {
        sum+=1e-2; 
        dummy_sum += 1e-2;     
    }

    if (sum>5.) // normally this should not happen
    {
        printf("warning message!\n");
        return(-1);
    }
    else if(sum >0)
    {
       // normal behavior
    }

    return(0);
}

int main()
{
   int fooint;

   for(size_t i=0; i<5e9; i++)
   {
       fooint = foo();
       if(fooint!=0)
       {
           return(fooint);
       }
   }
   return 0;
}

我gcc -Ofast -std=c99 test.c -o test.exe使用gcc版本4.8.5进行编译。

为了找到一种优化我的功能的方法，我运行了 …

我编写了一个计时函数，记录了函数的运行时间，并计算了多次运行的均值和标准差。我惊讶地发现即使是看似简单的任务（例如加两个双打）也有很高的标准偏差。我分析了python中的数据（请参见图）。C ++输出是19.6171 ns +/- 21.9653ns (82799807 runs)使用以下命令编译的：

gcc version 8.3.0 (Debian 8.3.0-19)
/usr/bin/c++ -O3 -DNDEBUG -std=gnu++17

整个测试是在我的个人计算机上完成的，该计算机不是空闲的而是运行DE，浏览器，IDE和其他进程。测试期间有可用的RAM。我的带有HT的双核CPU空闲率低于10％。
在这种情况下，是否会出现从20 ns的平均值到50 µs的峰值？

运行时间图
这是的内容std::vector<double> run_times。我没有看到任何图案。

运行时间的直方图
注意log y轴（此bin中的样本数）。

定时

gcc version 8.3.0 (Debian 8.3.0-19)
/usr/bin/c++ -O3 -DNDEBUG -std=gnu++17

计时文件

#include <cstdint>
#include <ostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <chrono>
#include <numeric>
#include <fstream>


struct TimingResults{
    // all time results are in nanoseconds
    double mean;
    double standard_deviation;
    uint64_t number_of_runs;
};


std::ostream& operator<<(std::ostream& os, const TimingResults& results);


template …