30天开发操作系统 第 12 天 -- 定时器 v1.0

前言

定时器(Timer)对于操作系统非常重要。它在原理上却很简单，只是每隔一段时间(比如0.01秒)就发送一个中断信号给CPU。幸亏有了定时器，CPU才不用辛苦地去计量时间。……如果没有定时器会怎么样呢?让我们想象一下吧。
假如CPU看不到定时器而仍想计量时间的话，就只能牢记每一条指令的执行时间了。比如，往寄存器写人常数的MOV指令是1个时钟周期(Clock):加法计算的ADD指令原则上是1个时钟周期，但根据条件不同可能是2个时钟周期……等等。CPU不仅要牢记这些内容，然后还要据此调查一下调用这些函数所需的时间，比如，调用这个函数需要150个时钟周期，调用那个函数因参数不同需要106到587个时钟周期等。
而这里的“时钟周期”又不是一个固定值。比如CPU主频是100MHz的话，一个时钟周期是10 纳秒;但主频如果是200MHz，1个时钟周期就是5纳秒。既然CPU有各种主频，那么1个时钟周期的时间也就各不相同。（大家这下理解cpu的大小核了吧）
这样做可以勉强通过程序对时间进行管理，实现每隔一定时间进行一次某种处理，比如让钟表(程序)的秒针动起来。如果程序中时间计算出错了，那么做出的钟表不是快就是慢，没法使用。
如果没有定时器,还会出现别的麻烦，即不能使用HLT指令。完成这个指令所需的时钟周期不是个固定值。这样，一旦执行HLT指令，程序就不知道时间了。不能执行HLT指令，就意味着要浪费很多电能。所以只能二选一，要么放弃时间的计量，要么选择浪费电能。左右为难，实在糟糕透顶。
打个比方说，如果大家没有手表还想知道时间，那该怎么办呢?当然，不准看太阳，也不准看星星。那就只能根据肚子的饥饿程度，或者烧一壶开水所用的时间等方法来判断了。
总之只能是一边干点儿什么，一边计算时间，而且决不能睡觉!一睡觉就没法计时了……就类似这种情况。
然而实际上，由于有定时器中断，所以不用担心会发生这样的悲剧。程序只需要以自己的步
调处理自己的问题就行了。至于到底经过了多长时间，只要在中断处理程序中数一数定时器中断发生的次数就可以了。就算CPU处于HLT状态，也可以通过中断来唤醒。根本就没必要让程序自己去记忆时间。CPU也就可以安心地去睡觉了(HT)。这样，大家还可以省点电费(笑)。
所以说定时器非常重要。管理定时器是操作系统的重大任务之一,所以在我们的操作系统中也要使用定时器。

一、定时器的设定和使用

1.定时器使用前的设定

要在电脑中管理定时器，只需对PIT进行设定就可以了。PIT是“ProgrammableInterval Timer的缩写，翻译过来就是“可编程的间隔型定时器”。我们可以通过设定PIT，让定时器每隔多少秒就产生一次中断。因为在电脑中PIT连接着IRQ(imteruptrequest，参考第6天)的0号，所以只要设定了PIT就可以设定IRQ0的中断间隔。……在旧机种上PIT是作为一个独立的芯片安装在主板上的，而现在已经和PIC(programmableinterruptcontroller，参考第6天)一样被集成到别的芯片里了。
前几天我们学习PIC时曾经非常辛苦，从现在开始，我们又要重温那种感觉了。大家可不要想:“怎么又学这个?”刚开始学习PIC时，陌生的东西比较多，学起来很费力。这次就不会那么辛苦了。
电脑里的定时器用的是8254芯片(或其替代品 )，那就查一下这个芯片吧。
IRQ0的中断周期变更:
■ AL=0x34:OUT(0x43,AL);
■ AL=中断周期的低8位;OUT(0x40,AL);
■ AL=中断周期的高8位;OUT(0x40,AL);
■ 到这里告一段落。
■ 如果指定中断周期为0，会被看作是指定为65536。实际的中断产生的频率是单位时间时钟周期数(即主频)/设定的数值。比如设定值如果是1000，那么中断产生的频率就是1.19318KHz。设定值是10000的话，中断产生频率就是119.318Hz。再比如设定值是11932的话，中断产生的频率大约就是100Hz了，即每10ms发生一次中断。
我们不清楚其中的详细原理，只知道只要执行3次OUT指令设定就完成了。将中断周期设定为11932的话，中断频率好像就是100Hz，也就是说1秒钟会发生100次中断。那么我们就设定成这个值吧。把11932换算成十六进制数就是0x2e9c，下面是我们编写的函数initpit。

