不同系统执行上clock_getres为什么有如此大的差异

jinxinxin163

[root@localhost ttimer]# cat time.c
#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 != (clockid_t) -1;i++)  
     {  
         struct timespec res;  
         int ret;  
         ret = clock_getres(clocks,&res);  
         if(ret)  
             perror("clock_getres");  
         else  
             printf("clock = [%d],sec = [%ld],nsec = [%ld]\n",clocks,res.tv_sec,res.tv_nsec);  
     }  
     return 1;  
}  
同样的代码，在不同的系统上执行结果完全不同：
我的pc机：
Linux localhost.localdomain 2.6.29.4-167.fc11.i686.PAE #1 SMP Wed May 27 17:28:22 EDT 2009 i686 i686 i386 GNU/Linux
执行结果：
clock = [0],sec = [0],nsec = [1]
clock = [1],sec = [0],nsec = [1]
clock = [2],sec = [0],nsec = [1]
clock = [3],sec = [0],nsec = [1]
我的开发版上的系统：
2.6.25.8-rt7 #133 PREEMPT RT Thu Nov 5 22:44:34 CST 2009 armv4tl unknown
执行结果：
/var/other1> ./time
clock = [0],sec = [0],nsec = [1250000]
clock = [1],sec = [0],nsec = [1250000]
clock = [2],sec = [0],nsec = [1]
clock   [3],sec = [0],nsec = [1]
看起来，好像在我的开发版上的执行结果比较合理，CLOCK_REALTIME描述的是我系统时钟周期的间隔，但在pc机上的执行结果是什么意思呢？
还有这跟我的系统硬件有关系么？
请大家多多指教哈

openspace

问一下LZ执行上面的程序要用到什么库吗？
我想试一下，可是系统说没有找到clock_getres

另搜了一篇说明，不知道有没有用：
http://www.opengroup.org/onlinep ... /clock_gettime.html

openspace

我似乎要将代码改一下才能运行：

1. 
   
2. #include <stdio.h>  
   
3. #include <time.h>  
   
4.    
   
5. int main()  
   
6. {  
   
7.         clockid_t clocks[]= {  
   
8.                         CLOCK_REALTIME,  
   
9.                         CLOCK_MONOTONIC,  
   
10.                         CLOCK_PROCESS_CPUTIME_ID,  
    
11.                         CLOCK_THREAD_CPUTIME_ID,  
    
12.                         (clockid_t) -1,  
    
13.         };  
    
14.    
    
15.         int i;  
    
16.         for(i = 0; clocks[i] != (clockid_t) -1; i++) {  
    
17.                 struct timespec res;  
    
18.                 int ret;  
    
19.                 ret = clock_getres(clocks[i], &res);  
    
20.                 if (ret)  
    
21.                         perror("clock_getres");  
    
22.                 else
    
23.                         printf("clock = [%d],sec = [%ld],nsec = [%ld]\n",
    
24.                                         i, res.tv_sec, res.tv_nsec);  
    
25.         }  
    
26.      
    
27.         return 0;  
    
28. }  
    

复制代码

我跑了一下, PC机上跟LZ类似
结果如下：

1. 
   
2. **********:~$ gcc -lrt time.c -o time
   
3. **********:~$ ./time
   
4. clock = [0],sec = [0],nsec = [1]
   
5. clock = [1],sec = [0],nsec = [1]
   
6. clock = [2],sec = [0],nsec = [1]
   
7. clock = [3],sec = [0],nsec = [1]
   
8. **********:~$ uname -a
   
9. Linux openspace 2.6.26-1-686 #1 SMP Sat Jan 10 18:29:31 UTC 2009 i686 GNU/Linux
   
10. 
    

复制代码

openspace

http://www.javaeye.com/topic/309744
这样看PC系统时钟频率为1GHz

PS：刚从lxr.linux.no上搜了一下
       sys_clock_getres到2.6.28内核中还有定义，在kernel/posix-timers.c
       从2.6.28.1开始就找不到定义了
       具体在哪也找不到，严重怀疑只剩一个空壳了，所以返回都是1
       要不LZ装个早版本的内核，试试PC上的运行情况

openspace

刚看了一下，简单理清了思路，希望对LZ有用

让我们先来看一下clock_getres的实现

