今天遇到一个和gettimeofday()相关奇怪的问题，问题描述如下。

有如下代码，在32bit CentOS 6.3平台上编译后运行

#include <iostream>
#include <sys/time.h>

using namespace std;

int main(void) {
        std::cout << __WORDSIZE << std::endl;

        struct timeval tm;
        gettimeofday(&tm, NULL);
        cout << "tm.tv_sec: " << tm.tv_sec << endl;
        cout << "tm.tv_usec: " << tm.tv_usec << endl;
        long long timestamp = tm.tv_sec * 1000;
        cout << "timestamp: " << timestamp << endl;

        return 0;
}

运行结果如下。

32
tm.tv_sec: 1384764898
tm.tv_usec: 303888
timestamp: 1785428688

这里的32表明是32bit机器。tm.tv_sec 和 tm.tv_usec的值都是正确的，但timestamp值异常，应该是1384764898000，结果像是被截断了，成了1785428688。

修改第13行代码如下。即，先将tm.tv_sec强制类型转换成long long 类型，然后再做计算。

#include <iostream>
#include <sys/time.h>

using namespace std;

int main(void) {
        std::cout << __WORDSIZE << std::endl;

        struct timeval tm;
        gettimeofday(&tm, NULL);
        cout << "tm.tv_sec: " << tm.tv_sec << endl;
        cout << "tm.tv_usec: " << tm.tv_usec << endl;
        long long timestamp = (long long)tm.tv_sec * 1000;
        cout << "timestamp: " << timestamp << endl;

        return 0;
}

这样改过后，结果正确。

32
tm.tv_sec: 1384764980
tm.tv_usec: 331110
timestamp: 1384764980000

但是为什么会这样？timestamp是long long类型的，8字节，足够承载最终计算出来的值，所以像是问题出在tm.tv_sec上，但是tm.tv_sec本身输出的值也是正确的~~~

我猜原因大概是这样的：

1384764980 * 1000的值已经超出32位有符号int所能表示的最大上限（2 ^ 31 - 1 = 2147483647）了。

同时，long long timestamp = tm.tv_sec * 1000很可能被编译器先转成了下面的样子（32位系统下，tm.tv_sec的数据类型 time_t 是4字节int）

int tmp = tm.tv_sec * 1000;

long long timestamp = tmp;

在第一步就已经发生溢出了，第二步赋值给long long型变量还是溢出的值！

下面用一个小例子 t.cpp 来验证上面的猜测。

int main(void) {
	int intValue = 2100000000;
	long long llValue = intValue * 10;
	return 0;
}

通过 g++ -save-temps -S t.cpp 命令得到g++编译 t.cpp 过程中产生的汇编文件 t.s

基本上就是，用32位的寄存器做乘10的运算，结果也存在32位eax寄存器中（16-21行，这时已经溢出了），然后在赋值给llValue（22-25行）的时候，扩展成64位寄存器（edx, eax）表示。

=======================================

对 t.cpp 稍作修改如下，即在 intValue 做乘10操作前，强制类型转换成 long long 类型

int main(void) {
	int intValue = 2100000000;
	long long llValue = (long long)intValue * 10;
	return 0;
}

然后，得到新的汇编代码如下

	.file	"x.cpp"
	.text
.globl main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	.cfi_offset 5, -8
	movl	%esp, %ebp
	.cfi_def_cfa_register 5
	andl	$-8, %esp
	pushl	%ebx
	subl	$20, %esp
	movl	$2100000000, 4(%esp)
	movl	4(%esp), %eax
	movl	%eax, %edx
	sarl	$31, %edx
	imull	$10, %edx, %ecx
	imull	$0, %eax, %ebx
	.cfi_escape 0x10,0x3,0x7,0x75,0x0,0x9,0xf8,0x1a,0x34,0x1c
	addl	%ebx, %ecx
	movl	$10, %ebx
	mull	%ebx
	addl	%edx, %ecx
	movl	%ecx, %edx
	movl	%eax, 8(%esp)
	movl	%edx, 12(%esp)
	movl	%eax, 8(%esp)
	movl	%edx, 12(%esp)
	movl	$0, %eax
	addl	$20, %esp
	popl	%ebx
	.cfi_restore 3
	movl	%ebp, %esp
	.cfi_def_cfa_register 4
	popl	%ebp
	.cfi_restore 5
	.cfi_def_cfa_offset 4
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (GNU) 4.4.7 20120313 (Red Hat 4.4.7-3)"
	.section	.note.GNU-stack,"",@progbits