#define PIT_CTRL	0x0043
#define PIT_CNT0	0x0040void init_pit(void)
{io_out8(PIT_CTRL, 0x34);io_out8(PIT_CNT0, 0x9c);io_out8(PIT_CNT0, 0x2e);return;
}

void HariMain(void)
{...init_gdtidt();init_pic();io_sti(); /* IDT/PIC的初始化已经结束，所以解除CPU的中断禁止 */fifo8_init(&keyfifo, 32, keybuf);fifo8_init(&mousefifo, 128, mousebuf);init_pit(); /* 这里 */...
}

这样的话IRQ0就会在1秒钟内发生100次中断了。
下面我们来编写IRO0发生时所调用的中断处理程序。它几乎和键盘中断处理程序一样，大家还记得吗：

void inthandler20(int *esp)
{io_out8(PIC0_OCW2, 0x60);	/* 把IRQ-00信号接收完了的信息通知给PIC *//* 暂时什么也不做 */return;
}

我们把 init_pit 和 inthandler20 放到了新创建的文件夹 timer.c
下面是naskfunc.nas新增的：

_asm_inthandler20:PUSH	ESPUSH	DSPUSHADMOV		EAX,ESPPUSH	EAXMOV		AX,SSMOV		DS,AXMOV		ES,AXCALL	_inthandler20POP		EAXPOPADPOP		DSPOP		ESIRETD

大家还记得下一步是要干什么吗？
为了把这个中断处理程序注册到IDT，inlt gdtidt函数中也要加上几行。这也和键盘处理的时候差不多哦：

/* IDT的设定 */set_gatedesc(idt + 0x20, (int) asm_inthandler20, 2 * 8, AR_INTGATE32);set_gatedesc(idt + 0x21, (int) asm_inthandler21, 2 * 8, AR_INTGATE32);set_gatedesc(idt + 0x27, (int) asm_inthandler27, 2 * 8, AR_INTGATE32);set_gatedesc(idt + 0x2c, (int) asm_inthandler2c, 2 * 8, AR_INTGATE32);

到这里准备工作就完成了。也不知能不能正常运行。正常的话,嗯,应该什么都不发生。
下面我们执行“make run”。哦，什么也没发生。太好了!但这样有点不过瘾，还是在中断处理程序中做点什么吧!

2.计量时间

那我们让它干点什么呢?……我们就让它执行下面这段程序吧：
bookpack.h

struct TIMERCTL {unsigned int count;
};

#include "bootpack.h"#define PIT_CTRL	0x0043
#define PIT_CNT0	0x0040struct TIMERCTL timerctl;void init_pit(void)
{io_out8(PIT_CTRL, 0x34);io_out8(PIT_CNT0, 0x9c);io_out8(PIT_CNT0, 0x2e);timerctl.count = 0; /* 这里 */return;
}void inthandler20(int *esp)
{io_out8(PIC0_OCW2, 0x60);	/* 把IRQ-00信号接收完了的信息通知给PIC */timerctl.count++; /* 这里 */return;
}

