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