精华内容
下载资源
问答
  • Windows精度时钟

    2021-08-02 11:24:00
    Windows精度时钟 精度:<1us 微秒 1.1Function 1统计一段代码的CPU时间 LARGE_INTEGER freq; LARGE_INTEGER beginTime; LARGE_INTEGER endTime; QueryPerformanceFrequency(&freq); ...

    封装几个代码,方便以后查询和使用

    Windows高精度时钟 精度:<1us 微秒

    1.1Function 1统计一段代码的CPU时间

    	LARGE_INTEGER freq;
    	LARGE_INTEGER beginTime;
    	LARGE_INTEGER endTime;
    
    	QueryPerformanceFrequency(&freq);
    	QueryPerformanceCounter(&beginTime);
    	//测试代码块时间 Begin
    	
        //测试代码块时间 End
        QueryPerformanceCounter(&endTime);
        double second = (double)(endTime.QuadPart - beginTime.QuadPart) / (double)freq.QuadPart;
    

    1.2更方便的宏定义

    #define COUNT_BEGIN  LARGE_INTEGER freq,beginTime,LARGE_INTEGER endTime;\
    QueryPerformanceFrequency(&freq);\
    QueryPerformanceCounter(&beginTime);
    
    #define COUNT_END QueryPerformanceCounter(&endTime);
    #define SHOW_TIME_COUNT printf("%llf second passed\n",(double)(endTime.QuadPart - beginTime.QuadPart) / (double)freq.QuadPart;);
    

    2.1Function 2高精度Sleep()

    LARGE_INTEGER freq;  
    LARGE_INTEGER start, end;  
    QueryPerformanceFrequency(&freq);  
    unsigned int s = 0; //此处填入延时的秒数
    unsigned int ms = 0; //此处填入延时的毫秒数
    unsigned int us = 100000; //此处填入需要延时的微秒数  
    us += ms*1000+s*1000*1000;
    LONGLONG count = (us * freq.QuadPart) / (1000 * 1000);  
    QueryPerformanceCounter(&start);  
    count = count + startQuadPart ;  
    do  
    {  
       QueryPerformanceCounter(&end);  
    }while(end.QuadPart< count);  
    

    2.2 更方便的宏定义

    #define SLEEP_S(S)
    LARGE_INTEGER freq;  \
    LARGE_INTEGER start, end;  \
    QueryPerformanceFrequency(&freq);  \
    LONGLONG count = (S*1000*1000 * freq.QuadPart) / (1000 * 1000);  \
    QueryPerformanceCounter(&start);  \
    count = count + startQuadPart ;  \
    do  \
    {  \
       QueryPerformanceCounter(&end);  \
    }while(end.QuadPart< count);  
    
    #define SLEEP_MS(MS)
    LARGE_INTEGER freq;  \
    LARGE_INTEGER start, end;  \
    QueryPerformanceFrequency(&freq);  \
    LONGLONG count = (S*1000 * freq.QuadPart) / (1000 * 1000);  \
    QueryPerformanceCounter(&start);  \
    count = count + startQuadPart ;  \
    do  \
    {  \
       QueryPerformanceCounter(&end);  \
    }while(end.QuadPart< count);  
    
    #define SLEEP_US(US)
    LARGE_INTEGER freq;  \
    LARGE_INTEGER start, end;  \
    QueryPerformanceFrequency(&freq);  \
    LONGLONG count = (US * freq.QuadPart) / (1000 * 1000);  \
    QueryPerformanceCounter(&start);  \
    count = count + startQuadPart ;  \
    do  \
    {  \
       QueryPerformanceCounter(&end);  \
    }while(end.QuadPart< count);  
    
    展开全文
  • Windows系统精度计时器 原理:联合使用QueryPerformanceFrequency和QueryPerformanceCounter获取高精度时间; 平台:vc++6/vc++2008
  • Windows时钟函数精度测试

    千次阅读 2005-01-04 20:09:00
    Windows有个多媒体时钟函数:timeGetTimeThe timeGetTime function retrieves the system time, in milliseconds. The system time is the time elapsed since Windows was started.DWORD timeGetTime(VOID); 单位为...

    Windows有个多媒体时钟函数:

    timeGetTime

    The timeGetTime function retrieves the system time, in milliseconds. The system time is the time elapsed since Windows was started.

    DWORD timeGetTime(VOID);

     

    单位为毫秒,精度比较高,使用时需要包含 "mmsystem.h"文件,并在工程中加入"winmm.lib" 文件。

     

    另外Windows还提供了QueryPerformanceCounter函数可以取得高精度的当前的时钟周期数,因此可以用此函数写出比timeGetTime精度更高的记时器函数。

     

    // 取得CPU每秒时间内的时钟周期数

    __inline LONGLONG GetSecondCount()

    {

           static LARGE_INTEGER liCounter = {0};

           if (0 == liCounter.QuadPart)

                  QueryPerformanceFrequency(&liCounter);

           return liCounter.QuadPart;

    }

     

    // 返回当前时间 单位:毫秒

    __inline DWORD highGetTime()

    {

           LARGE_INTEGER liCurrent = {0};

           QueryPerformanceCounter(&liCurrent);

           return (DWORD)(liCurrent.QuadPart * 1000 / GetSecondCount());

    }

     

     

    为了测试各时钟函数的精度究竟如何,笔者写了如下测试程序:

     

      GetTickCount()

     

    #include "conio.h"

    #include "windows.h"

     

    void main()

    {

           Sleep(1000);

          

           DWORD old_time = GetTickCount();

           for (int i = 0; i < 10; ++i)

           {

                  int n = 0;

                  for (int j = 0; j < 500000; ++j)

                  {

                         if (j % 10 == 0)

                                n--;

                         else

                                n++;

                  }

                  DWORD time = GetTickCount();

                  DWORD dt = time - old_time;

                  old_time = time;

                  printf("n = %d  耗时:%d/n", n, dt);

           }

          

           _getch();

    }

     

    输出结果:

    n = 400000  耗时:0

    n = 400000  耗时:16

    n = 400000  耗时:0

    n = 400000  耗时:15

    n = 400000  耗时:16

    n = 400000  耗时:0

    n = 400000  耗时:16

    n = 400000  耗时:0

    n = 400000  耗时:15

    n = 400000  耗时:16

     

     

     

      timeGetTime ()

     

    #include "conio.h"

    #include "windows.h"

    #include "mmsystem.h"

    #pragma comment(lib, "winmm.lib")

     

    void main()

    {

           Sleep(1000);

          

           DWORD old_time = timeGetTime();

           for (int i = 0; i < 10; ++i)

           {

                  int n = 0;

                  for (int j = 0; j < 500000; ++j)

                  {

                         if (j % 10 == 0)

                                n--;

                         else

                                n++;

                  }

                  DWORD time = timeGetTime();

                  DWORD dt = time - old_time;

                  old_time = time;

                  printf("n = %d  耗时:%d/n", n, dt);

           }

          

           _getch();

    }

     

    输出结果:

    n = 400000  耗时:0

    n = 400000  耗时:15

    n = 400000  耗时:16

    n = 400000  耗时:15

    n = 400000  耗时:16

    n = 400000  耗时:16

    n = 400000  耗时:15

    n = 400000  耗时:0

    n = 400000  耗时:16

    n = 400000  耗时:16

     

     

      highGetTime ()

     

    #include "conio.h"

    #include "windows.h"

     

    __inline LONGLONG GetSecondCount()

    {

           static LARGE_INTEGER liCounter = {0};

           if (0 == liCounter.QuadPart)

                  QueryPerformanceFrequency(&liCounter);

           return liCounter.QuadPart;

    }

     

    // 返回当前时间 单位:毫秒

    __inline DWORD highGetTime()

    {

     

           LARGE_INTEGER liCurrent = {0};

           QueryPerformanceCounter(&liCurrent);

           return (DWORD)(liCurrent.QuadPart * 1000 / GetSecondCount());

    }

     

    void main()

    {

           Sleep(1000);

          

           DWORD old_time = highGetTime();

           for (int i = 0; i < 10; ++i)

           {

                  int n = 0;

                  for (int j = 0; j < 500000; ++j)

                  {

                         if (j % 10 == 0)

                                n--;

                         else

                                n++;

                  }

                  DWORD time = highGetTime();

                  DWORD dt = time - old_time;

                  old_time = time;

                  printf("n = %d  耗时:%d/n", n, dt);

           }

          

           _getch();

    }

     

    输出结果:

    n = 400000  耗时:10

    n = 400000  耗时:9

    n = 400000  耗时:10

    n = 400000  耗时:10

    n = 400000  耗时:9

    n = 400000  耗时:10

    n = 400000  耗时:10

    n = 400000  耗时:10

    n = 400000  耗时:10

    n = 400000  耗时:10

     

     

    以上三个测试程序均完成同样的工作10次,那么每次耗费的时间应该相差不大才对,根据程序输出的结果,我们可以看出:timeGetTime GetTickCount精度高,highGetTime精度最高。

    展开全文
  • 浏览器的时钟精度

    2014-07-28 17:08:26
    时钟精度是指时钟更新的频率,大部分情况下,网络浏览器使用诸如setTimeout() 和setInterval()的函数调用系统默认时钟,这意味着浏览器部署代码时只能和系统时钟同步。Internet Explorer的日期对象(Date Object)也...

    原文地址:http://www.ituring.com.cn/article/1828?q=settimeout

    Nicholas C. Zakas发表于2011年12月14日上午7:00

    标签:JavaScript,性能,时钟

    时钟精度是指时钟更新的频率,大部分情况下,网络浏览器使用诸如setTimeout() 和setInterval()的函数调用系统默认时钟,这意味着浏览器部署代码时只能和系统时钟同步。Internet Explorer的日期对象(Date Object)也把系统时钟作为种子值,因此日期对象的差异也就只能用时钟精度来衡量。

    历史简介

    Windows机器默认时钟精度为10-15.6毫秒(大部分情况是15.6毫秒),亦即浏览器采用的系统时钟遵循该时钟精度。当然,以目前CPU处理器速度而言,10-15.6毫秒是一个极限。IE浏览器到IE 8都还独占系统时钟,以至于John Resig撰文阐释时间精度如何影响基准程序1也就不足为奇了。但是,OS X下浏览器时钟较Windows下更为精确。

    直到最近,Window下其他浏览器也使用系统时钟,遵循15.6毫秒的时钟精度,这在Firefox、Safari和Opera均得到体现。Chrome应该是首个采用高精度时钟的Windows浏览器2,他们的实验有一些有趣的结论。

    他们最初的想法是让Chrome使用亚毫秒级精度的时钟,但后来放弃了,并换用1毫秒精度。他们决定采用Windows多媒体时钟API,这能够给定达到1毫秒精度的时钟并用以此替代系统时钟。这和Flash和Quicktime等插件使用的时钟相同。

    Chrome 1.0 beta版采用了1毫秒的时钟精度。这看起来不错,但运行时却收到许多bug报告。1毫秒精度的时钟导致CPU高速运转,当CPU运转时,因不能进入睡眠模式(低耗电)而耗电增加3。这使得Chrome将时钟精度延长到4毫秒。

    这4毫秒的延迟在HTML5中作为时钟部分被记录下来4,HTML5认为setTimeout()的最小精度应为4毫秒。而setInterval ()的最小精度被设定为10毫秒。

    目前的时钟精度

    和Chrome一样,IE9、Firefox 5、Safari 5.1和 Opera 11也都跟着采用了4毫秒的时钟精度。此前,Firefox 4和Safari 5及它们的早期版本采用的是10毫秒的时钟精度(显然,这是在WebKit内核固定的)。iOS 5上Safari移动浏览器也采用4毫秒精度,Kindle Fire上的Silk采用10毫秒精度,这暗示了它可能是在老版本的WebKit平台上开发的。然而,正因为目前浏览器普遍采用4毫秒精度,并不意味着那就是你能获得的精度。

    大部分浏览器基于不同情况都会采取一些调节措施(使得时钟精度延迟),目的在于在合适时候保护电池——理论上讲,这些时间用户既不会察觉出异样也愿意为延长笔记本或移动设备电池寿命(做些让步)。下面这些情况时钟精度会做相应调整:

    • 当笔记本使用电池电源时,Chrome 和 IE 9+自动回调到系统时钟,而换上交流电源时又调整到4毫秒精度。
    • Firefox 5+、 Chrome 11+和IE 10+对未激活的tab页面使用1000毫秒的时钟精度5
    • 使用其他应用程序时,iOS5上的Safari移动浏览器和Kindle Fire上的Silk完全冻结时钟,直至再次使用浏览器时才解冻。

    浏览器往往不断调节适应时钟精度以适应电池供电设备的耗电。HTML5特地为浏览器开发人员预留了完成该调整的空间。

    结论

    随着浏览器近年来的发展,时钟精度一直在悄悄的改进。时钟精度并非经常讨论的热门话题,但当使用setTimeout() 和 setInterval()时,需要对其功能加以深入理解。我们越来越接近对浏览器的每毫秒的监控了,一旦有人解决了高精度时钟运行时的CPU崩溃问题,我们将很可能看到时钟精度的再次提高。但在这之前,记住4毫秒的限值,且牢记我们往往达不到这种状态。

    2011年12月15日更新:更新了关于日期对象的相关信息。

    参考文献

    1. Accuracy of JavaScript Time by John Resig

      JavaScript时间精度 John Resig

    2. Chrome: Cranking up the clock by Mike Belshe

      Chrome:启动时钟管理 Mike Belshe

    3. CPU Power Utilization on Intel® Architectures by Karthik Krishnan

      Intel®架构下的CPU电力使用 Karthik Krishnan

    4. Timers in HTML5

      HTML5下的时间设置

    5. Clamp setTimeout/setInterval to something higher than 10ms in inactive tabs

      对未激活标签页(tabs)中高于10毫秒精度对象强制设定时钟(setTimeout/setInterval)

    6. Timer Resolution Test by Ryan Grove

      时钟精度测试 Ryan Grove

    声明:本文所有观点和意见来自Nicholas C. Zakas,无论如何,请勿关联我的雇主、同事、Wrox出版社、O'Reilly出版社或者其它任何人。我仅表达自己的观点,而非为他人。

    原文标题:Timer resolution in browsers

    原文地址:http://www.nczonline.net/blog/2011/12/14/timer-resolution-in-browsers

    展开全文
  • 给出一个基于Windows操作系统的计算机网络同步时钟实现方案,该方案可以有效提高计算机时钟同步精度,在LAN中时钟同步精度达250 μs。同时采用了校正时钟频率误差算法,校正后的时钟长期计时误差能达到10天少于1 s。
  • 针对windows系统的高精度定时器

    千次阅读 2017-05-21 13:09:11
    然而,这种需求虽然存在,但是由于windows系统并不是一个实时操作系统,实现这种精度的定时器,并不是一件容易的事情。 Windows 不是实时操作系统,所以任何方案都无法绝对保证定时器的精度,只是能尽量减少误差。...

    背景

      在实际工作过程中,比如与硬件交互、媒体视频播放、性能分析以及多线程任务同步时,可能需要在windows平台下实现ms级别精度的定时器。然而,这种需求虽然存在,但是由于windows系统并不是一个实时操作系统,实现这种精度的定时器,并不是一件容易的事情。

    Windows 不是实时操作系统,所以任何方案都无法绝对保证定时器的精度,只是能尽量减少误差。所以,系统的稳定性不能完全依赖于定时器,必须考虑失去同步时的处理。

    等待策略

      要想实现高精度定时器,必须需要等待和计时两种基础功能,等待用来跳过一定时间间隔,计时可以进行时间检查,用以调整等待事件。
    等待策略实际就是两种:
    1. 自旋等待:让CPU空转消耗时间,占用大量CPU时间,但是时间高度可控。
    2. 阻塞等待:线程进入阻塞状态,让出CPU时间片,在等待一定时间后再由操作系统调度回到运行状态。阻塞时不占用CPU,然而需要操作系统调度,时间难以控制。
      可以看到二者各有优劣,应该按照不同需求进行不同的实现。
    所以难点在于等待策略,下面先分析简单的自旋等待。

    自旋等待

    伪代码如下:

    
    等待开始时间=当前计时
    while((当前计时-等待开始时间)<需要等待的时间)    
    {
        自旋;
    }

    阻塞等待

      阻塞等待会把控制权交给操作系统,这样就必须确保操作系统能够及时的将定时器线程调度回运行状态。默认情况下,Windows的系统定时器精度为15.625ms,也就是说时间切片是这个尺寸。如果线程阻塞,出让其时间片进行等待,再被调度运行的时间至少是一个切片15.625ms。那么必须减少时间切片的长度,才能实现更高的精度。
     一般实现阻塞等待都用的是thread库的sleep函数,实测sleep函数的精度不高,估计也就ms级的,也就是可能会产生+1ms的误差。
     sleep会出让剩余的cpu时间片给优先级相同的线程,而yield则是出让剩余的cpu时间片给运行在同一核心上的线程。在出让的时间片结束后,其会被重新调度。一般情况下,整个过程可以在1ms内完成。

    另外,sleep或者yield在CPU高负载情况下非常不稳定,实测可能会阻塞高达几ms的时间,所以可能会产生更多的误差,因此误差修正最好采用自旋方式实现。

    定时器实现

      需要注意的是,无论自选还是阻塞,显然定时器都应该运行在独立的线程,不能干扰使用方线程工作。而对于高精度定时器而言,触发事件以执行任务的线程一般都在定时器线程内,而不是再使用独立的任务线程。
      这是因为在高精度定时场景下,任何任务的时间开销很可能大于定时器的时间间隔,如果默认就在其他线程执行任务,可能导致占用大量线程。所以应该把控制权交给用户,让用户在需要的时候自行调度任务执行的线程。

    触发模式

      由于在定时器线程执行任务,所以定时器的触发就产生了三种模式。以下是三种模式的伪代码:

    1. 固定时间框架
      比如间隔10ms,任务 7-12ms,则会按照等待 10ms 、任务 7ms、等待 3ms、任务 12ms(超时 2ms 失去同步)、任务 7ms、等待 1ms(回到同步)、任务 7ms、等待 3ms、… 进行。就是尽量按照设定好的时间框架来执行任务,只要任务不是始终超时,就可以回到原本的时间框架上。
    var 下一帧时间=0
    while(定时器开始)
    {
        下一帧时间+=间隔时间
        while(当前时间<下一帧时间)
        {
        等待;
        }
        触发任务;
    }

    2.可推迟时间框架
    上面的例子会按照等待 10ms 、任务 7ms、等待 3ms、任务 12ms(超时,推迟时间框架 2ms)、任务 7ms、等待 3ms、… 进行。超时的任务会推迟时间框架。

    var 下一帧时间 = 0;
    while(定时器开启)
    {
        下一帧时间 += 间隔时间;
        if (下一帧时间 < 当前计时)
            下一帧时间 = 当前计时
        while (当前计时 < 下一帧时间)
        {
            等待;
        }
        触发任务;
    }

    3.固定等待框架
    上面的例子会按照等待 10ms、任务 7ms、等待 10ms、任务 12ms、等待 10ms、任务 7ms… 进行。等待时间始终不变。

    while(定时器开启)
    {
        var 等待开始时间 = 当前计时;
        while ((当前计时 - 等待开始时间) < 间隔时间)
        {
            等待;
        }
        触发任务;
    }
    // 或者:
    var 下一帧时间 = 0;
    while(定时器开启)
    {
        下一帧时间 += 间隔时间;
        while (当前计时 < 下一帧时间)
        {
            等待;
        }
        触发任务;
        下一帧时间 = 当前计时;
    }

      在while循环中的等待可以使用自旋或阻塞,也可以结合它们来达到精度、稳定性和 CPU 开销的平衡。
      另外,由上面的伪代码可以看出,这三种模式的实现可以统一,能够做到根据情况切换。

    实现

      为了实现高精度的定时器,我们不采用阻塞模式(sleep函数和yield函数),而是采用QueryPerformanceFrequency()和QueryPerformanceCounter()函数。这两个函数是Visual C++提供并且仅供Windows 95及其后续版本使用,其精度与CPU的时钟频率有关,它们要求计算机从硬件上支持精确定时器。。QueryPerformanceFrequency()函数和QueryPerformanceCounter()函数的原型如下:

    BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);
    BOOL QueryPerformanceCounter(LARGE_INTEGER *lpCount);

    上述两个函数的参数的数据类型LARGE_INTEGER既可以是一个8字节长的整型数,也可以是两个4字节长的整型数的联合结构,其具体用法根据编译器是否支持64位而定。该类型的定义如下:

    typedef union _LARGE_INTEGER
    {
        struct
        {
            DWORD LowPart; // 4字节整型数
            LONG HighPart; // 4字节整型数
        };
        LONG QuadPart; // 8字节整型数
    }LARGE_INTEGER;

    使用QueryPerformanceFrequency()和QueryPerformanceCounter()函数进行精确定时的步骤如下:

    1. 首先调用QueryPerformanceFrequency()函数取得高精度运行计数器的频率f,单位是每秒多少次(n/s),此数一般很大;
    2. 在需要定时的代码的两端分别调用QueryPerformanceCounter()以取得高精度运行计数器的数值n1、n2,两次数值的差值通过f换算成时间间隔,t=(n2-n1)/f,当t大于或等于定时时间长度时,启动定时器;
      下面给出一个简单的计算时间的例子:
    LARGE_INTEGER m_liPerfFreq={0};
     //获取每秒多少CPU Performance Tick
     QueryPerformanceFrequency(&m_liPerfFreq); 
     LARGE_INTEGER m_liPerfStart={0};
     QueryPerformanceCounter(&m_liPerfStart);
     for(int i=0; i< 100; i++)
      cout << i << endl;
     LARGE_INTEGER liPerfNow={0};
     // 计算CPU运行到现在的时间
     QueryPerformanceCounter(&liPerfNow);
     int time=( ((liPerfNow.QuadPart - m_liPerfStart.QuadPart) * 1000)/m_liPerfFreq.QuadPart);
     char buffer[100];
     sprintf(buffer,"執行時間 %d millisecond ",time);
     cout<<buffer<<endl;
    

    下列再由此实现1ms的精确定时:

      LARGE_INTEGER litmp; 
           LONGLONG QPart1,QPart2;
           double dfMinus, dfFreq, dfTim; 
           QueryPerformanceFrequency(&litmp);
           dfFreq = (double)litmp.QuadPart;// 获得计数器的时钟频率
           QueryPerformanceCounter(&litmp);
           QPart1 = litmp.QuadPart;// 获得初始值
           do
           {
              QueryPerformanceCounter(&litmp);
              QPart2 = litmp.QuadPart;//获得中止值
              dfMinus = (double)(QPart2-QPart1);
              dfTim = dfMinus / dfFreq;// 获得对应的时间值,单位为秒
           }while(dfTim<0.001);

      根据上述定时器,再结合之前的定时与任务的框架,就可以实现高精度的定时器,精度可以达到us级别。基本上可以满足大部分的对实时要求很高任务了。

    展开全文
  • 用硬件时钟同步系统时钟: 用系统时钟同步硬件时钟: 同步网络时间 查看和修改Linux的时间 时钟--详解 硬件时钟 系统时钟 时间同步 时间标准 网络时间 ntp时钟同步服务 chrony时钟同步服务 备注 ntp...
  • 要想真正有效地测试、优化程序性能——特别是为Windows服务器开发的多线程程序,操作系统提供的标准时钟是不够的,必须使用解析度更高的时钟。本文介绍了如何访问处理器的十亿分之一秒级别的时钟,极大地提高代码...
  • Windows下时间精度

    千次阅读 2014-07-25 17:17:59
    Windows为非实时系统,它的Timer通常精度不是很高,下面是常用的Timer设置处理 常用的时间精度 1. SetTimer/OnTimer 根据MSDN中的定义,可以知道,最下值是参考宏USER_TIMER_MINIMUM. If uElapse is less than USER...
  • Windows 2003 Server支持各种多处理器系统,同时也能在单处理器的P4系统上运行。对于单处理器P4系统Windows 2003 Server将发挥出Intel超线程技术提供的各种硬件线程执行引擎的优势。  开发服务器应用的人都...
  • 全网目前最好的,基于windows下写的四次握手ptp时钟同步程序,自动对时钟偏差进行修正,并计算双向延迟,实现毫秒级精度。修改时间需要提前关闭系统的自动对时功能,并用管理员方式打开程序。
  • windows 时间 定时 精度

    2011-06-11 12:28:00
    每执行一次,输出当前系统时钟值到文件“cure.out”,以 比较此定时器的精确度。 (此程序在中文windows95及Microsoft VC5.0编译通过。只节取与定时器有关的部分程序。) #include  stdio.h >  //...
  • 时钟系统(NTP子母钟系统)如何为高铁系统保驾护航 时钟系统(NTP子母钟系统)如何为高铁系统保驾护航 1、时钟系统概述 时钟系统是轨道交通系统的重要组成部份之一,其主要作用是为控制中心调度员、车站值班员、各...
  • Windows下高精度计时方法

    千次阅读 2005-03-24 17:09:00
    QueryPerformanceFrequency定时法://取系统级时间精度:varc1:int64;t1,t2:int64;r1:double;begin QueryPerformanceFrequency(c1);//第一次调用,获得时钟晶震频率 QueryPerformanceCounter(t1);//WINDOWS API ...
  • 在分析IEEE1588原理以及影响同步精度因素的基础上,设计了基于Windows平台的时间同步方法,为分布式网络系统时钟精确同步提供了一种有效可行的解决办法。目前,Windows平台下直接在应用层获取的时间戳精度在10ms级...
  • Windows定时精度比较

    千次阅读 2015-06-17 12:21:05
    Windows定时精度比较   方式一:VC中的WM_TIMER消息映射能进行简单的时间控制。首先调用函数SetTimer()设置定时间隔,如SetTimer(0,200,NULL)即为设置200ms的时间间隔。然后在应用程序中增加定时响应函数 OnTimer()...
  • Windows实现高精度定时器的三种方法

    万次阅读 2018-08-25 14:42:57
    前段时间一个项目需要用到1/24s的高精度定时器,每秒的误差不能超过10ms,大约41.666666666毫秒的延时,普通Sleep肯定是没办法满足的了,可以用以下新的三种方法: /* // 1秒=1000毫秒(ms) // 1毫秒=1/1000秒(s)...
  • System.currentTimeMillis()是依赖于系统时钟的,也就是说,如果你把自己的系统时钟更改了,这个函数的返回会立即生效,变成更改后的值; System.nanoTime()主要用于记录一个时间段的长度,或者说一个超时,在这个...
  • 弱电时间同步系统(卫星同步时钟)医院学校标准时钟系统建设的意义 弱电时间同步系统(卫星同步时钟)医院学校标准时钟系统建设的意义 **本文由安徽京准公司提供请勿转载** 摘要:随着网络的飞速发展,设备的日益...
  • windows下高精度时间获取

    千次阅读 2014-04-03 19:01:35
    对关注性能的程序开发人员而言,一个好的计时部件既是益友,也是良师。计时器既可以作为程序组件帮助程序员精确的控制程序进程,又是一件有力的调试武器,在有经验的程序员手里...但这个精度对很多应用场合而言还是太粗
  • Windows时钟同步(时间同步)问题 在系统部署的过程中间,时钟同步(时间同步)问题是必须的,这里只说明了Windows时钟同步(时间同步)的问题 1、时钟服务器的设置 windows server 2...
  • 系统时钟与进程调度

    千次阅读 2011-10-18 22:55:44
    【摘要】本章介绍了Linux系统的时间机制,包括系统时钟和硬件时钟之间的关系、各种时间标准的转换、时钟中断tick的维护;接着介绍了进程调度的几种常见算法、何时进行内核调度及选择相应该调度的进程,并分析了调度...
  • 在多核心或多处理器的计算机上,特别是在支持CPU频率动态调整的计算机上,windows系统下的QueryPerformanceFrequency()获取HPET(如果存...
  • 计算机网络系统 NTP时钟同步...依靠windows系统默认的windows或NIST等境外的时间服务器同步时间,总存在着访问堵塞、时间延迟大(同步精度低)等因素的影响。现在中国的国家授时中心发布了一个时间服务器地址,大家
  • Windows 时间服务的工作原理05/08/2018本文内容适用于:Windows Server 2016、Windows Server 2012 R2、Windows Server 2012、... 有关如何配置 Windows 时间服务的信息,请参阅配置系统以获得高精度。备注在 W...
  • Windows精度时间

    千次阅读 2016-12-12 11:03:54
    为了比较三个计时器的精度,特编制如下代码: // 使用高性能计时器实现的 GetTickCount 函数 double GetTickCountA() { __int64 Freq = 0; __int64 Count = 0; if...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,481
精华内容 2,592
关键字:

windows系统的时钟精度