大家瞅瞅，没几行新增代码。程序所做的处理是:首先定义了struct TIMERCTL结构体。然后，在结构体内定义了一个计数变量 count。初始化PIT时，将这个计数变量设置为0。每次发生定时器中断时，计数变量就以1递增。
也就是说，即使这个计数变量在HariMain中不进行加算，每1秒钟它也会自动增加100。
为了确认，我们把数值显示出来吧。

		...for (;;) {sprintf(s, "%010d", timerctl.count);boxfill8(buf_win, 160, COL8_C6C6C6, 40, 28, 119, 43);putfonts8_asc(buf_win, 160, 40, 28, COL8_000000, s);sheet_refresh(sht_win, 40, 28, 120, 44);...

这样的话，数字应该是以每秒钟100的速度增加。而且不论哪个机种增加速度都是一样的。
即使CPU的速度不同，增加速度也应该是一样的。我们先做做看吧。执行“make run"。……正常运行了，还算顺利。

就能知道从启动开始时间过去了多少秒。如果往方便面里倒入开水的同时利用这个方法，就能测量是否到3分钟(=180秒)了。哦，终于向着有实用价值的操作系统迈出了第一步。

现在，从启动开始经过了多少秒这一类问题，我们就可以很轻松地判断了。另外，我们还可以计量处理所花费的时间。具体做法是，处理前看一下时间并把它存放到一个变量里，处理结束之后再看一下时间，然后只要用减法算出时间差，就能得到答案了，比如“这个处理耗时13.56秒”等。我们甚至可以据此编制基准测试程序(benchmark program)。
这里大家稍稍回想一下，现在已经能够显示出窗口，又能使用鼠标，又能计量时间，还能进行内存管理，已经实现了很多功能。有了这些功能，只要对它们进行各种组合,就能做很多事情。
我们言归正传，继续说定时器吧。操作系统的定时器经常被用于这样一种情形:“喂，操作系统，过了10秒钟以后通知我一声，我要干什么什么”。当然，不一定非要是10秒，也可以是1秒或30分钟。我们把这样的功能叫做“超时”(timeout)。下面就来实现这个功能吧。
首先往结构体struct TIMERCTL里添加一些代码，以便记录有关超时的信息。

struct TIMERCTL {unsigned int count;unsigned int timeout;struct FIFO8 *fifo;unsigned char data;
};

以上结构体中的timeout用来记录离超时还有多长时间。一旦这个剩余时间达到0，程序就往FIFO缓冲区里发送数据。定时器就是通过这种方法通知HariMain时间到了。至于为什么要使用FIFO缓冲区，也说不上个所以然，只是觉得这个方法简单，因为使用FIFO缓冲区来通知的话，可以比照键盘和鼠标，利用同样的方法来处理。
下面我们来修改函数吧。

#include "bootpack.h"#define PIT_CTRL	0x0043
#define PIT_CNT0	0x0040struct TIMERCTL timerctl;void init_pit(void)
{io_out8(PIT_CTRL, 0x34);io_out8(PIT_CNT0, 0x9c);io_out8(PIT_CNT0, 0x2e);timerctl.count = 0;timerctl.timeout = 0;return;
}void inthandler20(int *esp)
{io_out8(PIC0_OCW2, 0x60);	/* 把IRQ-00信号接收结束的信息通知给PIC */timerctl.count++;if (timerctl.timeout > 0) { /* 如果已经设定了超时 */timerctl.timeout--;if (timerctl.timeout == 0) {fifo8_put(timerctl.fifo, timerctl.data);}}return;
}void settimer(unsigned int timeout, struct FIFO8 *fifo, unsigned char data)
{int eflags;eflags = io_load_eflags();io_cli();timerctl.timeout = timeout;timerctl.fifo = fifo;timerctl.data = data;io_store_eflags(eflags);return;
}

希望大家注意的是，我们在inthandler20函数里实现了超时功能。每次发生中断时就把timeout减1，减到0时，就向fifo发送数据。
在settimer函数里，如果设定还没有完全结束IRQ0的中断就进来的话，会引起混乱，所以我们先禁止中断，然后完成设定，最后再把中断状态复原。
这在HariMain中如何实现呢?我们来尝试这样做:

void HariMain(void)
{struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;struct FIFO8 timerfifo;char s[40], keybuf[32], mousebuf[128], timerbuf[8];...fifo8_init(&timerfifo, 8, timerbuf);settimer(1000, &timerfifo, 1);...for (;;) {...io_cli();if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) + fifo8_status(&timerfifo) == 0) {io_sti();} else {if (fifo8_status(&keyfifo) != 0) {...} else if (fifo8_status(&mousefifo) != 0) {i = fifo8_get(&mousefifo);io_sti();if (mouse_decode(&mdec, i) != 0) {...} else if (fifo8_status(&timerfifo) != 0) {i = fifo8_get(&timerfifo); /* 读入 */io_sti();putfonts8_asc(buf_back, binfo->scrnx, 0, 64, COL8_FFFFFF, "10[sec]");sheet_refresh(sht_back, 0, 64, 56, 80);}}}
}

