30天自制操作系统——第十三天添加定时器（二）

测试性能

由于后续开发中要经常用到定时器，需要不断对定时器进行改善，提高性能。然而每次一番操作，性能有没有提高，提高了多少，凭我们直观的感受可不好衡量，因此我们需要一个具体的方法来测试性能。

这里我们测试性能的方法很简单，我们在HariMain函数进行修改。先将count置0，不显示任何计数。在for循环中全力执行“count++",当到了10秒后超时，再对这个count进行显示。这里需要注意的是，由于每次电脑初始化花费的时间差别较大（原因很多，这里就不赘述了），我们在3秒后把count复位为0一次，这样测试的时间就是7秒。

HariMain函数修改：

void HariMain(void)
{
	（略）
	for (;;) {
		count++;

		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) {
				（略）
				
			} else if (fifo8_status(&timerfifo) != 0) {
				i = fifo8_get(&timerfifo); /* 超时的是哪个呢？ */
				io_sti();
				if (i == 10) {
					putfonts8_asc_sht(sht_back, 0, 64, COL8_FFFFFF, COL8_008484, "10[sec]", 7);
					sprintf(s, "%010d", count);
					putfonts8_asc_sht(sht_win, 40, 28, COL8_000000, COL8_C6C6C6, s, 10);
				} else if (i == 3) {
					putfonts8_asc_sht(sht_back, 0, 80, COL8_FFFFFF, COL8_008484, "3[sec]", 6);
					count = 0; /* 恢复0，开始测试 */
				} else {
					/* 0还是1 */
					if (i != 0) {
						timer_init(timer3, &timerfifo, 0); /* 下面是设定为0 */
						boxfill8(buf_back, binfo->scrnx, COL8_FFFFFF, 8, 96, 15, 111);
					} else {
						timer_init(timer3, &timerfifo, 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——

如果我们在模拟器中运行，多运行几次会发现差别非常大，这是因为使用模拟器受到了windows的影响。有条件的话可以在真机上多运行几次，会发现数值相差不会太大，有些细微的差别与电脑温度、时钟频率的微小变化有关。

调整FIFO缓冲区

这里我们将3个定时器、鼠标和键盘都归纳起来，用一个FIFO缓冲区来管理。通过将3个定时器、鼠标、键盘设定为不同的值，往FIFO缓冲区里写入数据。写入数值的对应关系如下：

0~1：光标闪烁用定时器

3：3秒定时器

10：10秒定时器

256~511：键盘输入（从键盘控制器读入的值再加上256）

512~767：鼠标输入（从键盘控制器读入的值再加上512）

bootpack.h节选：

struct FIFO32 {
	int *buf;
	int p, q, size, free, flags;
};

fifo.c节选：

void fifo32_init(struct FIFO32 *fifo, int size, int *buf)
/* FIFO缓冲区的初始化 */
{
	fifo->size = size;
	fifo->buf = buf;
	fifo->free = size; /* 空 */
	fifo->flags = 0;
	fifo->p = 0; /* 写入位置 */
	fifo->q = 0; /* 读取位置 */
	return;
}

int fifo32_put(struct FIFO32 *fifo, int data)
/* 给FIFO发送数据并存储在FIFO中 */
{
	if (fifo->free == 0) {
		/* 没有空余空间，溢出 */
		fifo->flags |= FLAGS_OVERRUN;
		return -1;
	}
	fifo->buf[fifo->p] = data;
	fifo->p++;
	if (fifo->p == fifo->size) {
		fifo->p = 0;
	}
	fifo->free--;
	return 0;
}

int fifo32_get(struct FIFO32 *fifo)
/* 从FIFO取得一个数据 */
{
	int data;
	if (fifo->free == fifo->size) {
		/* 当缓冲区为空的情况下返回-1 */
		return -1;
	}
	data = fifo->buf[fifo->q];
	fifo->q++;
	if (fifo->q == fifo->size) {
		fifo->q = 0;
	}
	fifo->free++;
	return data;
}

int fifo32_status(struct FIFO32 *fifo)
/* 报告已经存储了多少数据 */
{
	return fifo->size - fifo->free;
}

3个定时器、键盘和鼠标对应的位置需要修改，使用FIFO8的位置改为使用FIFIO32，最后修改一下HariMain函数，准备工作就完成了。

HariMain函数：

void HariMain(void)
{
	struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
	struct FIFO32 fifo;
	char s[40];
	int fifobuf[128];	
	（略）
	fifo32_init(&fifo, 128, fifobuf);
	init_pit();
	init_keyboard(&fifo, 256);
	enable_mouse(&fifo, 512, &mdec);
	io_out8(PIC0_IMR, 0xf8); 
	io_out8(PIC1_IMR, 0xef); 

	timer = timer_alloc();
	timer_init(timer, &fifo, 10);
	timer_settime(timer, 1000);
	timer2 = timer_alloc();
	timer_init(timer2, &fifo, 3);
	timer_settime(timer2, 300);
	timer3 = timer_alloc();
	timer_init(timer3, &fifo, 1);
	timer_settime(timer3, 50);
	（略）
	for (;;) {
		count++;

		io_cli();
		if (fifo32_status(&fifo) == 0) {
			io_sti();
		} else {
			i = fifo32_get(&fifo);
			io_sti();
			if (256 <= i && i <= 511) { /* 键盘数据 */
				sprintf(s, "%02X", i - 256);
				putfonts8_asc_sht(sht_back, 0, 16, COL8_FFFFFF, COL8_008484, s, 2);
			} else if (512 <= i && i <= 767) { /* 鼠标数据 */
				if (mouse_decode(&mdec, i - 512) != 0) {
					/* 已经收集了3字节的数据，所以显示出来 */
					sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
					if ((mdec.btn & 0x01) != 0) {
						s[1] = 'L';
					}
					if ((mdec.btn & 0x02) != 0) {
						s[3] = 'R';
					}
					if ((mdec.btn & 0x04) != 0) {
						s[2] = 'C';
					}
					putfonts8_asc_sht(sht_back, 32, 16, COL8_FFFFFF, COL8_008484, s, 15);
					/* 鼠标指针的移动 */
					mx += mdec.x;
					my += mdec.y;
					if (mx < 0) {
						mx = 0;
					}
					if (my < 0) {
						my = 0;
					}
					if (mx > binfo->scrnx - 1) {
						mx = binfo->scrnx - 1;
					}
					if (my > binfo->scrny - 1) {
						my = binfo->scrny - 1;
					}
					sprintf(s, "(%3d, %3d)", mx, my);
					putfonts8_asc_sht(sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);
					sheet_slide(sht_mouse, mx, my);
				}
			} else if (i == 10) { /* 10秒定时器 */
				putfonts8_asc_sht(sht_back, 0, 64, COL8_FFFFFF, COL8_008484, "10[sec]", 7);
				sprintf(s, "%010d", count);
				putfonts8_asc_sht(sht_win, 40, 28, COL8_000000, COL8_C6C6C6, s, 10);
			} else if (i == 3) { /* 3秒定时器 */
				putfonts8_asc_sht(sht_back, 0, 80, COL8_FFFFFF, COL8_008484, "3[sec]", 6);
				count = 0; /* 开始测试 */
			} else if (i == 1) { /* 光标用定时器 */
				timer_init(timer3, &fifo, 0); /* 下面是设定0 */
				boxfill8(buf_back, binfo->scrnx, COL8_FFFFFF, 8, 96, 15, 111);
				timer_settime(timer3, 50);
				sheet_refresh(sht_back, 8, 96, 16, 112);
			} else if (i == 0) { /* 光标用定时器 */
				timer_init(timer3, &fifo, 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一下——

与前一节相比快了不少呢，

上一节：0753015651

这一节：1045522362

这样看性能确实改善了不少，有条件的同学可以在真机里运行一下，可能没有在虚拟中变化这么明显，但是确确实实是改善了。

分析一下原因，在HariMain函数里，执行“count++”、查询FIFO缓冲区是多次交互操作的。经过修改后，程序只需要查看一个FIFO缓冲区就可以了。也就是说，提高了FIFO缓冲区的查询速度，从而执行了更多次的“count++”。

加快中断处理

继续对定时器进行改良，inthandler20和timer_settime中的移位处理是我们这次需要修改的地方。我们目前的定时器只有3个，使用移位处理影响不大，但是当有很多个定时器时，再使用这种移位处理就很浪费时间了。

我们使用数据结构中的线性表来替代移位处理，不熟悉的同学可以翻一下大学里的数据结构课本，另外《大话数据结构》这本书也不错。

我们在结构体struct TIMER中加入next变量，这个是地址变量，用来存放下一个即将超时的定时器地址。

bootpack.h

struct TIMER {
	struct TIMER *next;
	unsigned int timeout, flags;
	struct FIFO32 *fifo;
	int data;
};

inthander20函数：

void inthandler20(int *esp)
{
	int i;
	struct TIMER *timer;
	io_out8(PIC0_OCW2, 0x60);	
	timerctl.count++;
	if (timerctl.next > timerctl.count) {
		return;
	}
	timer = timerctl.t0; /* 首先把最前面的地址给timer */
	for (i = 0; i < timerctl.using; i++) {
		/* 因为timers的定时器都处于运行状态，所以不确认flags */
		if (timer->timeout > timerctl.count) {
			break;
		}
		/* タイムアウト */
		timer->flags = TIMER_FLAGS_ALLOC;
		fifo32_put(timer->fifo, timer->data);
		timer = timer->next; /*下一定时器的地址给timer*/
	}
	timerctl.using -= i;

	/* 新移位 */
	timerctl.t0 = timer;

	/* timerctl.next的设定 */
	if (timerctl.using > 0) {
		timerctl.next = timerctl.t0->timeout;
	} else {
		timerctl.next = 0xffffffff;
	} 
	return;
}

timer_settime函数:

void timer_settime(struct TIMER *timer, unsigned int timeout)
{
	int e;
	struct TIMER *t, *s;
	timer->timeout = timeout + timerctl.count;
	timer->flags = TIMER_FLAGS_USING;
	e = io_load_eflags();
	io_cli();
	timerctl.using++;
	if (timerctl.using == 1) {
		/* 处于运动状态的定时器只有这一个 */
		timerctl.t0 = timer;
		timer->next = 0; /*没有下一个 */
		timerctl.next = timer->timeout;
		io_store_eflags(e);
		return;
	}
	t = timerctl.t0;
	if (timer->timeout <= t->timeout) {
		/* 插入最前面的情况下*/
		timerctl.t0 = timer;
		timer->next = t; /*下面是t */
		timerctl.next = timer->timeout;
		io_store_eflags(e);
		return;
	}
	/* 搜寻插入位置 */
	for (;;) {
		s = t;
		t = t->next;
		if (t == 0) {
			break; /* 最后面 */
		}
		if (timer->timeout <= t->timeout) {
			/* 插入到s和t之间时 */
			s->next = timer; /* s的下一个是timer */
			timer->next = t; /* timer的下一个是t */
			io_store_eflags(e);
			return;
		}
	}
	/* 插入到最后面的情况下 */
	s->next = timer;
	timer->next = 0;
	io_store_eflags(e);
	return;
}

make run一下：

数值又变大了，说明性能确实有提升。

使用“哨兵”

time.c去除移位处理后，timer_settime函数有些冗长，我们查看一下程序发现，其中包含了4中可能性。

1.运行中的定时器只有一个

2.插入到最前面

3.插入到s和t之间

4.插入到最后面

使用“哨兵”具体做法是在进行初始化时，将时刻0xffffffff定时器连接到最后一个定时器上。它一直处在最后，这个留守者就是“哨兵”。

void init_pit(void)
{
	int i;
	struct TIMER *t;
	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.timers0[i].flags = 0; /* 没有使用 */
	}
	t = timer_alloc(); /* 取得一个 */
	t->timeout = 0xffffffff;
	t->flags = TIMER_FLAGS_USING;
	t->next = 0; /* 末尾 */
	timerctl.t0 = t; /* 因为现在只有哨兵，所有它就在最前面 */
	timerctl.next = 0xffffffff; /* 因为只有哨兵，所以下一个超时时刻就是哨兵的时刻 */
	return;
}

由于加入了哨兵，第一种和第四种情况就不会发生了，timer_settime精简了不少。

修改后的timer_settime函数：

void timer_settime(struct TIMER *timer, unsigned int timeout)
{
	int e;
	struct TIMER *t, *s;
	timer->timeout = timeout + timerctl.count;
	timer->flags = TIMER_FLAGS_USING;
	e = io_load_eflags();
	io_cli();
	t = timerctl.t0;
	if (timer->timeout <= t->timeout) {
		/* 插入最前面的情况 */
		timerctl.t0 = timer;
		timer->next = t; /*下面是设定t */
		timerctl.next = timer->timeout;
		io_store_eflags(e);
		return;
	}
	/* 搜寻插入位置 */
	for (;;) {
		s = t;
		t = t->next;
		if (timer->timeout <= t->timeout) {
			/* 插入s和t之间的情况 */
			s->next = timer; /* s下一个是timer */
			timer->next = t; /* timer的下一个是t */
			io_store_eflags(e);
			return;
		}
	}
}

修改后的inthander20函数：

void inthandler20(int *esp)
{
	struct TIMER *timer;
	io_out8(PIC0_OCW2, 0x60);	
	timerctl.count++;
	if (timerctl.next > timerctl.count) {
		return;
	}
	timer = timerctl.t0; /* 首先把最前面的地址给timer */
	for (;;) {
		/* 因为timers的定时器都处于运行状态、所以不确认flags */
		if (timer->timeout > timerctl.count) {
			break;
		}
		/* 超时 */
		timer->flags = TIMER_FLAGS_ALLOC;
		fifo32_put(timer->fifo, timer->data);
		timer = timer->next; /*将下一定时器的地址代入timer */
	}
    /* 新移位 */
	timerctl.t0 = timer;
    /* timerctl.next的设定 */
	timerctl.next = timer->timeout;
	return;
}

运行make run一下——

咦，数值比之前小了一些，说明速度变慢了。具体是什么原因呢，明天再来分析吧。

https://gitee.com/mint1993/myos.git