1. 
   
2. 2.6.31/kernel/posix-timers.c
   
3. 
   
4. 这里有两种方式，一直是common_clock_getres，直接访问posix_clocks[which_clock].res；另一种是使用
   
5. 939行定义的函数，其间接调用了posix_clocks[clock].clock_getres
   
6. 
   
7. ……
   
8. 134static struct k_clock posix_clocks[MAX_CLOCKS];
   
9. ……
   
10. 158#define CLOCK_DISPATCH(clock, call, arglist) \
    
11. 159        ((clock) < 0 ? posix_cpu_##call arglist : \
    
12. 160         (posix_clocks[clock].call != NULL \
    
13. 161          ? (*posix_clocks[clock].call) arglist : common_##call arglist))
    
14. ……
    
15. 171static inline int common_clock_getres(const clockid_t which_clock,
    
16. 172                                      struct timespec *tp)
    
17. 173{
    
18. 174        tp->tv_sec = 0;
    
19. 175        tp->tv_nsec = posix_clocks[which_clock].res;
    
20. 176        return 0;
    
21. 177}
    
22. ……
    
23. 939SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
    
24. 940                struct timespec __user *, tp)
    
25. 941{
    
26. 942        struct timespec rtn_tp;
    
27. 943        int error;
    
28. 944
    
29. 945        if (invalid_clockid(which_clock))
    
30. 946                return -EINVAL;
    
31. 947
    
32. 948        error = CLOCK_DISPATCH(which_clock, clock_getres,
    
33. 949                               (which_clock, &rtn_tp));
    
34. 950
    
35. 951        if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp))) {
    
36. 952                error = -EFAULT;
    
37. 953        }
    
38. 954
    
39. 955        return error;
    
40. 956}
    

复制代码

走到这里，目标都集中到posix_clocks上。来看一下posix_clocks的定义

1. 
   
2. 2.6.31/kernel/posix-timers.c
   
3. 
   
4. 134static struct k_clock posix_clocks[MAX_CLOCKS];
   
5.   
   
6. 2.6.31/include/linux/posix-timers.h
   
7. 
   
8.   69struct k_clock {
   
9.   70        int res;                /* in nanoseconds */
   
10.   71        int (*clock_getres) (const clockid_t which_clock, struct timespec *tp);
    
11.   72        int (*clock_set) (const clockid_t which_clock, struct timespec * tp);
    
12.   73        int (*clock_get) (const clockid_t which_clock, struct timespec * tp);
    
13.   74        int (*timer_create) (struct k_itimer *timer);
    
14.   75        int (*nsleep) (const clockid_t which_clock, int flags,
    
15.   76                       struct timespec *, struct timespec __user *);
    
16.   77        long (*nsleep_restart) (struct restart_block *restart_block);
    
17.   78        int (*timer_set) (struct k_itimer * timr, int flags,
    
18.   79                          struct itimerspec * new_setting,
    
19.   80                          struct itimerspec * old_setting);
    
20.   81        int (*timer_del) (struct k_itimer * timr);
    
21.   82#define TIMER_RETRY 1
    
22.   83        void (*timer_get) (struct k_itimer * timr,
    
23.   84                           struct itimerspec * cur_setting);
    
24.   85};
    

复制代码

接下来我们看一下posix_clocks的初始化

1. 
   
2. 2.6.31/kernel/posix-timers.c
   
3. 
   
4. 245/*
   
5. 246 * Initialize everything, well, just everything in Posix clocks/timers ;)
   
6. 247 */
   
7. 248static __init int init_posix_timers(void)
   
8. 249{
   
9. 250        struct k_clock clock_realtime = {
   
10. 251                .clock_getres = hrtimer_get_res,
    
11. 252        };
    
12. 253        struct k_clock clock_monotonic = {
    
13. 254                .clock_getres = hrtimer_get_res,
    
14. 255                .clock_get = posix_ktime_get_ts,
    
15. 256                .clock_set = do_posix_clock_nosettime,
    
16. 257        };
    
17. 258        struct k_clock clock_monotonic_raw = {
    
18. 259                .clock_getres = hrtimer_get_res,
    
19. 260                .clock_get = posix_get_monotonic_raw,
    
20. 261                .clock_set = do_posix_clock_nosettime,
    
21. 262                .timer_create = no_timer_create,
    
22. 263                .nsleep = no_nsleep,
    
23. 264        };
    
24. 265
    
25. 266        register_posix_clock(CLOCK_REALTIME, &clock_realtime);
    
26. 267        register_posix_clock(CLOCK_MONOTONIC, &clock_monotonic);
    
27. 268        register_posix_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);
    