程序很简单，我们在其中设定10秒钟以后向timerfifo写人“1”这个数据，而timerffo接收到数据时，就会在屏幕上显示“10[sec]”。
我们执行一下“make run”，看，显示出来了!

2.设定多个计时器

在上一节做的超时功能，超时结束后如果再设定1000的话，那我们就可以让它每10秒显示或是让它一闪一灭地显示。另外，间隔不仅限于10秒，我们还可以设定得更长一些或更短一次，些。比如设定为0.5秒的间隔可以用于文字输人时的光标闪烁。
开发操作系统时，超时功能非常方便，所以在很多地方都可以使用它。比如可以让电子时钟每隔1秒重新显示一次;演奏音乐时，可以用它计量音符的长短;也可以让它以0.1秒1次的频率来监视没有中断功能的装置;另外，还可以用它实现光标的闪烁功能。
为了简单地实现这些功能，我们要准备很多能够设定超时的定时器。
首先把struct TIMERCTL修改成下面这样。

#define MAX_TIMER		500
struct TIMER {unsigned int timeout, flags;struct FIFO8 *fifo;unsigned char data;
};
struct TIMERCTL {unsigned int count;struct TIMER timer[MAX_TIMER];
};

这样超时定时器最多就可以设定为500个了，fags则用于记录各个定时器的状态。
继续修改对应的函数：

#include "bootpack.h"#define PIT_CTRL	0x0043
#define PIT_CNT0	0x0040struct TIMERCTL timerctl;#define TIMER_FLAGS_ALLOC		1	/* 已配置状态 */
#define TIMER_FLAGS_USING		2	/* 定时器运行中 */void init_pit(void)
{int i;io_out8(PIT_CTRL, 0x34);io_out8(PIT_CNT0, 0x9c);io_out8(PIT_CNT0, 0x2e);timerctl.count = 0;for (i = 0; i < MAX_TIMER; i++) {timerctl.timer[i].flags = 0; /* 未使用 */}return;
}struct TIMER *timer_alloc(void)
{int i;for (i = 0; i < MAX_TIMER; i++) {if (timerctl.timer[i].flags == 0) {timerctl.timer[i].flags = TIMER_FLAGS_ALLOC;return &timerctl.timer[i];}}return 0; /* 没找到 */
}void timer_free(struct TIMER *timer)
{timer->flags = 0; /* 未使用 */return;
}void timer_init(struct TIMER *timer, struct FIFO8 *fifo, unsigned char data)
{timer->fifo = fifo;timer->data = data;return;
}void timer_settime(struct TIMER *timer, unsigned int timeout)
{timer->timeout = timeout;timer->flags = TIMER_FLAGS_USING;return;
}void inthandler20(int *esp)
{int i;io_out8(PIC0_OCW2, 0x60);	/* 把IRQ-00信号接收结束的信息通知给PIC */timerctl.count++;for (i = 0; i < MAX_TIMER; i++) {if (timerctl.timer[i].flags == TIMER_FLAGS_USING) {timerctl.timer[i].timeout--;if (timerctl.timer[i].timeout == 0) {timerctl.timer[i].flags = TIMER_FLAGS_ALLOC;fifo8_put(timerctl.timer[i].fifo, timerctl.timer[i].data);}}}return;
}