大致的意思就是，通过下面两条指令将数字2100000000保存在eax寄存器中：

movl $2100000000, 4(%esp)

movl 4(%esp), %eax

然后通过无符号乘法运算mull对eax做乘10操作,结果的高32位保存在edx中，低32位保存在eax中。

movl $10, %ebx

mull %ebx ；eax * ebx = edx,eax

2100000000的符号位通过算术右移31位获取到，然后也乘10，再加到结果的高32位edx寄存器中。

即，用两个32位寄存器来表示最终的计算结果，于是没有发生溢出！

前面的猜测基本正确~~~

转载：https://blog.csdn.net/deyuzhi/article/details/51814934
获取当前的时间的秒数和微秒数本方法需要用到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; //日光节约时间的状态
};
3、示例

#include
#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_sec1000 + tv.tv_usec/1000); //毫秒
printf(“microsecond:%ld\n”,tv.tv_sec1000000 + 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;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

4、附
一秒等于1000毫秒
一秒等于1000000微秒
一秒等于1000000000纳秒
————————————————
版权声明：本文为CSDN博主「is_thinking」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/deyuzhi/article/details/51814934

一、引言

练习编写调用内核的时间测量功能为应用程序测量和精确定时。

通过这个实验进一步了解Linux内核的定时机制及其数据结构以及怎样从用户空间去访问内核空间的时间数据。

二、实验内容

问题A：使用ITIMER_REAL型定时器实现一个gettimeofday()，将它设置为每秒产生一个信号，并计算已经经过的秒数。

问题B：使用以上实现的gettimeofday()实现一个精确到微秒级的“壁钟”。

三、实验代码

/*****************************************
*
* 内核的定时机制
*
* Copyright: (C) 2018.4.24 by shaomingshan
*
* Compile: gcc -g -o main_a main_a.c
*
* Execute: ./main_a
*
*****************************************/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
#include <signal.h>

static void sig_real(int);
static long real_secs = 0;
static struct itimerval realt;


int main(int argc, char *argv[])
{
    signal(SIGALRM, sig_real);
    realt.it_interval.tv_sec  = 0;
    realt.it_value.tv_sec     = 0;
    realt.it_interval.tv_usec = 999999;
    realt.it_value.tv_usec    = 999999;
    setitimer(ITIMER_REAL, &realt, NULL);

    for(;;);
    return 0;
}

static void sig_real(int non) {
    real_secs += 1;
    printf("%ld\r", real_secs);
    fflush(stdout);
}

/*****************************************
*
* 内核的定时机制
*
* Copyright: (C) 2018.4.24 by shaomingshan
*
* Compile: gcc -g -o main_b main_b.c
*
* Execute: ./main_b
*
*****************************************/
#include <sys/time.h>
#include <stdio.h>
#include <signal.h>

static void sighandle(int);
struct timeval now; 
int today;
int main(){
	struct itimerval v;
	signal(SIGALRM,sighandle);
	v.it_interval.tv_sec = 0;
	v.it_interval.tv_usec = 1;
	v.it_value.tv_sec = 0;
	v.it_value.tv_usec = 1;
	setitimer(ITIMER_REAL, &v, NULL);
	for(;;);
}
static void sighandle(int s){
	gettimeofday(&now, NULL);
	today = now.tv_sec%(3600*24);
    printf("%02d:%02d:%02d:%ld\r",today/3600+8,(today%3600)/60,(today%3600)%60,now.tv_usec);
	fflush(stdout);
}

/*****************************************
*
* 内核的定时机制
*
* Copyright: (C) 2018.4.24 by shaomingshan
*
* Compile: gcc -g -o main_c main_c.c
*
* Execute: ./main_c
*
*****************************************/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/time.h>
#include <wait.h>

// 父进程定时中断处理
static void psig_real(int);
static void psig_virtual(int);
static void psig_prof(int);

// 子进程1定时中断处理
static void c1sig_real(int);
static void c1sig_virtual(int);
static void c1sig_prof(int);

// 子进程2定时中断处理
static void c2sig_real(int);
static void c2sig_virtual(int);
static void c2sig_prof(int);

long unsigned int fibonnacci(unsigned int n);

static long p_real_secs     = 0, 
            c1_real_secs    = 0, 
            c2_real_secs    = 0,
            p_virtual_secs  = 0,
            c1_virtual_secs = 0,
            c2_virtual_secs = 0,
            p_prof_secs     = 0,
            c1_prof_secs    = 0,
            c2_prof_secs    = 0;

static struct itimerval p_realt, c1_realt, c2_realt;
static struct itimerval p_virtt, c1_virtt, c2_virtt;
static struct itimerval p_proft, c1_proft, c2_proft;

int main(int argc, char *argv[])
{
    long unsigned fib = 0;
    int pid1, pid2;
    unsigned int fibarg;
    int status;
    int i;
    
    if (argc < 3) {
        printf("Usage: testsig arg1 arg2 arg3\n");
        return 1;
    }


    pid1 = fork();
    if (pid1==0) {

        signal(SIGALRM, c1sig_real);
        signal(SIGVTALRM, c1sig_virtual);
        signal(SIGPROF, c1sig_prof);

        c1_realt.it_interval.tv_sec = 9;
        c1_realt.it_interval.tv_usec = 999999;
        c1_realt.it_value.tv_sec = 9;
        c1_realt.it_value.tv_usec = 999999;
        setitimer(ITIMER_REAL, &c1_realt, NULL);

        c1_virtt.it_interval.tv_sec = 9;
        c1_virtt.it_interval.tv_usec = 999999;
        c1_virtt.it_value.tv_sec = 9;
        c1_virtt.it_value.tv_usec = 999999;
        setitimer(ITIMER_VIRTUAL, &c1_virtt, NULL);

        c1_proft.it_interval.tv_sec = 9;
        c1_proft.it_interval.tv_usec = 999999;
        c1_proft.it_value.tv_sec = 9;
        c1_proft.it_value.tv_usec = 999999;
        setitimer(ITIMER_PROF, &c1_proft, NULL);

        fib = fibonnacci(atoi(argv[1]));

        getitimer(ITIMER_REAL, &c1_realt);
        printf("Child1 fib = %ld\nChild1 Real Time    = %2ldSec: %03ldMsec\n", 
                fib, c1_real_secs+9-c1_realt.it_value.tv_sec,
                (999999-c1_realt.it_value.tv_usec)/1000);

        getitimer(ITIMER_VIRTUAL, &c1_virtt);
        printf("Child1 Virtual Time = %2ldSec: %03ldMsec\n", 
                c1_virtual_secs+9-c1_virtt.it_value.tv_sec,
                (999999-c1_virtt.it_value.tv_usec)/1000);

        getitimer(ITIMER_PROF, &c1_proft);
        printf("Child1 Prof Time    = %2ldSec: %03ldMsec\n\n", 
                c1_prof_secs+9-c1_proft.it_value.tv_sec,
                (999999-c1_proft.it_value.tv_usec)/1000);

    } else if ((pid2=fork())==0) {

        signal(SIGALRM, c2sig_real);
        signal(SIGVTALRM, c2sig_virtual);
        signal(SIGPROF, c2sig_prof);

        c2_realt.it_interval.tv_sec = 9;
        c2_realt.it_interval.tv_usec = 999999;
        c2_realt.it_value.tv_sec = 9;
        c2_realt.it_value.tv_usec = 999999;
        setitimer(ITIMER_REAL, &c2_realt, NULL);

        c2_virtt.it_interval.tv_sec = 9;
        c2_virtt.it_interval.tv_usec = 999999;
        c2_virtt.it_value.tv_sec = 9;
        c2_virtt.it_value.tv_usec = 999999;
        setitimer(ITIMER_VIRTUAL, &c2_virtt, NULL);

        c2_proft.it_interval.tv_sec = 9;
        c2_proft.it_interval.tv_usec = 999999;
        c2_proft.it_value.tv_sec = 9;
        c2_proft.it_value.tv_usec = 999999;
        setitimer(ITIMER_PROF, &c2_proft, NULL);

        fib = fibonnacci(atoi(argv[2]));

        getitimer(ITIMER_REAL, &c2_realt);
        printf("Child2 fib = %ld\nChild2 Real Time    = %2ldSec: %03ldMsec\n", 
                fib, c2_real_secs+9-c2_realt.it_value.tv_sec,
                (999999-c2_realt.it_value.tv_usec)/1000);

        getitimer(ITIMER_VIRTUAL, &c2_virtt);
        printf("Child2 Virtual Time = %2ldSec: %03ldMsec\n", 
                c2_virtual_secs+9-c2_virtt.it_value.tv_sec,
                (999999-c2_virtt.it_value.tv_usec)/1000);

        getitimer(ITIMER_PROF, &c2_proft);
        printf("Child2 Prof Time    = %2ldSec: %03ldMsec\n\n", 
                c2_prof_secs+9-c2_proft.it_value.tv_sec,
                (999999-c2_proft.it_value.tv_usec)/1000);
    } else {

        // 父进程设置3种定时处理入口
        signal(SIGALRM, psig_real);
        signal(SIGVTALRM, psig_virtual);
        signal(SIGPROF, psig_prof);

        // 初始化父进程3种时间定时器
        p_realt.it_interval.tv_sec = 9;
        p_realt.it_interval.tv_usec = 999999;
        p_realt.it_value.tv_sec = 9;
        p_realt.it_value.tv_usec = 999999;
        setitimer(ITIMER_REAL, &p_realt, NULL);

        p_virtt.it_interval.tv_sec = 9;
        p_virtt.it_interval.tv_usec = 999999;
        p_virtt.it_value.tv_sec = 9;
        p_virtt.it_value.tv_usec = 999999;
        setitimer(ITIMER_VIRTUAL, &p_virtt, NULL);

        p_proft.it_interval.tv_sec = 9;
        p_proft.it_interval.tv_usec = 999999;
        p_proft.it_value.tv_sec = 9;
        p_proft.it_value.tv_usec = 999999;
        setitimer(ITIMER_PROF, &p_proft, NULL);

        fib = fibonnacci(atoi(argv[3]));

        getitimer(ITIMER_REAL, &p_realt);
        printf("Parent fib = %ld\nParent Real Time    = %2ldSec: %03ldMsec\n", 
                fib, p_real_secs+9-p_realt.it_value.tv_sec,
                (999999-p_realt.it_value.tv_usec)/1000);

        getitimer(ITIMER_VIRTUAL, &p_virtt);
        printf("Parent Virtual Time = %2ldSec: %03ldMsec\n", 
                p_virtual_secs+9-p_virtt.it_value.tv_sec,
                (999999-p_virtt.it_value.tv_usec)/1000);

        getitimer(ITIMER_PROF, &p_proft);
        printf("Parent Prof Time    = %2ldSec: %03ldMsec\n\n", 
                p_prof_secs+9-p_proft.it_value.tv_sec,
                (999999-p_proft.it_value.tv_usec)/1000);
        waitpid(0, &status, 0);
        waitpid(0, &status, 0);
    }
    return 0;
}

static void psig_real(int non) {
    p_real_secs += 10;
}
static void psig_virtual(int non) {
    p_virtual_secs += 10;
}
static void psig_prof(int non) {
    p_prof_secs += 10;
}
static void c1sig_real(int non) {
    c1_real_secs += 10;
}
static void c1sig_virtual(int non) {
    c1_virtual_secs += 10;
}
static void c1sig_prof(int non) {
    c1_prof_secs += 10;
}
static void c2sig_real(int non) {
    c2_real_secs += 10;
}
static void c2sig_virtual(int non) {
    c2_virtual_secs += 10;
}
static void c2sig_prof(int non) {
    c2_prof_secs += 10;
}

long unsigned int fibonnacci(unsigned int n) {
    if (n < 3) return 1;
    return fibonnacci(n-1)+fibonnacci(n-2);
}

四、运行结果

如有错误请指正