Linux内核中的jiffies及其作用介绍及jiffies等相关函数详解

Dear 丶 2022-05-30 12:45 515阅读 0赞

在LINUX的时钟中断中涉及至二个全局变量一个是xtime,它是timeval数据结构变量，另一个则是jiffies，首先看timeval结构  
struct timeval  
\{  
time\_t tv\_sec; /\*\*\*second\*\*\*/  
susecond\_t tv\_usec;/\*\*\*microsecond\*\*\*/  
\}  
到底microsecond是毫秒还是微秒？？

1秒＝1000毫秒（3个零），1秒＝1000 000微秒（6个零），1秒＝1000 000 000纳秒（9个零），1秒＝1000 000 000 000皮秒（12个零）。  
秒用s表现，毫秒用ms,微秒用us表示，纳秒用ns表示，皮秒用ps表示，他们的分级单位是千，即每次3个零。  
混淆的原因找到了，由于毫秒用ms表示，所以我老是以为microsecond是毫秒，所以就把tv\_usec理解错了。  
microsecond查词霸也是微秒的意思（microsecond！=ms，microsecond==us），看来单位的表示迷惑了我，也迷惑了大多数人，请朋友们牢记这里，非常重要。

xtime是从cmos电路中取得的时间，一般是从某一历史时刻开始到现在的时间，也就是为了取得我们操作系统上显示的日期。这个就是所谓的“实时时钟”，它的精确度是微秒。

jiffies是记录着从电脑开机到现在总共的时钟中断次数。在linux内核中jiffies远比xtime重要，那么他取决于系统的频率，单位是Hz，这里不得不说一下频率的单位，1MHz＝1000，000Hz（6个零），1KHz=1000Hz（3个零）.  
频率是周期的倒数，一般是一秒钟中断产生的次数，所以，假如我们需要知道系统的精确的时间单位时，需要换算了，假如我们系统的频率是200Mhz,那么一次中断的间隔是1秒/200,000，000Hz=0.000 000 005秒看一下上面我们的时间单位，对照一下小数点后面是9个零，所以理论上我们系统的精确度是5纳秒。LINUX系统时钟频率是一个常数HZ来决定的，通常HZ＝100，那么他的精度度就是10ms（毫秒）。也就是说每10ms一次中断。所以一般来说Linux的精确度是10毫秒。