程序稍微有些长，不是很难，只要前面的程序大家都明白了，这里应该也没什么困难。
最后来看HariMain函数。我们不一定都设定为10秒，也尝试一下设为3秒吧。另外，我们还要编写类似光标闪烁那样的程序。

void HariMain(void)
{struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;struct FIFO8 timerfifo, timerfifo2, timerfifo3;char s[40], keybuf[32], mousebuf[128], timerbuf[8], timerbuf2[8], timerbuf3[8];struct TIMER *timer, *timer2, *timer3;...fifo8_init(&timerfifo, 8, timerbuf);timer = timer_alloc();timer_init(timer, &timerfifo, 1);timer_settime(timer, 1000);fifo8_init(&timerfifo2, 8, timerbuf2);timer2 = timer_alloc();timer_init(timer2, &timerfifo2, 1);timer_settime(timer2, 300);fifo8_init(&timerfifo3, 8, timerbuf3);timer3 = timer_alloc();timer_init(timer3, &timerfifo3, 1);timer_settime(timer3, 50);...for (;;) {...io_cli();if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) + fifo8_status(&timerfifo)+ fifo8_status(&timerfifo2) + fifo8_status(&timerfifo3) == 0) {io_sti();} else {if (fifo8_status(&keyfifo) != 0) {...} else if (fifo8_status(&mousefifo) != 0) {i = fifo8_get(&mousefifo);io_sti();if (mouse_decode(&mdec, i) != 0) {} else if (fifo8_status(&timerfifo) != 0) {i = fifo8_get(&timerfifo); /* 读入 */io_sti();putfonts8_asc(buf_back, binfo->scrnx, 0, 64, COL8_FFFFFF, "10[sec]");sheet_refresh(sht_back, 0, 64, 56, 80);} else if (fifo8_status(&timerfifo2) != 0) {i = fifo8_get(&timerfifo2); /* 读入 */io_sti();putfonts8_asc(buf_back, binfo->scrnx, 0, 80, COL8_FFFFFF, "3[sec]");sheet_refresh(sht_back, 0, 80, 48, 96);} else if (fifo8_status(&timerfifo3) != 0) {/* 模拟光标 */i = fifo8_get(&timerfifo3);io_sti();if (i != 0) {timer_init(timer3, &timerfifo3, 0); /* 设置 0 */boxfill8(buf_back, binfo->scrnx, COL8_FFFFFF, 8, 96, 15, 111);} else {timer_init(timer3, &timerfifo3, 1); /* 设置 1 */boxfill8(buf_back, binfo->scrnx, COL8_008484, 8, 96, 15, 111);}timer_settime(timer3, 50);sheet_refresh(sht_back, 8, 96, 16, 112);}}}
}

下面就是期盼已久的“make run”了。我们执行一下，看看我们的成就：

二、加快中断处理

1.0

现在我们可以自由使用多个定时器了，从数量上说，已经足够了。但仔细看一下大家会发现，inthandler20还有很大问题:中断处理本来应该在很短的时间内完成,可利用inthandler20时却花费了很长时间。这就妨碍了其他中断处理的执行，使得操作系统反应很迟钝。
如果检査inthandler20，能发现每次进行定时器中断处理的时候，都会对所有活动中的定时器
进行“timerctl.timer[i].timeout–;”处理。也就是说，CPU要完成从内存中读取变量值，减去1，然后又往内存中写人的操作。本来谁也不会注意到这种细微之处，但由于我们想在中断处理程序中尽可能减少哪怕是一点点工作量，所以才会注意到这里。
问题找到了，那该怎么修改才好呢?我们看看下面这样行不行：

