linux下的时间 汇编
来源：互联网 发布：cf检测客户端数据异常 编辑：程序博客网 时间：2024/05/16 07:01
一．概念
Coordinated Universal Time（UTC）：协调世界时，又称为世界标准时间，也就是大家所熟知的格林威治标准时间（Greenwich Mean Time，GMT）。比如，中国内地的时间与UTC的时差为+8，也就是UTC+8。美国是UTC-5。
Calendar Time：日历时间，是用“从一个标准时间点到此时的时间经过的秒数”来表示的时间。这个标准时间点对不同的编译器来说会有所不同，但对一个编译系统来说，这个标准时间点是不变的，该编译系统中的时间对应的日历时间都通过该标准时间点来衡量，所以可以说日历时间是“相对时间”，但是无论你在哪一个时区，在同一时刻对同一个标准时间点来说，日历时间都是一样的。
epoch：时间点。时间点在标准C/C++中是一个整数，它用此时的时间和标准时间点相差的秒数（即日历时间）来表示。
clock tick：时钟计时单元（而不把它叫做时钟滴答次数），一个时钟计时单元的时间长短是由CPU控制的。一个clock tick不是CPU的一个时钟周期，而是C/C++的一个基本计时单位。
二． 计时
1. clock: C/C++中的计时函数是clock()，而与其相关的数据类型是clock_t。在MSDN中，查得对clock函数定义如下：
clock_t clock( void );
返回：从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数。
clock_t：是用来保存时间的数据类型，在time.h文件中，我们可以找到对它的定义：
#ifndef _CLOCK_T_DEFINED
typedef long clock_t;
#define _CLOCK_T_DEFINED
#endif
2. CLOCKS_PER_SEC 在time.h文件中，还定义了一个常量CLOCKS_PER_SEC，它用来表示一秒钟会有多少个时钟计时单元，其定义如下：
#define CLOCKS_PER_SEC ((clock_t)1000)
可以看到可以看到每过千分之一秒（1毫秒），调用clock（）函数返回的值就加1。下面举个例子，你可以使用公式clock()/CLOCKS_PER_SEC来计算一个进程自身的运行时间：
void elapsed_time()
{
printf("Elapsed time:%u secs.\n",clock()/CLOCKS_PER_SEC);
}
3. 用clock计时
当然，你也可以用clock函数来计算你的机器运行一个循环或者处理其它事件到底花了多少时间：
方法1：
#include “stdio.h”
#include “stdlib.h”
#include “time.h”
int main( void )
{
long i = 10000000L;
clock_t start, finish;
double duration;
/* 测量一个事件持续的时间*/
printf( "Time to do %ld empty loops is ", i );
start = clock();
while( i-- ) ;
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
printf( "%f seconds\n", duration );
system("pause");
}
在笔者的机器上，运行结果如下：
Time to do 10000000 empty loops is 0.03000 seconds
方法2(：摘自付国宏老师的Chart_parser程序)：
struct timeb fStartTime;
struct timeb fEndTime;
ftime( &fStartTime );
…
ftime( &fEndTime );
double dbTotalProcessTime = (float) (((float) (fEndTime.time - fStartTime.time ) +
((float) (fEndTime.millitm - fStartTime.millitm) * 0.001 )));
上面我们看到时钟计时单元的长度为1毫秒，那么计时的精度也为1毫秒，那么我们可不可以通过改变CLOCKS_PER_SEC的定义，通过把它定义的大一些，从而使计时精度更高呢？通过尝试，你会发现这样是不行的。在标准C/C++中，最小的计时单位是一毫秒。
三．与日期和时间相关的数据结构
1. tm
在标准C/C++中，我们可通过tm结构来获得日期和时间，ANSI C标准称使用tm结构的这种时间表示为分解时间(broken-down time)。tm结构在time.h中的定义如下：
#ifndef _TM_DEFINED
struct tm {
int tm_sec; /* 秒 – 取值区间为[0,59] */
int tm_min; /* 分 - 取值区间为[0,59] */
int tm_hour; /* 时 - 取值区间为[0,23] */
int tm_mday; /* 一个月中的日期 - 取值区间为[1,31] */
int tm_mon; /* 月份（从一月开始，0代表一月） - 取值区间为[0,11] */
int tm_year; /* 年份，其值等于实际年份减去1900 */
int tm_wday; /* 星期 – 取值区间为[0,6]，其中0代表星期天，1代表星期一，以此类推 */
int tm_yday; /* 从每年的1月1日开始的天数 – 取值区间为[0,365]，其中0代表1月1日，1代表1月2日，以此类推 */
int tm_isdst; /* 夏令时标识符，实行夏令时的时候，tm_isdst为正。不实行夏令时的进候，tm_isdst为0；不了解情况时，tm_isdst()为负。*/
};
#define _TM_DEFINED
#endif
2. time_t
日历时间（Calendar Time）是通过time_t数据类型来表示的，用time_t表示的时间（日历时间）是从一个时间点（例如：1970年1月1日0时0分0秒）到此时的秒数。在time.h中，我们也可以看到time_t是一个长整型数：
#ifndef _TIME_T_DEFINED
typedef long time_t; /* 时间值 */
#define _TIME_T_DEFINED /* 避免重复定义 time_t */
#endif
大家可能会产生疑问：既然time_t实际上是长整型，到未来的某一天，从一个时间点（一般是1970年1月1日0时0分0秒）到那时的秒数（即日历时间）超出了长整形所能表示的数的范围怎么办？对time_t数据类型的值来说，它所表示的时间不能晚于2038年1月18日19时14分07秒。为了能够表示更久远的时间，一些编译器厂商引入了64位甚至更长的整形数来保存日历时间。比如微软在Visual C++中采用了__time64_t数据类型来保存日历时间，并通过_time64()函数来获得日历时间（而不是通过使用32位字的time()函数），这样就可以通过该数据类型保存3001年1月1日0时0分0秒（不包括该时间点）之前的时间。
通过查阅MSDN，我们可以知道Microsoft C/C++ 7.0中时间点的值（time_t对象的值）是从1899年12月31日0时0分0秒到该时间点所经过的秒数，而其它各种版本的Microsoft C/C++和所有不同版本的Visual C++都是计算的从1970年1月1日0时0分0秒到该时间点所经过的秒数。
四．与日期和时间相关的函数及应用
4.1 获得日历时间time()
通过time()函数来获得日历时间（Calendar Time），其原型为：
time_t time(time_t * timer);
用法如：
time_t lt;
lt =time(NULL);
printf("The Calendar Time now is %d\n",lt);
output：
The Calendar Time now is 1122707619
4.2 获得日期和时间
struct tm * gmtime(const time_t *timer);
struct tm * localtime(const time_t * timer);
gmtime()：是将日历时间转化为世界标准时间（即格林尼治时间），并返回一个tm结构体来保存这个时间。
localtime()：函数是将日历时间转化为本地时间。比如现在用gmtime()函数获得的世界标准时间是2005年7月30日7点18分20秒，那么我用localtime()函数在中国地区获得的本地时间会比时间标准时间晚8个小时，即2005年7月30日15点18分20秒。下面是个例子：
#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *local;
time_t t;
t=time(NULL);
local=localtime(&t);
printf("Local hour is: %d\n",local->tm_hour);
local=gmtime(&t);
printf("UTC hour is: %d\n",local->tm_hour);
return 0;
}
运行结果是：
Local hour is: 15
UTC hour is: 7
4.3 固定的时间格式
我们可以通过asctime()函数和ctime()函数将时间以固定的格式显示出来，两者的返回值都是char*型的字符串。返回的时间格式为：
星期几 月份 日期 时:分:秒 年\n\0
例如：Wed Jan 02 02:03:55 1980\n\0
其中\n是一个换行符，\0是一个空字符，表示字符串结束。下面是两个函数的原型：
char * asctime(const struct tm * timeptr);
char * ctime(const time_t *timer);
asctime()函数: 是通过tm结构来生成具有固定格式的保存时间信息的字符串，
ctime（）：是通过日历时间来生成时间字符串。只是把tm结构对象中的各个域填到时间字符串的相应位置就行了函数需要先参照本地的时间设置，把日历时间转化为本地时间，然后再生成格式化后的字符串。
在下面，如果lt是一个非空的time_t变量的话，那么：
printf(ctime(lt));
等价于：
struct tm *ptr;
ptr=localtime(lt);
printf(asctime(ptr));
那么，下面这个程序的两条printf语句输出的结果就是不同的了（除非你将本地时区设为世界标准时间所在的时区）：
ptr=gmtime(<);
printf(asctime(ptr));
printf(ctime(<));
运行结果：
Sat Jul 30 08:43:03 2005
Sat Jul 30 16:43:03 2005
4.4 自定义时间格式
我们可以使用strftime（）函数将时间格式化为我们想要的格式。它的原型如下：
size_t strftime(
char *strDest,
size_t maxsize,
const char *format,
const struct tm *timeptr
);
我们可以根据format指向字符串中格式命令把timeptr中保存的时间信息放在strDest指向的字符串中，最多向strDest中存放maxsize个字符。该函数返回向strDest指向的字符串中放置的字符数。
函数strftime()的操作有些类似于sprintf()：识别以百分号(%)开始的格式命令集合，格式化输出结果放在一个字符串中。格式化命令说明串strDest中各种日期和时间信息的确切表示方法。格式串中的其他字符原样放进串中。格式命令列在下面，它们是区分大小写的。
%a 星期几的简写
%A 星期几的全称
%b 月分的简写
%B 月份的全称
%c 标准的日期的时间串
%C 年份的后两位数字
%d 十进制表示的每月的第几天
%D 月/天/年
%e 在两字符域中，十进制表示的每月的第几天
%F 年-月-日
%g 年份的后两位数字，使用基于周的年
%G 年分，使用基于周的年
%h 简写的月份名
%H 24小时制的小时
%I 12小时制的小时
%j 十进制表示的每年的第几天
%m 十进制表示的月份
%M 十时制表示的分钟数
%n 新行符
%p 本地的AM或PM的等价显示
%r 12小时的时间
%R 显示小时和分钟：hh:mm
%S 十进制的秒数
%t 水平制表符
%T 显示时分秒：hh:mm:ss
%u 每周的第几天，星期一为第一天 （值从0到6，星期一为0）
%U 第年的第几周，把星期日做为第一天（值从0到53）
%V 每年的第几周，使用基于周的年
%w 十进制表示的星期几（值从0到6，星期天为0）
%W 每年的第几周，把星期一做为第一天（值从0到53）
%x 标准的日期串
%X 标准的时间串
%y 不带世纪的十进制年份（值从0到99）
%Y 带世纪部分的十制年份
%z，%Z 时区名称，如果不能得到时区名称则返回空字符。
%% 百分号
如果想显示现在是几点了，并以12小时制显示，就象下面这段程序：
#include “time.h”
#include “stdio.h”
int main(void)
{
struct tm *ptr;
time_t lt;
char str[80];
lt=time(NULL);
ptr=localtime(<);
strftime(str,100,"It is now %I %p",ptr);
printf(str);
return 0;
}
其运行结果为：
It is now 4PM
而下面的程序则显示当前的完整日期：
#include
#include
void main( void )
{
struct tm *newtime;
char tmpbuf[128];
time_t lt1;
time( <1 );
newtime=localtime(<1);
strftime( tmpbuf, 128, "Today is %A, day %d of %B in the year %Y.\n", newtime);
printf(tmpbuf);
}
运行结果：
Today is Saturday, day 30 of July in the year 2005.
4.5 计算持续的时间长度
有时候在实际应用中要计算一个事件持续的时间长度，比如计算打字速度。在第1节计时部分中，我已经用clock函数举了一个例子。Clock()函数可以精确到毫秒级。同时，我们也可以使用difftime()函数，但它只能精确到秒。该函数的定义如下：
double difftime(time_t time1, time_t time0);
虽然该函数返回的以秒计算的时间间隔是double类型的，但这并不说明该时间具有同double一样的精确度，这是由它的参数觉得的（time_t是以秒为单位计算的）。比如下面一段程序：
time_t start,end;
start = time(NULL);
system("pause");
end = time(NULL);
printf("The pause used %f seconds.\n",difftime(end,start));//<-
system("pause");
return 0;
}
运行结果为：
请按任意键继续. . .
The pause used 2.000000 seconds.
请按任意键继续. . .
可以想像，暂停的时间并不那么巧是整整2秒钟。其实，你将上面程序的带有“//<-”注释的一行用下面的一行代码替换：
printf("The pause used %f seconds.\n",end-start);
其运行结果是一样的。
4.6 分解时间转化为日历时间
这里说的分解时间就是以年、月、日、时、分、秒等分量保存的时间结构，在C/C++中是tm结构。我们可以使用mktime（）函数将用tm结构表示的时间转化为日历时间。其函数原型如下：
time_t mktime(struct tm * timeptr);
其返回值就是转化后的日历时间。这样我们就可以先制定一个分解时间，然后对这个时间进行操作了，下面的例子可以计算出1997年7月1日是星期几：
struct tm t;
time_t t_of_day;
t.tm_year=1997-1900;
t.tm_mon=6;
t.tm_mday=1;
t.tm_hour=0;
t.tm_min=0;
t.tm_sec=1;
t.tm_isdst=0;
t_of_day=mktime(&t);
printf(ctime(&t_of_day));
return 0;
}
运行结果：
Tue Jul 01 00:00:01 1997
五．总结
本文介绍了标准C/C++中的有关日期和时间的概念，并通过各种实例讲述了这些函数和数据结构的使用方法。笔者认为，和时间相关的一些概念是相当重要的，理解这些概念是理解各种时间格式的转换的基础，更是应用这些函数和数据结构的基础。
在内核中有3个不同的时间：
Wall time(real time), Process time和Monotonic time.
Wall time,也就是rtc时钟。
Process time，进程执行的时间。
Monotonic time,也就是系统从boot后到当前的时间。
表示时间的数据结构：
- typedef __timer_t timer_t;
- struct timeval
- {
- __time_t tv_sec; /* Seconds. */
- __suseconds_t tv_usec; /* Microseconds. */
- };
- struct timespec
- {
- __time_t tv_sec; /* Seconds. */
- long int tv_nsec; /* Nanoseconds. */
- };
其中第三个最好，因为他能精确到纳秒。
上面的所能表示的是秒，我们有时需要更直观的表示，因此就有下面的数据结构;
- struct tm
- {
- int tm_sec; /* Seconds. [0-60] (1 leap second) */
- int tm_min; /* Minutes. [0-59] */
- int tm_hour; /* Hours. [0-23] */
- int tm_mday; /* Day. [1-31] */
- int tm_mon; /* Month. [0-11] */
- int tm_year; /* Year - 1900. */
- int tm_wday; /* Day of week. [0-6] */
- int tm_yday; /* Days in year.[0-365] */
- int tm_isdst; /* DST. [-1/0/1]*/
- #ifdef __USE_BSD
- long int tm_gmtoff; /* Seconds east of UTC. */
- __const char *tm_zone; /* Timezone abbreviation. */
- #else
- long int __tm_gmtoff; /* Seconds east of UTC. */
- __const char *__tm_zone; /* Timezone abbreviation. */
- #endif
- };
clock_getres这个函数得到不同时钟的精度，也就是时钟间隔：
- int clock_getres(clockid_t clk_id, struct timespec *res);
- #include <stdio.h>
- #include <time.h>
- int main()
- {
- clockid_t clocks[]= {
- CLOCK_REALTIME,
- CLOCK_MONOTONIC,
- CLOCK_PROCESS_CPUTIME_ID,
- CLOCK_THREAD_CPUTIME_ID,
- (clockid_t) -1,
- };
- int i;
- for(i=0;clocks[i] != (clockid_t) -1;i++)
- {
- struct timespec res;
- int ret;
- ret = clock_getres(clocks[i],&res);
- if(ret)
- perror("clock_getres");
- else
- printf("clock = [%d],sec = [%ld],nsec = [%ld]\n",clocks[i],res.tv_sec,res.tv_nsec);
- }
- return 1;
- }
我的amd的cpu下，输出结果是这样的：
- clock = [0],sec = [0],nsec = [4000250]
- clock = [1],sec = [0],nsec = [4000250]
- clock = [2],sec = [0],nsec = [1]
- clock = [3],sec = [0],nsec = [1]
其中4000250刚好是0.04秒，也就是说x86的架构的系统时钟频率为250hz。。
得到当前的时间的函数：
- extern time_t time (time_t *__timer) __THROW;
- int gettimeofday(struct timeval *tv, struct timezone *tz);
- int clock_gettime(clockid_t clk_id, struct timespec *tp);
- #include <stdio.h>
- #include <time.h>
- int main()
- {
- clockid_t clocks[]= {
- CLOCK_REALTIME,
- CLOCK_MONOTONIC,
- CLOCK_PROCESS_CPUTIME_ID,
- CLOCK_THREAD_CPUTIME_ID,
- (clockid_t) -1,
- };
- int i;
- for(i=0;clocks[i] != (clockid_t) -1;i++)
- {
- struct timespec res;
- int ret;
- ret = clock_gettime(clocks[i],&res);
- if(ret)
- perror("clock_getres");
- else
- printf("clock = [%d],sec = [%ld],nsec = [%ld]\n",clocks[i],res.tv_sec,res.tv_nsec);
- }
- return 1;
- }
通过结果可以看出4个时钟的不同含义。比如CLOCK_REALTIME我们可以看到结果就是从1970年以来所经过的秒数。。
设置时间的函数和get差不多：
- int stime(time_t *t);
- int settimeofday(const struct timeval *tv, const struct timezone *tz);
- int clock_settime(clockid_t clk_id, const struct timespec *tp);
这里要注意，在大部分系统我们设置时钟，只能设置CLOCK_REALTIME。。
这里还有一个更高级的函数：
- #include <sys/timex.h>
- int adjtimex(struct timex *buf);
这个函数用来同步内核的时钟。具体的用法可以去看man。。
sleep的4个函数：
- sleep
- usleep
- int nanosleep(const struct timespec *req, struct timespec *rem);
- long sys_clock_nanosleep (clockid_t which_clock, int flags, const struct timespec *rqtp, struct timespec *rmtp);
sleep和usleep区别不大，一个是秒，一个是毫秒而已。
nanosleep和他们的区别是它使用纳秒，并且他不是用信号来实现的，因此建议使用nanosleep，而不要使用sleep和usleep。
而最后一个函数我们可以选择所取的时钟。。
Linux获取当前时间
1. Linux下与时间有关的结构体
struct timeval
{
int tv_sec;
int tv_usec;
};
其中tv_sec是由凌晨开始算起的秒数，tv_usec则是微秒(10E-6 second)。
struct timezone
{
int tv_minuteswest;
int tv_dsttime;
};
tv_minuteswest是格林威治时间往西方的时差，tv_dsttime则是时间的修正方式。
struct timespec
{
long int tv_sec;
long int tv_nsec;
};
tv_nsec是nano second(10E-9 second)。
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};
tm_sec表「秒」数，在[0,61]之间，多出来的两秒是用来处理跳秒问题用的。
tm_min表「分」数，在[0,59]之间。
tm_hour表「时」数，在[0,23]之间。
tm_mday表「本月第几日」，在[1,31]之间。
tm_mon表「本年第几月」，在[0,11]之间。
tm_year要加1900表示那一年。
tm_wday表「本第几日」，在[0,6]之间。
tm_yday表「本年第几日」，在[0,365]之间，闰年有366日。
tm_isdst表是否为「日光节约时间」。
struct itimerval
{
struct timeval it_interval;
struct timeval it_value;
};
it_interval成员表示间隔计数器的初始值，而it_value成员表示间隔计数器的当前值。
2.获得当前时间
在所有的UNIX下，都有个time()的函数
time_t time(time_t *t);
这个函数会传回从epoch开始计算起的秒数，如果t是non-null，它将会把时间值填入t中。
对某些需要较高精准度的需求，Linux提供了gettimeofday()。
int gettimeofday(struct timeval * tv,struct timezone *tz);
int settimeofday(const struct timeval * tv,const struct timezone *tz);
struct tm格式时间函数
struct tm * gmtime(const time_t * t);
转换成格林威治时间。有时称为GMT或UTC。
struct tm * localtime(const time_t *t);
转换成本地时间。它可以透过修改TZ环境变数来在一台机器中，不同使用者表示不同时间。
time_t mktime(struct tm *tp);
转换tm成为time_t格式，使用本地时间。
tme_t timegm(strut tm *tp);
转换tm成为time_t格式，使用UTC时间。
double difftime(time_t t2,time_t t1);
计算秒差。
3.文字时间格式函数
char * asctime(struct tm *tp);
char * ctime(struct tm *tp);
这两个函数都转换时间格式为标准UNIX时间格式。
Mon May 3 08:23:35 1999
ctime一率使用当地时间，asctime则用tm结构内的timezone资讯来表示。
size_t strftime(char *str,size_t max,char *fmt,struct tm *tp);
strftime有点像sprintf，其格式由fmt来指定。
%a : 本第几天名称，缩写。
%A : 本第几天名称，全称。
%b : 月份名称，缩写。
%B : 月份名称，全称。
%c : 与ctime/asctime格式相同。
%d : 本月第几日名称，由零算起。
%H : 当天第几个小时，24小时制，由零算起。
%I : 当天第几个小时，12小时制，由零算起。
%j : 当年第几天，由零算起。
%m : 当年第几月，由零算起。
%M : 该小时的第几分，由零算起。
%p : AM或PM。
%S : 该分钟的第几秒，由零算起。
%U : 当年第几，由第一个日开始计算。
%W : 当年第几，由第一个一开始计算。
%w : 当第几日，由零算起。
%x : 当地日期。
%X : 当地时间。
%y : 两位数的年份。
%Y : 四位数的年份。
%Z : 时区名称的缩写。
%% : %符号。
char * strptime(char *s,char *fmt,struct tm *tp);
如同scanf一样，解译字串成为tm格式。
%h : 与%b及%B同。
%c : 读取%x及%X格式。
%C : 读取%C格式。
%e : 与%d同。
%D : 读取%m/%d/%y格式。
%k : 与%H同。
%l : 与%I同。
%r : 读取"%I:%M:%S %p"格式。
%R : 读取"%H:%M"格式。
%T : 读取"%H:%M:%S"格式。
%y : 读取两位数年份。
%Y : 读取四位数年份。
下面举一个小例子，说明如何获得系统当前时间：
- time_t now;
- struct tm *timenow;
- char strtemp[255];
- time(&now);
- timenow = localtime(&now);
- printf("recent time is : %s \n", asctime(timenow));
- linux下的时间 汇编
- Linux下的汇编
- linux下的汇编开发
- Linux下的时间
- Linux下的时间
- LINUX下汇编的编译，调试命令
- (收集)Linux下的汇编相关文章
- Linux下的汇编开发简介
- LINUX下ARM的汇编语法
- Linux 下的64位汇编
- Linux下的objdump反汇编工具
- linux下编写汇编的Helloworld
- linux下的预处理--编译--汇编---连接
- Linux下反汇编指定的函数
- linux下编写汇编的Helloworld
- Linux下C程序的反汇编
- linux下汇编调试
- Linux下ARM汇编
- Myeclipse 部署Tomcat的两种方式
- 查看各种Role所需服务的运行状态
- ubuntu12.04安装openvpn
- tcp udp实现文件传输（java）
- 两个数中显示最大的数
- linux下的时间 汇编
- 三个数中显示最大的数
- 资源管理器双击弹出新窗口或普通文件列表窗口双击弹出资源管理器的解决方法
- 查看linux cpu 内存信息
- 十个数中显示最大的数
- 华氏温标与摄氏温标的转换
- 判断一个数是否为素数
- 判断整除并求和
- 大数据量，海量数据 处理方法总结
