# Timer
昨天的優化還是要繼續主要還是進行中斷加速的優化
## 調整為共用緩衝區
依照他的說法假設我們每次增加一個timer 是否都要為 timer 去增加一個 緩衝區
所以就提出了共用緩衝區的概念，那麼共用緩衝區會怎樣，會不會造成不知道是哪一個timer 發生的中斷
### HariMain
調整前中斷判斷
```c=
if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) + fifo8_status(&timerfifo)
+ fifo8_status(&timerfifo2) + fifo8_status(&timerfifo3) == 0) {
io_sti();
} else {
```
```c=
fifo8_init(&timerfifo, 8, timerbuf);
timer = timer_alloc();
timer_init(timer, &timerfifo, 10);
timer_settime(timer, 1000);
timer2 = timer_alloc();
timer_init(timer2, &timerfifo, 3);
timer_settime(timer2, 300);
timer3 = timer_alloc();
timer_init(timer3, &timerfifo, 1);
timer_settime(timer3, 50);
for (;;)
{
sprintf(s, "%010d", timerctl.count);
putfonts8_asc_sht(sht_win, 40, 28, COL8_000000, COL8_C6C6C6, s, 10);
io_cli();
if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) + fifo8_status(&timerfifo) == 0)
{
io_sti();
}
else
{
if (fifo8_status(&keyfifo) != 0)
{
io_sti();
（中略）
}
else if (fifo8_status(&mousefifo) != 0)
{
io_sti();
（中略）
}
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);
}
else if (i == 3)
{
putfonts8_asc_sht(sht_back, 0, 80, COL8_FFFFFF, COL8_008484, "3[sec]", 6);
}
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);
}
}
}
}
```
調整後中斷判斷，每次新增新的timer 我們就不用再增加那些判斷式了
```c=
if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) + fifo8_status(&timerfifo) == 0) {
```
## 替換結構 fifo32 和 共用緩衝區
整體結構跟 fifo8一樣，主要要在不同data區段
有這些，那麼共用緩衝區要怎麼判斷那些中斷設備的範圍
0～ 1…………………光标闪烁用定时器
3…………………3秒定时器
10…………………10秒定时器
256～ 511…………………键盘输入（从键盘控制器读入的值再加上256）
512～ 767……鼠标输入（从键盘控制器读入的值再加上512）
### bootpack.h
```c=
struct FIFO32
{
int *buf;
int p, q, size, free, flags;
};
```
### fifo.c
```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;
}
```
### keybord
```c=
void inthandler21(int *esp)
{
int data;
io_out8(PIC0_OCW2, 0x61); /* 把IRQ-01接收信号结束的信息通知给PIC */
data = io_in8(PORT_KEYDAT);
fifo32_put(keyfifo, data + keydata0);
return;
}
```
### mouse
```c=
void inthandler2c(int *esp)
/* 基于PS/2鼠标的中断 */
{
int data;
io_out8(PIC1_OCW2, 0x64); /* 把IRQ-12接收信号结束的信息通知给PIC1 */
io_out8(PIC0_OCW2, 0x62); /* 把IRQ-02接收信号结束的信息通知给PIC0 */
data = io_in8(PORT_KEYDAT);
fifo32_put(mousefifo, data + mousedata0);
return;
}
```
### mouse
```c=
void inthandler2c(int *esp)
/* 基于PS/2鼠标的中断 */
{
int data;
io_out8(PIC1_OCW2, 0x64); /* 把IRQ-12接收信号结束的信息通知给PIC1 */
io_out8(PIC0_OCW2, 0x62); /* 把IRQ-02接收信号结束的信息通知给PIC0 */
data = io_in8(PORT_KEYDAT);
fifo32_put(mousefifo, data + mousedata0);
return;
}
```
### HariMain
可以看到 fifobuf 被定義為 128 ，可以看到 keybord 和 mouse timer 緩衝區被換成 fifo
```c=
struct FIFO32 fifo;
char s[40];
int fifobuf[128];
（中略）
fifo32_init(&fifo, 128, fifobuf);
init_keyboard(&fifo, 256);
enable_mouse(&fifo, 512, &mdec);
io_out8(PIC0_IMR, 0xf8); /* 设定PIT和PIC1以及键盘为许可(11111000) */
io_out8(PIC1_IMR, 0xef); /* 设定鼠标为许可(11101111) */
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);
}
}
}
```
## 更改 timer 為 Linked List 資料結構
TIMER 增加一個 struct TIMER *next;
```c=
struct TIMER {
struct TIMER *next;
unsigned int timeout, flags;
struct FIFO32 *fifo;
int data;
};
```
下面這張圖表示為一個TIMER
也就是後面去做多任務切換的時候，總不能每次都去位移 timer
所以後面使用 linked list 去做連接，也就是下面這個圖
### inthandler20
```c=
void inthandler20(int *esp)
{
int i;
struct TIMER *timer;
io_out8(PIC0_OCW2, 0x60); /* 把IRQ-00接收信号结束的信息通知给PIC */
timerctl.count++;
if (timerctl.next > timerctl.count)
{
return;
}
timer = timerctl.timers[0]; /* 首先把最前面的地址赋给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.timers[0] = timer;
/* timerctl.next的设定 */
if (timerctl.using > 0)
{
timerctl.next = timerctl.timers[0]->timeout;
}
else
{
timerctl.next = 0xffffffff;
}
return;
}
```
# timer_settime
比較要著重的是這裡
假設新的 timer 近來之前都是會挑最小timer 往後面做插入的動作，那麼只要把 timer struct next
做調換就可以了
```c=
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.timers[0] = timer;
timer->next = 0; /* 没有下一个 */
timerctl.next = timer->timeout;
io_store_eflags(e);
return;
}
t = timerctl.timers[0];
if (timer->timeout <= t->timeout)
{
/* 插入最前面的情况下 */
timerctl.timers[0] = 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;
}
```
## 哨兵模式
哨兵用于顺序表查找，所谓“哨兵”就是用一个特殊值来作为数组的边界，使用“哨兵”可以少用一条判断语句(少判断了i<n这句)，所以可以提高程序的效率。具体看代码：
https://blog.csdn.net/weixin_42034217/article/details/84715881
```c=
//普通查找代码
int Search_1(int *a,int n,int key)
{
int i;
for(int i=0; i<n; i++)
{
if(a[i]==key)
return i;
}
return 0;//查找失败
}
//带哨兵查找代码
int Search_2(int *a,int n,int key)
{
int i=0;
a[0]=key;//哨兵
i=n;
while(a[i]!=key)
{
i--;
}
return i;//返回0就是查找失败
}
```
有了這些概念加入哨兵模式，哨兵基本上就是新增了邊界點
，settime的状况就变了。4种情况中有2种情况是绝对不会发生的。（下面的
第1种和第4种）
处于运行中的定时器只有这1个的情况
插入最前面的情况
插入s和t之间的情况
插入最后的情况
可以看到下面程式碼 加上最後一個 0xffffffff; 最大值後
流程 第一個 和 最後一個 都可以省略
处于运行中的定时器只有这1个的情况（因为有哨兵，所以最少应该有2个）
插入最前面的情况
插入s和t之间的情况
插入最后的情况（哨兵总是在最后）****
```c=
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; /* 因为只有哨兵，所以下一个超时时刻就是哨兵的时刻 */
timerctl.using = 1;
return;
}
```
### settime 精簡
可以看到 settime 少了兩個判斷，還有既然改用 list 我們的 timerctl.using 也就不用再用了
因為一定會有一個 timer ，然後這個 timerctl.using用來目前用到哪一個 timer
```c=
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 ++;
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;
}
}
}
```
Sign in with Wallet
Connect another wallet