精华内容
下载资源
问答
  • tv_usec
    千次阅读
    2018-12-24 19:24:57

    该结构体是Linux系统中定义,struct timeval结构体在time.h中的定义为:

    struct timeval
    {
    __time_t tv_sec;        /* Seconds. */
    __suseconds_t tv_usec;  /* Microseconds. */
    };

    在ndk中使用tv_sec或者tv_usec时,需先强制类型转换,否则直接用于计算或者显示会有溢出现象(如tv_sec的值输出为负数)。

    例子如下:

    long long getCurrentTimeInMilliseconds()      
       struct timeval tv;
       gettimeofday(&tv,NULL);
       return ((long long)tv.tv_sec) * 1000 + ((long long)tv.tv_usec) / 1000;
    }

     

    更多相关内容
  • linux 时间与文件实验

    2013-05-10 12:21:13
    tick.it_value.tv_usec = 0; tick.it_i nt erval.tv_sec =1; //定时器启动后,每隔 1 秒将执行相应的函数 tick.it_i nt erval.tv_usec = 0; //setitimer 将触发 SIGALRM 信号 int ret = setiti mer(ITIMER_REAL, &...
  • linux获取时间,精确到微秒usec

    千次阅读 2018-08-18 20:21:48
    int gettimeofday(struct timeval *tv, struct timezone *tz); 计算时间间隔,精确到微秒: 1.首先获取任务起始时间值,使用上述接口,也可以封装,并记录到微秒 2.中途执行其他任务 3.再次获取任务结束时间值,...

    包含系统头文件:#include <sys/time.h>

    用到的接口:

    int gettimeofday(struct timeval *tv, struct timezone *tz);

    计算时间间隔,精确到微秒:

    1.首先获取任务起始时间值,使用上述接口,也可以封装,并记录到微秒

    2.中途执行其他任务

    3.再次获取任务结束时间值,使用上述接口,也可以简单封装

    4.计算两次时间间隔,微秒转换为秒,单位为S,保留小数位数。

    long long GetCurrentTime()
    {
        struct timeval time;
    
        gettimeofday(&time,NULL);
        
        return (time.tv_sec * 1000000 + time.tv_usec);
    }
    
    double CalcTime_inusec(long long startusec, long long endusec)
    {
        return (double)(endusec - startusec)/1000000.0;
    }
    

    举例:

    int main ()
    {
        long long startusec, endusec;
        double elaps;
        startusec = GetCurrentTime();
        /* do sth */
        
        endusec = GetCurrentTime();
        elaps = CalcTime_inusec(startusec, endusec);
    
        printf("do sth took %.4f seconds\n", elaps);/* 精确到小数点后四位输出值,单位为S */
    }

     

    展开全文
  • 获取当前的时间的秒数和微秒数本方法需要用到...函数说明int gettimeofday (struct timeval * tv, struct timezone * tz) 1、返回值:该函数成功时返回0,失败时返回-1 2、参数 struct timeval{ long tv_sec; //秒

    获取当前的时间的秒数和微秒数本方法需要用到gettimeofday()函数,该函数需要引入的头文件是 sys/time.h 。

    函数说明int gettimeofday (struct timeval * tv, struct timezone * tz)

    1、返回值:该函数成功时返回0,失败时返回-1
    2、参数
    struct timeval{
    long tv_sec; //秒
    long tv_usec; //微秒
    };
    struct timezone
    {
    int tz_minuteswest; //和Greenwich 时间差了多少分钟
    int tz_dsttime; //日光节约时间的状态
    };

    其中.tv_sec是公元1970年至今的时间(换算为秒) 


    .tv_usec是当前秒数下的微妙数,所以将.tv_sec*1000+.tv_usec/1000可以得到当前的毫秒数


    3、示例

    #include<iostream>
    #include <stdlib.h>
    #include <stdio.h>
    #include <sys/time.h>
    #include <unistd.h>
    
    int main(){
        struct timeval tv;
        gettimeofday(&tv,NULL);
        printf("second:%ld\n",tv.tv_sec);  //秒
        printf("millisecond:%ld\n",tv.tv_sec*1000 + tv.tv_usec/1000);  //毫秒
        printf("microsecond:%ld\n",tv.tv_sec*1000000 + tv.tv_usec);  //微秒
    
        sleep(3); // 为方便观看,让程序睡三秒后对比
        std::cout << "3s later:" << std::endl;
    
        gettimeofday(&tv,NULL);
        printf("second:%ld\n",tv.tv_sec);  //秒
        printf("millisecond:%ld\n",tv.tv_sec*1000 + tv.tv_usec/1000);  //毫秒
        printf("microsecond:%ld\n",tv.tv_sec*1000000 + tv.tv_usec);  //微秒
        return 0;
    }

    
    

    运行结果: second:1467523986 millisecond:1467523986800 microsecond:1467523986800434 3s later: second:1467523989 millisecond:1467523989800 microsecond:1467523989800697

    4、附 一秒等于1000毫秒 一秒等于1000000微秒 一秒等于1000000000纳秒

    装载:http://blog.csdn.net/deyuzhi/article/details/51814934

    
    
    展开全文
  • C++中的计时器

    千次阅读 2021-07-03 14:38:22
    timeuse = t2.tv_sec - t1.tv_sec + (t2.tv_usec - t1.tv_usec)/1000000.0; printf("Use Time:%f\n",timeuse); } 8.RDTSC指令计时(Linux) 该时间精度同windows的可以达到纳秒级精度。 #if defined (__i386__) ...

    在调试代码的时候,很多时候需要用代码的运行时间来衡量代码的效率,看了网上已经有了很多关于计时的文章,自己学习的时候再进行一些整理吧。

    1. time()函数

    在头文件time.h中,time()获取当前的系统时间,只能精确到秒,返回的结果是一个time_t类型,其使用方法如下:

    #include <time.h>   
    #include <stdio.h>   
    
    int main() {  
         time_t first, second;  
         first=time(NULL);  
         delay(2000);  
         second=time(NULL);  
         printf("The difference is: %f seconds",difftime(second,first));  //调用difftime求出时间差
         return 0;   
    }

    2. clock()函数

    在头文件time.h中,clock()函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元(clock tick)数,在MSDN中称之为挂钟时间(wal-clock),常量CLOCKS_PER_SEC,它用来表示一秒钟会有多少个时钟计时单元,精确到毫秒,其使用方法如下:

    #include<time.h>
    #include<stdio.h>
    
    int main()
    {
        double dur;
        clock_t start,end;
        start = clock();
        foo();//dosomething
        end = clock();
        dur = (double)(end - start);
        printf("Use Time:%f\n",(dur/CLOCKS_PER_SEC));
    }

    3.timeGetTime()函数(Windows API

    时间精确到毫秒,以毫秒计的系统时间,该时间为从系统开启算起所经过的时间。在使用timeGetTime之前应先包含头文件#include <Mmsystem.h>或#include <Windows.h>并在project->settings->link->Object/library modules中添加winmm.lib。也可以在文件头部添加 #pragma comment( lib,"winmm.lib" )。

    备注:命令行:#pragma comment( lib,"xxx.lib" )时预编译处理指令,让vc将winmm.lib添加到工程中去进行编译。

    #include<stdio.h>
    #include<windows.h>
    
    #pragma comment( lib,"winmm.lib" )
    
    int main()
    {
        DWORD t1, t2;
        t1 = timeGetTime();
        foo();//do something
        t2 = timeGetTime();
        printf("Use Time:%f\n", (t2 - t1)*1.0 / 1000);
        return 0;
    }

     该函数的时间精度是五毫秒或更大一些,这取决于机器的性能。可用timeBeginPeriod和timeEndPeriod函数提高timeGetTime函数的精度。如果使用了,连续调用timeGetTime函数,一系列返回值的差异由timeBeginPeriod和timeEndPeriod决定。也可以用timeGetTime实现延时功能Delay

    void Delay(DWORD delayTime)
    {
      DWORD delayTimeBegin;
      DWORD delayTimeEnd;
      delayTimeBegin=timeGetTime();
      do
      {    delayTimeEnd=timeGetTime();
      }while((delayTimeEnd-delayTimeBegin)<delayTime)
    }

    4.QueryPerformanceCounter()函数和QueryPerformanceFrequency()函数(Windows API)

     QueryPerformanceFrequency()函数返回高精确度性能计数器的值,它可以精确到微妙为单位计时,但是QueryPerformanceCounter()确切的精确计时的最小单位是与系统有关的,所以,必须要查询系统以得到QueryPerformanceCounter()返回的嘀哒声的频率。QueryPerformanceFrequency()提供了这个频率值,返回每秒嘀哒声的个数。

     

    #include<stdio.h>
    #include<windows.h>
    #pragma comment( lib,"winmm.lib" )
    
    int main()
    {
        LARGE_INTEGER t1, t2, tc;
        QueryPerformanceFrequency(&tc);
        QueryPerformanceCounter(&t1);
        foo();//do something
        QueryPerformanceCounter(&t2);
        printf("Use Time:%f\n", (t2.QuadPart - t1.QuadPart)*1.0 / tc.QuadPart);
        return 0;
    }

    5.GetTickCount()函数(Windows API)

    GetTickCount返回(retrieve)从操作系统启动所经过(elapsed)的毫秒数,计时精度精确到毫秒,它的返回值是DWORD。

    #include<stdio.h>
    #include<windows.h>
    #pragma comment( lib,"winmm.lib" )
    
    int main()
    {
        DWORD t1, t2;
        t1 = GetTickCount();
        foo;//do something
        t2 = GetTickCount();
        printf("Use Time:%f\n", (t2 - t1)*1.0 / 1000);
        return 0;
    }

    6.RDTSC指令(Windows)

    在Intel Pentium以上级别的CPU中,有一个称为“时间戳(Time Stamp)”的部件,它以64位无符号整型数的格式,记录了自CPU上电以来所经过的时钟周期数。由于目前的CPU主频都非常高,因此这个部件可以达到纳秒级的计时精度。这个精确性是上述几种方法所无法比拟的.在Pentium以上的CPU中,提供了一条机器指令RDTSC(Read Time Stamp Counter)来读取这个时间戳的数字,并将其保存在EDX:EAX寄存器对中。由于EDX:EAX寄存器对恰好是Win32平台下C++语言保存函数返回值的寄存器,所以我们可以把这条指令看成是一个普通的函数调用,因为RDTSC不被C++的内嵌汇编器直接支持,所以我们要用_emit伪指令直接嵌入该指令的机器码形式0X0F、0X31。

    inline unsigned __int64 GetCycleCount()
    {
        __asm
        {
            _emit 0x0F;
            _emit 0x31;
        }
    }
    
    void test6()
    {
        unsigned long t1,t2;
        t1 = (unsigned long)GetCycleCount();
        foo();//dosomething
        t2 = (unsigned long)GetCycleCount();
        printf("Use Time:%f\n",(t2 - t1)*1.0/FREQUENCY);   //FREQUENCY指CPU的频率
    }

    获取CPU频率参考:http://blog.csdn.net/kofandlizi/article/details/6253801

    7.gettimeofday() (Linux)

    该调用可精度可以达到微秒, 且在x86-64平台gettimeofday()已不是系统调用,不会陷入内核, 多次调用不会有性能损失.

    //timeval结构定义为:
    struct timeval{
      long tv_sec; /*秒*/
      long tv_usec; /*微秒*/
    };
    //timezone 结构定义为:
    struct timezone{
      int tz_minuteswest; /*和Greenwich 时间差了多少分钟*/
      int tz_dsttime; /*日光节约时间的状态*/
    };
    void test()
    {
        struct timeval t1,t2;
        double timeuse;
        gettimeofday(&t1,NULL);
        foo();
        gettimeofday(&t2,NULL);
        timeuse = t2.tv_sec - t1.tv_sec + (t2.tv_usec - t1.tv_usec)/1000000.0;
        printf("Use Time:%f\n",timeuse);
    }

    8.RDTSC指令计时(Linux)

    该时间精度同windows的可以达到纳秒级精度

    #if defined (__i386__)
    static __inline__ unsigned long long GetCycleCount(void)
    {
            unsigned long long int x;
            __asm__ volatile("rdtsc":"=A"(x));
            return x;
    }
    #elif defined (__x86_64__)
    static __inline__ unsigned long long GetCycleCount(void)
    {
            unsigned hi,lo;
            __asm__ volatile("rdtsc":"=a"(lo),"=d"(hi));
            return ((unsigned long long)lo)|(((unsigned long long)hi)<<32);
    }
    #endif
    
    void test8()
    {
            unsigned long t1,t2;
            t1 = (unsigned long)GetCycleCount();
            foo();//dosomething
            t2 = (unsigned long)GetCycleCount();
            printf("Use Time:%f\n",(t2 - t1)*1.0/FREQUENCY); //FREQUENCY  CPU的频率
    }

    9.GetSystemTime / GetLocalTime(Windows)

     Windows SDK 中有两个精确到毫秒的获取当前时间的函数,可以获得毫秒级的精度

        GetSystemTime:获取 UTC 时间。

        GetLocalTime:获取当地时间。

      这两个函数的返回都是:SYSTEMTIME ,结构体占用了 16 个字节,它的定义如下:

    typedef struct _SYSTEMTIME {
      WORD wYear;
      WORD wMonth;
      WORD wDayOfWeek;
      WORD wDay;
      WORD wHour;
      WORD wMinute;
      WORD wSecond;
      WORD wMilliseconds;
    } SYSTEMTIME, *PSYSTEMTIME;
    
    // GetSystemTime.cpp : Defines the entry point for the console application.
    #include "stdafx.h"
    #include <Windows.h>
    
    int _tmain(void)
    {
        SYSTEMTIME utc_time = { 0 };
        SYSTEMTIME local_time = { 0 };
    
        GetSystemTime(&utc_time);
        GetLocalTime(&local_time);
        _tprintf(_T("The UTC time is \t: %02d:%02d:%02d.%03d\n"), utc_time.wHour, utc_time.wMinute, utc_time.wSecond, utc_time.wMilliseconds);
        _tprintf(_T("The local time is\t: %02d:%02d:%02d.%03d\n"), local_time.wHour, local_time.wMinute, local_time.wSecond, local_time.wMilliseconds);
        return 0;
    }

    10.GetSystemTimeAsFileTime

     究竟能不能达到 100 纳秒的精确度呢?在 Windows SDK 中有一个结构体:FILETIME,它可以记录精度达到 100ns 的时间。用哪个函数得到这个值呢?可以用 GetSystemTimeAsFileTime。但是,不要高兴得太早,虽

    然 FILETIME 能够达到如此高的精度,但是这个函数我连试都懒得试。为什么呢?因为 Windows 系统并不是一个实时操作系统(Windows Embedded Compact 2013 是一个实时系统),其时钟精度一般认为是 15 ~ 16 毫秒。

    Windows Sysinternals 给我们提供了一个查看你使用的 Windows 系统的时钟分辨率的小工具:ClockRes v2.0。把它下载下来在控制台中执行,结果如下: 

     

    看到了吧。死心了吧。所以说,用 GetSystemTime / GetLocalTime 就已经很好了。如果要获得真正毫秒级甚至更高精度的当前系统时间,必须跟 CPU 打交道,别无它法。先贴出代码吧:

    #ifdef _WIN32
    #include <windows.h>
    #else
    #include <time.h>
    #endif  // _WIND32
    
    
    // 定义64位整形
    #if defined(_WIN32) && !defined(CYGWIN)
    typedef __int64 int64_t;
    #else
    typedef long long int64t;
    #endif  // _WIN32
    
    // 获取系统的当前时间,单位微秒(us)
    int64_t GetSysTimeMicros()
    {
    #ifdef _WIN32
    // 从1601年1月1日0:0:0:000到1970年1月1日0:0:0:000的时间(单位100ns)
    #define EPOCHFILETIME   (116444736000000000UL)
        FILETIME ft;
        LARGE_INTEGER li;
        int64_t tt = 0;
        GetSystemTimeAsFileTime(&ft);
        li.LowPart = ft.dwLowDateTime;
        li.HighPart = ft.dwHighDateTime;
        // 从1970年1月1日0:0:0:000到现在的微秒数(UTC时间)
        tt = (li.QuadPart - EPOCHFILETIME) /10;
        return tt;
    #else
        timeval tv;
        gettimeofday(&tv, 0);
        return (int64_t)tv.tv_sec * 1000000 + (int64_t)tv.tv_usec;
    #endif // _WIN32
        return 0;
    }

     

    展开全文
  • timer = 1000000 * (end.tv_sec-start.tv_sec)+ end.tv_usec-start.tv_usec; printf("time:%ldus product_%d in %d. buffer: ", timer,id, in+1); //printf("timer = %ld us\n",timer); buff[in] = 1; ...
  • cout << "tm.tv_usec: " << tm.tv_usec ; long long timestamp = tm.tv_sec * 1000; cout ; return 0; } 运行结果如下。 32 tm.tv_sec: 1384764898 tm.tv_usec: 303888 timestamp: 1785428688 这里的32...
  • long deltaTime = 1000000L * (tEnd.tv_sec - tBegin.tv_sec ) + (tEnd.tv_usec - tBegin.tv_usec); printf("Time spent: %ldus\n", deltaTime); } 上述代码中,gettimeofday(&tBegin, NULL)用于获得计算之前的...
  • Appliances-c0jhyt_use_

    2021-10-01 09:44:46
    For rust okey just for rust
  • Linux时钟精度:毫秒?微妙?纳秒?

    千次阅读 2016-09-05 12:44:03
    解释同上,tv_sec代表墙上时间的秒,tv_usec表示从上一秒到现在经过的微秒数。就是说,它的精度是 微妙 。 struct timeval{  long tv_sec; //秒  long tv_usec; //微妙 }; 精彩的...
  • linux 延时及时间函数总结

    千次阅读 2016-10-18 16:22:09
    一、 基础知识 1、时间类型。Linux下常用的时间类型有4个:time_t,struct timeval,struct timespec,struct tm。 (1)time_t是一个长整型,一般用来表示用1970年以来的秒数。... long tv_
  • do_gettimeofday使用方法

    2021-03-14 22:16:00
    它的精度可以达到微妙,是与C标准库中gettimeofday()用发相同的函数。在Linux内核中获得时间的函数。 2.函数原型: #include <linux/time.h> void do_gettimeofday(struct timeval *tv); 3.说明: do_...
  • C/C++开发中遇到的时间Time计算

    千次阅读 2014-07-10 14:49:06
    return tv.tv_sec * 1000 + tv.tv_usec / 1000; } int main() { printf("TK------>>>>>>sizeof(long) is %d\n",sizeof(long)); printf("c/c++ program:%llu\n",getCurrentTime()); return 0; } */ ...
  • 对于linux libevent已经提供了一套锁机制,我们就不用...我们在linux上使用锁机制的时候只要使用int evthread_use_pthreads(void) 开启使用多线程机制,那么锁的机制也会自动加入进来 int evthread_use_pthreads(void...
  • + (endTime.tv_usec - startTime.tv_usec); Timeuse /= 1000000; printf("Timeuse = %f\n",Timeuse); }   #include #include int main(void) { int *r = (int*)calloc(64,sizeof(int)); int a =...
  • struct timeval结构体

    千次阅读 2019-11-29 16:54:08
    一、struct timeval结构体 struct timeval结构体在time.h中的定义为: struct timeval ...__suseconds_t tv_usec; /* Microseconds. */ }; 其中,tv_sec为Epoch到创建struct timeval时的秒数,tv_use...
  • C/C++中的计时器

    千次阅读 2020-08-05 16:47:03
    timeuse = t2.tv_sec - t1.tv_sec + (t2.tv_usec - t1.tv_usec)/1000000.0; printf("Use Time:%f\n",timeuse); } 4. RDTSC指令计时 —— Linux #if defined (__i386__) static __inline__ unsigned long long ...
  • 随机数的生成

    万次阅读 2019-10-30 23:41:29
    uint64_t ms_time =time_now.tv_sec*1000+time_now.tv_usec/1000; return ms_time; } uint64_t wait_next_ms(uint64_t lastStamp) { uint64_t cur = 0; do { cur = get_curr_ms(); } while (cur ); return ...
  • Linux 系统设置时间和获取时间

    千次阅读 2018-06-10 16:42:00
    tv.tv_usec = 0; 1.4 调用系统函数settimeofday(&tv, NULL),设置就OK了 , settimeofday函数的原型是 int settimeofday(const struct timeval *tv, struct timezone *tz); 参数tv表示时间的结构体,参数tz表示当地...
  • linux系统时间获取方式

    千次阅读 2017-10-13 18:04:10
    int timeuse = 1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec - start.tv_usec; printf("time: %d us\n", timeuse); return 0; } 结果:   [root@libmaster time]# ./a.out  time: 3000205 ...
  • Android NDK 开发在测试接口性能 使用gettimeofday,发现获取系统时间的函数输出的是一个负数。 long getCurrentMillisecondCount() { struct timeval tv;... return tv.tv_sec * 1000 + tv.tv_usec /...
  • linux 获得微秒时间

    千次阅读 2013-06-15 11:39:06
    使用函数 int gettimeofday(struct timeval *tv, struct timezone *tz);,struct timeval 结构体中记录了自1970年1月1日起到现在的时间即秒+微秒。 #include #include #include int main() { struct ...
  • 关于 struct timeval struct timeval { __time_t tv_sec;/*Seconds.*/ ...其中tv_sec是Epoch到创建结构体timeval的秒数,tv_usec为微秒数,也就是秒数后面的零头, 下面做一个实验 #include #inclu
  • 获取本地时间戳

    2020-03-11 00:35:32
    int getTimeStamp() { timeval tm; gettimeofday(&tm, NULL); return tm.tv_sec; // 单位:秒 return tm.tv_usec; // 单位:毫秒 }
  • C语言测试程序运行时间

    千次阅读 2015-08-24 19:03:17
    在标准C/C++中,最小的计时单位是一毫秒。C/C++在中有计时函数clock(),与其相关的数据类型是clock_t。clock函数定义如下: clock_t clock(void ); 这个函数返回从“开启这个程序进程”到“程序中调用clock()函数...
  • timeval使用和理解

    万次阅读 2018-11-22 17:33:11
    在 看协议的过程中经常会有同步 时间计算获得时间延迟,所以会用到timeval /* * Structure used in select() call, taken from the BSD file sys/time.h. */ struct timeval { long tv_sec;... long tv...
  • linux时间编程(二) - 定时器编程应用

    千次阅读 2014-07-16 18:36:44
    printf("%ld %ld\n", tv.tv_sec, tv.tv_usec); return 0; } 2.jiffies变量  jiffies内核变量用来记录自系统启动以来产生的节拍次数。  jiffies是一个有可能溢出的32位变量,jiffies_64这个64位版本的...
  • opt.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN); opt.c_cflag &= ~(CSIZE | PARENB); opt.c_cflag |= CS8; tcflush(fd,TCIFLUSH); //清空输入缓存 if(tcsetattr(fd,TCSANOW,&opt) != 0) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,181
精华内容 20,472
关键字:

tv_usec