硬件给内核提供一个系统定时器用以计算和管理时间，内核通过编程预设系统定时器的频率，即节拍率（tick rate),每一个周期称作一个tick(节拍）。Linux内核从2.5版内核开始把频率从100调高到1000，时间单位 jiffies 有多长？

"在 Linux 2.6 中，系统时钟每 1 毫秒中断一次（时钟频率，用 HZ 宏表示，定义为 1000，即每秒中断 1000 次，2.4 中定义为 100，很多应用程序也仍然沿用 100 的时钟频率），这个时间单位称为一个 jiffie。"  
"jiffies 与绝对时间之间的转换, 用两个宏来完成两种时间单位的互换：JIFFIES\_TO\_NS()、NS\_TO\_JIFFIES()"  
（当然带来了很多优点，也有一些缺点）.

硬件给内核提供一个系统定时器用以计算和管理时间，内核通过编程预设系统定时器的频率，即节拍率（tick rate),每一个周期称作一个tick(节拍）。Linux内核从2.5版内核开始把频率从100调高到1000（当然带来了很多优点，也有一些缺点）.  
jiffies是内核中的一个全局变量，用来记录自系统启动一来产生的节拍数。譬如，如果计算系统运行了多长时间，可以用 jiffies/tick rate 来计算。jiffies定义在文件<linux/jiffies.h>中：

extern unsigned long volatile jiffies;

可以利用jiffies设置超时等，譬如：

unsigned long timeout = jiffies + tick\_rate \* 2; // 2秒钟后超时

if(time\_before(jiffies, timeout)\{  
// 还没有超时

\}  
else\{  
// 已经超时

内核提供了四个宏来比较节拍计数，这些宏定义在文件<linux/jiffies.h>中：

time\_before(unknown, known)  
time\_after(unknown, known)  
time\_before\_eq(unknown, known)  
time\_after\_eq(unknown, known)

比较的时候用这些宏可以避免jiffies由于过大造成的回绕问题。

除了系统定时器外，还有一个与时间有关的时钟：实时时钟（RTC），这是一个硬件时钟，用来持久存放系统时间，系统关闭后靠主板上的微型电池保持计时。系统启动时，内核通过读取RTC来初始化Wall Time,并存放在xtime变量中，这是RTC最主要的作用。

///网络相关函数内容详解//

1.linux HZ

Linux核心几个重要跟时间有关的名词或变数，以下将介绍HZ、tick与jiffies。

Linux核心每隔固定周期会发出timer interrupt (IRQ 0)，HZ是用来定义每一秒有几次timer interrupts。举例来说，HZ为1000，代表每秒有1000次timer interrupts。 HZ可在编译核心时设定，如下所示(以核心版本2.6.20-15为例)：

adrian@adrian-desktop:~$ cd /usr/src/linux

adrian@adrian-desktop:/usr/src/linux$ make menuconfig

Processor type and features ---> Timer frequency (250 HZ) --->

其中HZ可设定100、250、300或1000。

小实验

观察/proc/interrupt的timer中断次数，并于一秒后再次观察其值。理论上，两者应该相差250左右。

adrian@adrian-desktop:~$ cat /proc/interrupts | grep timer && sleep 1 && cat /proc/interrupts | grep timer

0: 9309306 IO-APIC-edge timer

0: 9309562 IO-APIC-edge timer

上面四个栏位分别为中断号码、CPU中断次数、PIC与装置名称。

要检查系统上HZ的值是什么，就执行命令

cat kernel/.config | grep '^CONFIG\_HZ='

2.Tick

Tick是HZ的倒数，意即timer interrupt每发生一次中断的时间。如HZ为250时，tick为4毫秒(millisecond)。

3.Jiffies

Jiffies为Linux核心变数(unsigned long)，它被用来记录系统自开机以来，已经过了多少tick。每发生一次timer interrupt，Jiffies变数会被加一。值得注意的是，Jiffies于系统开机时，并非初始化成零，而是被设为-300\*HZ (arch/i386/kernel/time.c)，即代表系统于开机五分钟后，jiffies便会溢位。那溢位怎么办?事实上，Linux核心定义几个macro(timer\_after、time\_after\_eq、time\_before与time\_before\_eq)，即便是溢位，也能借由这几个macro正确地取得jiffies的内容。

另外，80x86架构定义一个与jiffies相关的变数jiffies\_64 ，此变数64位元，要等到此变数溢位可能要好几百万年。因此要等到溢位这刻发生应该很难吧。

3.1 jiffies及其溢出

全局变量jiffies取值为自操作系统启动以来的时钟滴答的数目，在头文件<linux/sched.h>中定义，数据类型为unsigned long volatile (32位无符号长整型)。

jiffies转换为秒可采用公式：(jiffies/HZ)计算，

将秒转换为jiffies可采用公式：(seconds\*HZ)计算。

当时钟中断发生时，jiffies 值就加1。因此连续累加一年又四个多月后就会溢出(假定HZ=100，1个jiffies等于1/100秒，jiffies可记录的最大秒数为 (2^32 -1)/100=42949672.95秒，约合497天或1.38年)，即当取值到达最大值时继续加1，就变为了0。

3.4 Linux内核如何来防止jiffies溢出

Linux内核中提供了以下四个宏，可有效解决由于jiffies溢出而造成程序逻辑出错的情况。下面是从Linux Kernel 2.6.7版本中摘取出来的代码：

/\*

\* These inlines deal with timer wrapping correctly. You are

\* strongly encouraged to use them

\* 1. Because people otherwise forget

\* 2. Because if the timer wrap changes in future you won't have to

\* alter your driver code.

\* time\_after(a,b) returns true if the time a is after time b.

\* Do this with "<0" and ">=0" to only test the sign of the result. A

\* good compiler would generate better code (and a really good compiler

\* wouldn't care). Gcc is currently neither.

\*/

\#define time\_after(a,b) \\

(typecheck(unsigned long, a) && \\

typecheck(unsigned long, b) && \\

((long)(b) - (long)(a) < 0))

\#define time\_before(a,b) time\_after(b,a)

\#define time\_after\_eq(a,b) \\

(typecheck(unsigned long, a) && \\

typecheck(unsigned long, b) && \\

((long)(a) - (long)(b) >= 0))

\#define time\_before\_eq(a,b) time\_after\_eq(b,a)

在宏time\_after中，首先确保两个输入参数a和b的数据类型为unsigned long，然后才执行实际的比较。

8. 结论

系统中采用jiffies来计算时间，但由于jiffies溢出可能造成时间比较的错误，因而强烈建议在编码中使用 time\_after等宏来比较时间先后关系，这些宏可以放心使用。

内核时钟：

内核使用硬件提供的不同时钟来提供依赖于时间的服务，如busy-waiting（浪费CPU周期）和sleep-waiting（放弃CPU）

5.HZ and Jiffies

jiffies记录了系统启动后的滴答数，常用的函数：time\_before()、 time\_after()、time\_after\_eq()、time\_before\_eq()。因为jiffies随时钟滴答变化，不能用编译器优化它，应取volatile值。

32位jiffies变量会在50天后溢出，太小，因此内核提供变量jiffies\_64来hold 64位jiffies。该64位的低32位即为jiffies，在32位机上需要两天指令来赋值64位数据，不是原子的，因此内核提供函数 get\_jiffies\_64()。

6.Long Delays

busy-wait：timebefore(),使CPU忙等待；sleep-wait：shedule\_timeout(截至时间)；无论在内核空间还是用户空间，都没有比HZ更精确的控制了，因为时间片都是根据滴答更新的，而且即使定义了您的进程在超过指定时间后运行，调度器也可能根据优先级选择其他进程执行。

sleep-wait()：wait\_event\_timeout()用于在满足某个条件或超时后重新执行，msleep()睡眠指定的ms后重新进入就绪队列，这些长延迟仅适用于进程上下文，在中断上下文中不能睡眠也不能长时间busy-waiting。

内核提供了timer API来在一定时间后执行某个函数：

\#include <linux/timer.h>

struct timer\_list my\_timer;

init\_timer(&my\_timer); /\* Also see setup\_timer() \*/

my\_timer.expire = jiffies + n\*HZ; /\* n is the timeout in number of seconds \*/

my\_timer.function = timer\_func; /\* Function to execute

after n seconds \*/

my\_timer.data = func\_parameter; /\* Parameter to be passed to timer\_func \*/

add\_timer(&my\_timer); /\*Start the timer\*/

如果您想周期性执行上述代码，那么把它们加入timer\_func()函数。您使用mod\_timer()来改变my\_timer的超时值，del\_timer()来删掉my\_timer，用timer\_pending()查看是否my\_timer处于挂起状态。

用户空间函数clock\_settime()和clock\_gettime()用于获取内核时钟服务。用户应用程序使用setitimer()和getitimer()来控制alarm信号的传递当指定超时发生后。

8.Real Time Clock

RTC时钟track绝对时间。RTC电池常超过computer生存期。可以用RTC完成以下功能：（1）读或设置绝对时钟，并在clock updates时产生中断；（2）以2HZ到8192HZ来产生周期性中断；（3）设置alarms。

jiffies仅是相对于系统启动的相对时间，如果想获取absolute time或wall time，则需要使用RTC，内核用变量xtime来记录，当系统启动时，读取RTC并记录在xtime中，当系统halt时，则将wall time写回RTC，函数do\_gettimeofday()来读取wall time。

\#include <linux/time.h>

static struct timeval curr\_time;

do\_gettimeofday(&curr\_time);

my\_timestamp = cpu\_to\_le32(curr\_time.tv\_sec); /\* Record timestamp \*/

用户空间获取wall time的函数：time()返回calendar time或从00：00：00 on January 1，1970的秒数；（2）localtime()：返回calendar time in broken-down format；（3）mktime()：与 localtime()相反；（4）gettimeofday()以microsecond 精确度返回calendar时间。

另外一个获取RTC的方法是通过字符设备/dev/rtc，一个时刻仅允许一个处理器访问它。

9.时钟和定时器

时钟和定时器对Linux内核来说十分重要。首先，内核要管理系统的运行时间(uptime)和当前墙上时间(wall time)， 即当前实际时间。其次，内核中大量的活动由时间驱动。

9.1实时时钟

内核必须借助硬件来实现时间管理。实时时钟是用来持久存放系统时间的设备，它通过主板电池供电，所以即便在关闭计算机系统之后，实时时钟仍然能继续工作。

系统启动时，内核读取实时时钟，将所读的时间存放在变量xtime中作为墙上时间(wall time)，xtime保存着从1970年1月1日0:00到当前时刻所经历的秒数。虽然在Intel x86机器上，内核会周期性地将当前时间存回实时时钟中，但应该明确，实时时钟的主要作用就是在启动时初始化墙上时间xtime。

9.2系统定时器与动态定时器

周期性发生的事件都是由系统定时器驱动。在X86体系结构上，系统定时器通常是一种可编程硬件芯片，其产生的中断就是时钟中断。时钟中断对应的处理程序负责更新系统时间和执行周期性运行的任务。系统定时器的频率称为节拍率(tick rate)，在内核中表示为HZ。

以X86为例，在2.4之前的内核中其大小为100； 从内核2.6开始，HZ = 1000， 也就是说每秒时钟中断发生1000次。这一变化使得系统定时器的精度(resolution)由10ms提高到1ms，这大大提高了系统对于时间驱动事件调度的精确性。过于频繁的时钟中断不可避免地增加了系统开销。

与系统定时器相对的是动态定时器，它是调度事件(执行调度程序)在未来某个时刻发生的时机。内核可以动态地创建或销毁动态定时器。

系统定时器及其中断处理程序是内核管理机制的中枢，下面是一些利用系统定时器周期执行的工作(中断处理程序所做的工作):

(1) 更新系统运行时间(uptime)

(2) 更新当前墙上时间(wall time)

(3) 在对称多处理器系统(SMP)上，均衡调度各处理器上的运行队列

(4) 检查当前进程是否用完了时间片(time slice)，如果用尽，则进行重新调度

(5) 运行超时的动态定时器

(6) 更新资源耗尽和处理器时间的统计值

内核动态定时器依赖于系统时钟中断，因为只有在系统时钟中断发生后内核才会去检查当前是否有超时的动态定时器。

\---------------------------------------------------------

X86体系结构中，内核2.6.X的HZ = 1000， 即系统时钟中断执行粒度为1ms，这意味着系统中周期事情最快为1ms执行一次，而不可能有更高的精度。动态定时器随时都可能超时，但由于只有在系统时钟中断到来时内核才会检查执行超时的动态定时器，所以动态定时器的平均误差大约为半个系统时钟周期(即0.5ms).

http://blog.csdn.net/allen6268198/article/details/7270194