void inthandler20(int *esp)
{int i;io_out8(PIC0_OCW2, 0x60);	/* 把IRQ-00信号接收结束的信息通知给PIC */timerctl.count++;for (i = 0; i < MAX_TIMER; i++) {if (timerctl.timer[i].flags == TIMER_FLAGS_USING) {if (timerctl.timer[i].timeout <= timerctl.count) {timerctl.timer[i].flags = TIMER_FLAGS_ALLOC;fifo8_put(timerctl.timer[i].fifo, timerctl.timer[i].data);}}}return;
}

我们改变了程序中变量timer[i].timeout的含义。它指的不再是“所剩时间”,而是“设定时刻”
了。因为现在的时刻计数到timerctl.count中去了，所以就拿它和timer[i].timeout进行比较，如果相同或是超过了，就通过往FIFO缓冲区里传送数据来通知HariMain。大家现在再看一看，我们一直担心的减法计算没有了。这样一改，程序的速度应该能稍微变快一些了。
下面我们也要相应地修改timer_settime函数。

void timer_settime(struct TIMER *timer, unsigned int timeout)
{timer->timeout = timeout + timerctl.count;timer->flags = TIMER_FLAGS_USING;return;
}

timer_settime函数中所指定的时间，是“从现在开始多少多少秒以后”的意思，所以用这个
时间加上现在的时刻，就可以计算出中断的预定时刻。程序中对这个时刻进行了记录。别的地方就不用改了。

到底这样做行不行呢，我们执行一下“make run”。好哇，进行得很顺利。虽然还没能切身
感到速度变快了多少，不过先自我满足一下吧。
同时也正是因为变成了这种方式，在我们这个操作系统中，启动以后经过42949673
秒后，count就是0xfffffffff了，比这个值再大就不能设定了。这么多秒是几天呢?……嗯，请稍等(用计算器算一下)……大约是497天。也就是大约一年就要重新启动一次操作系统，让count归0。
这里大家可能又会有怨言了“哎呀，还需要重新起动，这样的操作系统真是麻烦”。事实上
本人也是这么想的(笑)。怎么办才好呢。回到上一节的做法，好不好呢?可是回到上
一节的做法，速度又有些慢。……既不希望速度慢，又不想重新启动 – 为了满足这种奢望，我们设计成一年调整一次时刻的程序也许比较好。

int t0=timerctl.count;/*所有时刻都要减去这个值*/
io_cli();/*在时刻调整时禁止定时器中断 */
timerctl.count-=t0;
for(i=0;i<MAX TIMER;i++){if(timerctl.timeri],flags ==TIMER FLAGS USING){timerctl.timer[i].timeout =t;}
}
io_sti();

也许以上方法并非最好，但我们不轻言放弃而去想办法解决，这种心境是最重要的。只要努
力，我们肯定还能找到别的好办法。

2.0

我们再来改善一下吧。

代码如下（示例）：

void inthandler20(int *esp)
{int i;io_out8(PIC0_OCW2, 0x60);timerctl.count++;for (i = 0; i < MAX_TIMER; i++) {if (timerctl.timer[i].flags == TIMER_FLAGS_USING) {if (timerctl.timer[i].timeout <= timerctl.count) {timerctl.timer[i].flags = TIMER_FLAGS_ALLOC;fifo8_put(timerctl.timer[i].fifo, timerctl.timer[i].data);}}}return;
}

如果看一下 harib09e的inthandler20，大家会发现每次中断都要执行500次(=MAX TIMER的
次数)if语句，很浪费时间。由于1秒钟就要发生100次中断，这个if语句1秒钟就要执行5万次。
尽管如此，这两个if语句都为真，而其中的fags值得以更改，或者是6fo8put函数能够执行的频
率，最多也就是每0.5秒1次，即每秒2次左右。其余的49998次if语句都是在做无用功，基本没什么意义。