28. 269
    
29. 270        posix_timers_cache = kmem_cache_create("posix_timers_cache",
    
30. 271                                        sizeof (struct k_itimer), 0, SLAB_PANIC,
    
31. 272                                        NULL);
    
32. 273        idr_init(&posix_timers_id);
    
33. 274        return 0;
    
34. 275}
    
35. 276
    
36. 277__initcall(init_posix_timers);
    

复制代码

看到CLOCK_REALTIME和CLOCK_MONOTONIC了没，是不是感觉很熟悉。可以看到，要获取精度，都会调用hrtimer_get_res，这 就可以解释为什么CLOCK_REALTIME和CLOCK_MONOTONIC的输出相同了

我们跟踪一下hrtimer_get_res的实现

1. 
   
2. 2.6.31/kernel/hrtimer.c
   
3. 
   
4. 1189int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp)
   
5. 1190{
   
6. 1191        struct hrtimer_cpu_base *cpu_base;
   
7. 1192
   
8. 1193        cpu_base = &__raw_get_cpu_var(hrtimer_bases);
   
9. 1194        *tp = ktime_to_timespec(cpu_base->clock_base[which_clock].resolution);
   
10. 1195
    
11. 1196        return 0;
    
12. 1197}
    
13. 1198EXPORT_SYMBOL_GPL(hrtimer_get_res);
    

复制代码

目标成了hrtimer_bases和hrtimer_cpu_base了，这里可以猜出hrtimer_bases是一个Per CPU变量，用于记录每个CPU的
hrtimer_cpu_base，这里先关注hrtimer_cpu_base

1. 
   
2. 2.6.31/include/linux/hrtimer.h
   
3. 
   
4. 172struct hrtimer_cpu_base {
   
5. 173        spinlock_t                      lock;
   
6. 174        struct hrtimer_clock_base       clock_base[HRTIMER_MAX_CLOCK_BASES];
   
7. 175#ifdef CONFIG_HIGH_RES_TIMERS
   
8. 176        ktime_t                         expires_next;
   
9. 177        int                             hres_active;
   
10. 178        unsigned long                   nr_events;
    
11. 179#endif
    
12. 180};
    

复制代码

目标转为hrtimer_cpu_base，看看它如何设置clock_base。先看一下struct hrtimer_clock_base的定义

1. 
   
2. 2.6.31/include/linux/hrtimer.h
   
3. 
   
4. 131/**
   
5. 132 * struct hrtimer_clock_base - the timer base for a specific clock
   
6. 133 * @cpu_base:           per cpu clock base
   
7. 134 * @index:              clock type index for per_cpu support when moving a
   
8. 135 *                      timer to a base on another cpu.
   
9. 136 * @active:             red black tree root node for the active timers
   
10. 137 * @first:              pointer to the timer node which expires first
    
11. 138 * @resolution:         the resolution of the clock, in nanoseconds
    
12. 139 * @get_time:           function to retrieve the current time of the clock
    
13. 140 * @softirq_time:       the time when running the hrtimer queue in the softirq
    
14. 141 * @offset:             offset of this clock to the monotonic base
    
15. 142 */
    
16. 143struct hrtimer_clock_base {
    
17. 144        struct hrtimer_cpu_base *cpu_base;
    
18. 145        clockid_t               index;
    
19. 146        struct rb_root          active;
    
20. 147        struct rb_node          *first;
    
21. 148        ktime_t                 resolution;
    
22. 149        ktime_t                 (*get_time)(void);
    
23. 150        ktime_t                 softirq_time;
    
24. 151#ifdef CONFIG_HIGH_RES_TIMERS
    
25. 152        ktime_t                 offset;
    
26. 153#endif
    
27. 154};
    

复制代码

看来最后的目标是查看hrtimer_clock_base的设置和初始化化了

1. 
   
