linux 定时器原理
内核定时器：
unsigned long timeout = jiffies + (x * HZ);
while(1) {
// Check the condition.
// Take a schedule.
if (time_after(jiffies, timeout)) {
printk("Timeout\n");
break;
}
}
转换到秒：
s = (jiffies - last_jiffies)/HZ;
jiffies（约50天溢出）为jiffies_64的后32位，因此直接读取jiffies_64不具备原子性，使用get_jiffies_64，
函数原理：[平台为32位则需要保护读取，否则直接读取]
顺序锁： 读读/读写并发，写写互斥
读写自旋锁: 读读并发，读写/写写互斥
自旋锁： 不允许任何操作并发
u64 get_jiffies_64(void)
{
unsigned long seq;
u64 ret;
do {
seq = read_seqbegin(&xtime_lock);
ret = jiffies_64;
} while (read_seqretry(&xtime_lock, seq)); // 若读的过程中发生写，则重读
return ret;
}
这里涉及一个顺序锁的读写规则：
读不会更改lock的seq,写会++,这里就会发现到值被写覆盖，于是重新读。
write_seqlock(&lock);
...... //写操作代码
write_sequnlock(&lock);
顺序锁的使用场景是必须默认保持写互斥后，才能使用顺序锁.
睡眠延时：
这种睡眠再调度的精度要低于jiffies的精度：
schedule_timeout(xx);
函数原理：
expire = timeout + jiffies; // 超时截至时间
setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
__mod_timer(&timer, expire, false, TIMER_NOT_PINNED);
schedule();
del_singleshot_timer_sync(&timer);
destroy_timer_on_stack(&timer);
timeout = expire - jiffies;
out:
return timeout < 0 ? 0 : timeout;
从这里看出，这个函数实际上是基于timer来实现的
标准的延时调度接口 timer_list:[如果需要循环调度，则在timer_func中递归init/add]
struct timer_list my_timer;
init_timer(&my_timer);
my_timer.expire = jiffies + n*HZ;
my_timer.function = timer_func;
my_timer.data = func_parameter;
add_timer(&my_timer);
短延时（基于指令级忙等，不基于jiffy机制的方法）：
mdelay/udelay/ndelay
基于一个全局的变量：loops_per_jiffy，变量初始化位于：
calibrate_delay()
基本原理是，先从4096 以*2的倍数找到第一个范围 4096*x < t < 4096*2x
然后逐渐开始细化，从4096*x 开始，逐渐递增4096*x>>2(而不是减半),直到到达对应的精度要求
10000000
11000000
10100000
....
static inline void __udelay(unsigned long usecs)
{
unsigned long loops_per_usec;
loops_per_usec = (loops_per_jiffy * HZ) / 1000000; //一秒中能够执行的指令数目/1000000（ms）
__delay(usecs * loops_per_usec); //Delay 几毫秒的可以执行的指令
}
注：rdtsc这个指令是得到CPU自启动以后的运行周期，不适合超线程和多核CPU
墙上时钟：RTC
static struct timeval curr_time;
do_gettimeofday(&curr_time);
timer_list原理:
初始化timer时，首先取一个cpu变量【timer在哪个cpu注册，就在哪个cpu触发】
作为本cpu上所有timer的控制结构，根据超时程度将timers进行分级管理，其中base->timer_jiffies为最短的那个计时器的时间:
0 - 1<<8 tv1 index = expires
- 1<<(8+6) tv2 index = expires >> 8()
- 1<<(8+2*6) tv3 index = expires >> 8+6()
- 1<<(8+3*6) tv4 index = expires >> 8+2*6()
... tv5 [不是直接根据索引来决定在数组的地方，因为数组的地方是有限的]
在tv2中，需要把 2^8 - 2^14之间的timers均匀放到一个2^6的数组中，只能2^8对齐，每个数组链中最多放置2^8个timers.
往后类推..
tv1
1 2 3 4 5 6 .... vec
a1 b1 c1 d1 e1 f1
a2 b2 c2
a3 c3
a4
最后一步，添加timer到目标队列的尾部.
timer_list执行调度:
初始化：init_timers_cpu，主要是分配cpu变量，（除了启动cpu0是固定的静态空间），后再初始化tv1-tv5所有的timer header.
调用：这里从时钟irq中开始执行，增加jiffies.
run_timer_softirq(timer.c)
-> __run_timers
在函数update_process_times调用run_local_timers后触发软中断：
raise_softirq(TIMER_SOFTIRQ);
遍历过程：
static inline void __run_timers(struct tvec_base *base)
{
struct timer_list *timer;
spin_lock_irq(&base->lock);
while (time_after_eq(jiffies, base->timer_jiffies)) { //遍历所有超时的列表
struct list_head work_list;
struct list_head *head = &work_list;
int index = base->timer_jiffies & TVR_MASK; //取其索引
if (!index &&(!cascade(base, &base->tv2, INDEX(0))) &&(!cascade(base, &base->tv3, INDEX(1))) &&!cascade(base, &base->tv4, INDEX(2)))
cascade(base, &base->tv5, INDEX(3));
++base->timer_jiffies; //下一个处理的列表
list_replace_init(base->tv1.vec + index, &work_list); //清空这个列表，并处理
while (!list_empty(head)) { //遍历这个列表下的所有timer
void (*fn)(unsigned long);
unsigned long data;
bool irqsafe;
timer = list_first_entry(head, struct timer_list,entry);//取出timer
fn = timer->function;
data = timer->data;
irqsafe = tbase_get_irqsafe(timer->base);
timer_stats_account_timer(timer);
base->running_timer = timer;
detach_expired_timer(timer, base); //timer脱链
if (irqsafe) {
spin_unlock(&base->lock);
call_timer_fn(timer, fn, data); //调用实际的函数
spin_lock(&base->lock);
} else {
spin_unlock_irq(&base->lock);
call_timer_fn(timer, fn, data);
spin_lock_irq(&base->lock);
}
}
}
base->running_timer = NULL;
spin_unlock_irq(&base->lock);
}
核心的降级处理函数：
#define INDEX(N) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)
static int cascade(struct tvec_base *base, struct tvec *tv, int index)
{
struct timer_list *timer, *tmp;
struct list_head tv_list;
list_replace_init(tv->vec + index, &tv_list); //获取
list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
__internal_add_timer(base, timer);
}
return index;
}
index=0 说明当前的tv1已经为空，这个时候base->timer_jiffies应该已经 >256, INDEX(N)的作用就是减去基数获取实际所在的
链表位置，在tv2中timer_jiffies逐渐增加，每次取tv2的一个数组链表然后释放到tv1中(256)，逐渐释放，当tv2结束时，同理从tv3
释放到tv2.