我们来变通一下思考方式，如果是人在进行着这样的定时器管理，会怎么做呢?定时器加在
一起最多有500个。其中有3秒钟以后超时的，有50秒钟以后超时的，也有0.3秒钟以后超时的，还有一天以后超时的。这种情况下，我们首先会关注哪一个?应该是0.3秒钟以后的那个吧。0.3秒钟的结束后，下次是3秒钟以后的。也就是没必要把500个都看完，只要看到“下一个”的时刻就可以了。因此，我们追加一个变量timerctl.next，让它记住下一个时刻。

struct TIMERCTL {unsigned int count, next;struct TIMER timer[MAX_TIMER];
};

void inthandler20(int *esp)
{int i;io_out8(PIC0_OCW2, 0x60);	/* 把IRQ-00信号接收结束的信息通知给PIC */timerctl.count++;if (timerctl.next > timerctl.count) {return; /* 还不到下一个时刻，所以结束 */}timerctl.next = 0xffffffff;for (i = 0; i < MAX_TIMER; i++) {if (timerctl.timer[i].flags == TIMER_FLAGS_USING) {if (timerctl.timer[i].timeout <= timerctl.count) {/* 超时 */timerctl.timer[i].flags = TIMER_FLAGS_ALLOC;fifo8_put(timerctl.timer[i].fifo, timerctl.timer[i].data);} else {/* 还没有超时的话,这里会找到离下一次超时最近的*/if (timerctl.next > timerctl.timer[i].timeout) {timerctl.next = timerctl.timer[i].timeout;}}}}return;
}

虽然程序变长了,但要做的处理却减少了。在大多数情况下,第一个if语句的return都会执行，
中断处理就到此结束了。当到达下一个时刻时，使用之前那种方法检查是否超时。超时的话，就写人到FIFO中;还没超时的话就调查是否将其设定为下一个时刻(未超时时刻中，最小的时刻是下一个时刻)。
如果用这样的方法，就能大大减少没有意义的if语句的执行次数，速度也应该快多了。
由于使用了next，所以其他地方也要修改一下。

void init_pit(void)
{int i;io_out8(PIT_CTRL, 0x34);io_out8(PIT_CNT0, 0x9c);io_out8(PIT_CNT0, 0x2e);timerctl.count = 0;timerctl.next = 0xffffffff; /* 因为最初没有正在运行的定时器 */for (i = 0; i < MAX_TIMER; i++) {timerctl.timer[i].flags = 0; /* 没有使用 */}return;
}void timer_settime(struct TIMER *timer, unsigned int timeout)
{timer->timeout = timeout + timerctl.count;timer->flags = TIMER_FLAGS_USING;if (timerctl.next > timer->timeout) {/* 更新下一次的时刻 */timerctl.next = timer->timeout;}return;
}

这样就好了。现在我们来确认是否能正常运行。“makerun”。……和以前一样，虽然仍不能
切身地感受到速度变快了，但还是自我满足一下吧。

3.0

到了harib09f的时候，中断处理程序的平均处理时间已经大大缩短了。这真是太好了。可是，
现在有一个问题，那就是到达next时刻和没到next时刻的定时器中断，它们的处理时间差别很大。
这样的程序结构不好。因为平常运行一直都很快的程序，会偶尔由于中断处理拖得太长，而搞得像是主程序要停了似的。更确切一点,这样有时会让人觉得“不知为什么,鼠标偶尔会反应迟钝,很卡。”
因此，我们要让到达next时刻的定时器中断的处理时间再缩短一些。，怎么办呢?模仿
sheet.c的做法怎么样呢?我们来试试看。
在sheet.c的结构体struct SHTCTL中，除了sheet0[]以外，我们还定义了*sheets[]。它里面存
放的是按某种顺序排好的图层地址。有了这个变量，按顺序描绘图层就简单了。这次我们在stuct TIMERCTL中也定义一个变量，其中存放按某种顺序排好的定时器地址。

struct TIMERCTL {unsigned int count, next, using;struct TIMER *timers[MAX_TIMER];struct TIMER timers0[MAX_TIMER];
};