2.   91DEFINE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases) =
   
3.   92{
   
4.   93
   
5.   94        .clock_base =
   
6.   95        {
   
7.   96                {
   
8.   97                        .index = CLOCK_REALTIME,
   
9.   98                        .get_time = &ktime_get_real,
   
10.   99                        .resolution = KTIME_LOW_RES,
    
11. 100                },
    
12. 101                {
    
13. 102                        .index = CLOCK_MONOTONIC,
    
14. 103                        .get_time = &ktime_get,
    
15. 104                        .resolution = KTIME_LOW_RES,
    
16. 105                },
    
17. 106        }
    
18. 107};
    

复制代码

跟踪一下KTIME_LOW_RES的定义

1. 
   
2. 2.6.31/include/linux/ktime.h
   
3. 
   
4. 321#define LOW_RES_NSEC            TICK_NSEC
   
5. 322#define KTIME_LOW_RES           (ktime_t){ .tv64 = LOW_RES_NSEC }
   
6. 
   
7.   2.6.31/include/linux/jiffies.h
   
8.   42/* LATCH is used in the interval timer and ftape setup. */
   
9.   43#define LATCH  ((CLOCK_TICK_RATE + HZ/2) / HZ)  /* For divider */
   
10.   44
    
11.   45/* Suppose we want to devide two numbers NOM and DEN: NOM/DEN, then we can
    
12.   46 * improve accuracy by shifting LSH bits, hence calculating:
    
13.   47 *     (NOM << LSH) / DEN
    
14.   48 * This however means trouble for large NOM, because (NOM << LSH) may no
    
15.   49 * longer fit in 32 bits. The following way of calculating this gives us
    
16.   50 * some slack, under the following conditions:
    
17.   51 *   - (NOM / DEN) fits in (32 - LSH) bits.
    
18.   52 *   - (NOM % DEN) fits in (32 - LSH) bits.
    
19.   53 */
    
20.   54#define SH_DIV(NOM,DEN,LSH) (   (((NOM) / (DEN)) << (LSH))              \
    
21.   55                             + ((((NOM) % (DEN)) << (LSH)) + (DEN) / 2) / (DEN))
    
22.   56
    
23.   57/* HZ is the requested value. ACTHZ is actual HZ ("<< 8" is for accuracy) */
    
24.   58#define ACTHZ (SH_DIV (CLOCK_TICK_RATE, LATCH, 8))
    
25.   59
    
26.   60/* TICK_NSEC is the time between ticks in nsec assuming real ACTHZ */
    
27.   61#define TICK_NSEC (SH_DIV (1000000UL * 1000, ACTHZ, 8))
    

复制代码

看看HZ的值是多少

1. 
   
2. 2.6.31/arch/x86/include/asm/param.h
   
3. 
   
4.   10#ifndef HZ
   
5.   11#define HZ 100
   
6.   12#endif
   
7. 
   
8. 2.6.31/arch/ia64/include/asm/param.h
   
9. 
   
10.   30# define HZ 1024
    
11. 
    
12. 2.6.31/arch/arm/include/asm/param.h
    
13. 
    
14.   13#ifdef __KERNEL__
    
15.   14# define HZ             CONFIG_HZ       /* Internal kernel timer frequency */
    
16.   15# define USER_HZ        100             /* User interfaces are in "ticks" */
    
17.   16# define CLOCKS_PER_SEC (USER_HZ)       /* like times() */
    
18.   17#else
    
19.   18# define HZ             100
    
20.   19#endif
    
21.   20
    

复制代码

====================================================================
整理的有些乱，自己对这块也不熟悉。给LZ提供一个思路吧
一路看多来，感觉还是跟系统硬件有关系的，终归编译内核时候的配置选项会根据硬件来做，HZ就会有变化了
另外 KTIME_LOW_RES仅仅是初始化值，具体在后面运行中是否会发生变化也不一定，这样可能通过系统调用得到的
值与单纯自己根据这个流程得到的值会不一样
还有一点，配置不同也会影响初始化时调用的函数，我这里没有细看，LZ可以自己看看不同配置会有什么影响
LZ可以自己看看/kernel/hrtimer.c文件

[ 本帖最后由 openspace 于 2009-11-6 16:22 编辑 ]