Linux内核延时研究与函数代码分析

jiffies 以前提过，但是用来计算函数调用的时间确实显得粒度太大（一个 jiffies = 1ms or 4ms ）

gettimeofday （用户态）和do_gettimeofday(内核态）用下来感觉不错。粒度可以达到us级别。

试验过一个while 循环

unsigned long i =0xffffffff; while(i--);

按代码来讲，这个时间应该不算短，测出来的时间却是0. 估计是代码优化了。

加个volatile :

volatile unsigned long i=0xffffffff; while(i--);

跑了半天才跑出来。。。

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

Linux内核延时研究与函数代码分析

 

 

有时驱动程序需要非常短的延迟来与硬件同步。此时，使用jiffies值无法达到目的。这时就要用内核函数udelay和mdelay。u表示希腊字母“mu”（m），它代表“微”。它们的原型如下：

#include <Linux/delay.h>

void udelay(unsigned long usecs); //软件循环延迟指定数目的微秒数

void mdelay(unsigned long msecs); //使用 udelay 做循环

该函数在绝大多数体系结构上是作为内联函数编译的。udelay函数里要用到BogoMips值：它的循环基于整数值loops_per_second，这个值是在引导阶段计算BogoMips时得到的结果。

udelay函数只能用于获取较短的时间延迟，因为loops_per_second值的精度只有8位，所以，当计算更长的延迟时会积累出相当大的误差。尽管最大能允许的延迟将近1s（因为更长的延迟就要溢出），推荐的udelay函数参数最大值是取1000us（1ms）。当延迟大于11ms时可以使用函数mdelay。许多驱动程序需要将任务延迟到以后处理，但又不想借助中断。Linux为此提供了三种方法：任务队列、tasklet和内核定时器。

要特别注意的是udelay是个忙等待函数，在延迟的时间段内无法运行其他的任务。源码见头文件<asm/delay.h>。

 

目前内核不支持大于1微秒而小于1个时钟滴答的延迟，但这不是个问题，因为延迟是给硬件或者人去识别的。百分之一秒的时间间隔对人来说延迟精度足够了，而1毫秒对硬件来说延迟时间也足够长。如果你真的需要其间的延迟间隔，你只要建立一个连续执行udelay(1000)函数的循环。

linux内核延时函数代码示例： 

1、#include <linux/time.h>

void do_gettimeofday(struct timeval *tv)

{

 unsigned long flags;

 unsigned long usec, sec;

 read_lock_irqsave(&xtime_lock, flags);

 sec = xtime.tv_sec;

 usec = xtime.tv_usec + do_gettimeoffset();

 read_unlock_irqrestore(&xtime_lock, flags);

 while (usec >= 1000000) {

  usec -= 1000000;

  sec++;

 }

 tv->tv_sec = sec;

 tv->tv_usec = usec;

}

void MyDelay(unsigned long delay)

{

 struct timeval tv;

 do_gettimeofday(&tv)

 unsigned long start = tv.tv_usec;//unsigned long start = tv.tv_sec;

 while(tv.tv_usec - start <delay)

    do_gettimeofday(&tv)

}

2、如果驱动程序使用等待队列等待某个事件，而你又想确保在一段时间后运行该驱动程序时

extern inline long sleep_on_timeout(wait_queue_head_t *q, signed long timeout)

{

    signed long early = 0;

       

    current->timeout = jiffies + timeout;

    sleep_on (q);

    if (current->timeout > 0) {

        early = current->timeout - jiffies;

        current->timeout = 0;

    }

    return early;

}

extern inline long interruptible_sleep_on_timeout(wait_queue_head_t *q,

                signed long timeout)

{

    signed long early = 0;

       

    current->timeout = jiffies + timeout;

    interruptible_sleep_on (q);

    if (current->timeout > 0) {

        early = current->timeout - jiffies;

        current->timeout = 0;

    }

    return early;

}

3.无需等待其他事件，则可直接延时等待

extern inline void schedule_timeout(int timeout)

{

    current->timeout = jiffies + timeout;

    current->state = TASK_INTERRUPTIBLE;

    schedule();

    current->timeout = 0;

}

set_current_state(TASK_INTERRUPTIBLE);

schedule_timeout(jit_delay*HZ);

4 非常短的延时与硬件同步 udelay推荐最大1000us

#include<linux/delay.h>

void __delay(int loops)

{

 long long dummy;

 __asm__ __volatile__("gettr " __t0 ", %1/n/t"

        "_pta 4, " __t0 "/n/t"

        "addi %0, -1, %0/n/t"

        "bne %0, r63, " __t0 "/n/t"

        "ptabs %1, " __t0 "/n/t":"=r"(loops),

        "=r"(dummy)

        :"0"(loops));

}

void __udelay(unsigned long long usecs, unsigned long lpj)

{

 usecs *= (((unsigned long long) HZ << 32) / 1000000) * lpj;

 __delay((long long) usecs >> 32);

}

#ifdef notdef

#define mdelay(n) (/

 {unsigned long msec=(n); while (msec--) udelay(1000);})

#else

#define mdelay(n) (/

 (__builtin_constant_p(n) && (n)<=MAX_UDELAY_MS) ? udelay((n)*1000) : /

 ({unsigned long msec=(n); while (msec--) udelay(1000);}))

#endif