变量using相当于struct SHTCTL中的top，它用于记录现在的定时器中有几个处于活动中。
改进后的inthandler20函数如下:

void inthandler20(int *esp)
{int i, j;io_out8(PIC0_OCW2, 0x60);	/* 把IRQ-00信号接收结束的信息通知给PIC */timerctl.count++;if (timerctl.next > timerctl.count) {return;}for (i = 0; i < timerctl.using; i++) {/* timers的定时器都处于动作中，所以不确认flags */if (timerctl.timers[i]->timeout > timerctl.count) {break;}/* 超时 */timerctl.timers[i]->flags = TIMER_FLAGS_ALLOC;fifo8_put(timerctl.timers[i]->fifo, timerctl.timers[i]->data);}/* 正好有i个定时器超时了。其余的进行移位。 */timerctl.using -= i;for (j = 0; j < timerctl.using; j++) {timerctl.timers[j] = timerctl.timers[i + j];}if (timerctl.using > 0) {timerctl.next = timerctl.timers[0]->timeout;} else {timerctl.next = 0xffffffff;}return;
}

这样，即使是在超时的情况下，也不用查找下一个next时刻，或者查找有没有别的定时器超
时了，真不错。如果有很多的定时器都处于正在执行的状态，我们会担心定时器因移位而变慢，这放在以后再改进吧。
由于timerctl中的变量名改变了，所以其他地方也要随之修改。

void init_pit(void)
{int i;io_out8(PIT_CTRL, 0x34);io_out8(PIT_CNT0, 0x9c);io_out8(PIT_CNT0, 0x2e);timerctl.count = 0;timerctl.next = 0xffffffff; /* 因为最初没有正在运行的定时器 */timerctl.using = 0;for (i = 0; i < MAX_TIMER; i++) {timerctl.timers0[i].flags = 0; /* 未使用 */}return;
}struct TIMER *timer_alloc(void)
{int i;for (i = 0; i < MAX_TIMER; i++) {if (timerctl.timers0[i].flags == 0) {timerctl.timers0[i].flags = TIMER_FLAGS_ALLOC;return &timerctl.timers0[i];}}return 0; /* 没找到 */
}

这两个函数比较简单，只是稍稍修改了一下变量名。
在timer_settime函数中，必须将timer注册到timers中去，而且要注册到正确的位置。如果在注册时发生中断的话可就麻烦了，所以我们要事先关闭中断。

void timer_settime(struct TIMER *timer, unsigned int timeout)
{int e, i, j;timer->timeout = timeout + timerctl.count;timer->flags = TIMER_FLAGS_USING;e = io_load_eflags();io_cli();/* 搜索注册位置 */for (i = 0; i < timerctl.using; i++) {if (timerctl.timers[i]->timeout >= timer->timeout) {break;}}/* i号之后全部后移一位 */for (j = timerctl.using; j > i; j--) {timerctl.timers[j] = timerctl.timers[j - 1];}timerctl.using++;/* 插入到空位上 */timerctl.timers[i] = timer;timerctl.next = timerctl.timers[0]->timeout;io_store_eflags(e);return;
}

这样做看来不错。虽然中断处理程序速度已经提高了，但在设定定时器期间，我们关闭了中
这多少有些令人遗憾。不过就算对此不满意，也不要随便更改哦。
从某种程度上来讲，这也是无法避免的事。如果在设定时，多下点工夫整理一下，到达中断
时刻时就能轻松一些了。反之，如果在设定时偷点懒，那么到达中断时刻时就要吃点苦头了。总之，要么提前做好准备，要么临时抱佛脚。究竟哪种做法好呢，要根据情况而定。

总结

`
现在我们执行“make run”看看吧。希望它能正常运行。会怎么样呢?貌似很顺利，太好了。
关于定时器我们还有想要修改的地方。不过大家肯定已经很困了，我们还是明天再继续吧。
再见!