第16天 多任务（2）
2020.4.18
1. 任务管理自动化（harib13a）
- 在bootpack.h中结构体TASK、TASKCTL和TSS的定义：
#define MAX_TASKS 1000 /* 最大任务数量 */
#define TASK_GDT0 3 /* 定义从GDT的几号开始分配给TSS */
struct TSS32 {
int backlink, esp0, ss0, esp1, ss1, esp2, ss2, cr3;
int eip, eflags, eax, ecx, edx, ebx, esp, ebp, esi, edi;
int es, cs, ss, ds, fs, gs;
int ldtr, iomap;
};
struct TASK {
int sel, flags; /* sel用来存放GDT的编号 */
struct TSS32 tss;
};
struct TASKCTL {
int running; /* 正在运行的任务数量 */
int now; /* 正在运行的是哪个任务 */
struct TASK *tasks[MAX_TASKS];
struct TASK tasks0[MAX_TASKS];
};- flags：0未被使用；1正在使用；2正在运行。
- task_init函数(mtask.c)：
struct TASKCTL *taskctl;
struct TIMER *task_timer;
struct TASK *task_init(struct MEMMAN *memman)
{
int i;
struct TASK *task;
struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT; /*获得GDT的初始地址*/
taskctl = (struct TASKCTL *) memman_alloc_4k(memman, sizeof (struct TASKCTL)); /*给任务管理器分配内存*/
for (i = 0; i < MAX_TASKS; i++) {
taskctl->tasks0[i].flags = 0; /*未被使用*/
taskctl->tasks0[i].sel = (TASK_GDT0 + i) * 8; /*分配GDT编号*/
set_segmdesc(gdt + TASK_GDT0 + i, 103, (int) &taskctl->tasks0[i].tss, AR_TSS32); /*为每个任务设置GDT*/
}
task = task_alloc(); /*分配任务*/
task->flags = 2; /* 任务正在活动 */
taskctl->running = 1; /*当前运行任务数是1*/
taskctl->now = 0; /*正在运行的任务编号是0*/
taskctl->tasks[0] = task; /*将该任务归入任务管理器*/
load_tr(task->sel); /*规定当前运行的程序是task任务*/
task_timer = timer_alloc(); /*分配任务定时器*/
timer_settime(task_timer, 2); /*定时器时间*/
return task; /*将task任务返回*/
}- 编写初始化（分配）一个任务的函数task_alloc：
struct TASK *task_alloc(void)
{
int i;
struct TASK *task;
for (i = 0; i < MAX_TASKS; i++) {
if (taskctl->tasks0[i].flags == 0) { /*未被使用*/
task = &taskctl->tasks0[i];
task->flags = 1; /* 正在使用 */
task->tss.eflags = 0x00000202; /* IF = 1; */
task->tss.eax = 0; /* eax暂时设置为0 */
task->tss.ecx = 0;
task->tss.edx = 0;
task->tss.ebx = 0;
task->tss.ebp = 0;
task->tss.esi = 0;
task->tss.edi = 0;
task->tss.es = 0;
task->tss.ds = 0;
task->tss.fs = 0;
task->tss.gs = 0;
task->tss.ldtr = 0;
task->tss.iomap = 0x40000000;
return task;
}
}
return 0; /* 全部都正在使用 */
}- 编写让任务运行的函数task_run：
void task_run(struct TASK *task)
{
task->flags = 2; /* 正在运行中 */
taskctl->tasks[taskctl->running] = task;
taskctl->running++;
return;
}- 编写任务切换函数task_switch：
void task_switch(void)
{
timer_settime(task_timer, 2); /*设置定时器*/
if (taskctl->running >= 2) { /*正在运行的任务个数大于等于2个才进行任务切换*/
taskctl->now++; /*正在运行的任务*/
if (taskctl->now == taskctl->running) {
taskctl->now = 0; /*置零*/
}
farjmp(0, taskctl->tasks[taskctl->now]->sel); /*任务切换*/
}
return;
}- 这个函数时用来代替mt_taskswitch的，因此在timer.c中的inthandler20函数中也需要修改。
- 在bootpack.c中修改HariMain函数：
void HariMain(void)
{
……
struct TASK *task_b;
……
task_init(memman); /*任务管理器初始化，HariMain变成GDT编号为3的任务*/
task_b = task_alloc(); /*为任务b初始化分配*/
/*任务b相关寄存器参数设定*/
task_b->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 8;
task_b->tss.eip = (int) &task_b_main;
task_b->tss.es = 1 * 8;
task_b->tss.cs = 2 * 8;
task_b->tss.ss = 1 * 8;
task_b->tss.ds = 1 * 8;
task_b->tss.fs = 1 * 8;
task_b->tss.gs = 1 * 8;
*((int *) (task_b->tss.esp + 4)) = (int) sht_back;
task_run(task_b); /*运行任务b*/
……
}- 增加任务：只需要先task_alloc，然后配置任务参数，再执行task_run即可。
make之后在VMware上运行，顺利运行。
2. 让任务休眠（harib13b）
- 到目前为止，多任务是建立在两个任务分配大约相同的运行时间的基础上的。运行任务A（HariMain）时CPU基本上都是处于HLT状态（基本上没有键盘鼠标操作，偶尔出现定时器中断）。
- 任务B在拼命计数，任务A却无所事事。与其让A无所事事地HLT，不如把运行时间让给任务B。
- 具体做法：当任务A要HLT的时候，不执行io_hlt，而是将任务A从任务运行列表task中删除，只保留任务B，那么任务B就可以全力计数了。这种将一个任务从任务运行列表中删除的操作，叫做任务休眠。【进程就绪态】
- 当任务A休眠时，FIFO缓冲区有数据过来，那么需要将任务A唤醒。需要运行一次task_run。
- 编写函数task_sleep：
void task_sleep(struct TASK *task)
{
int i;
char ts = 0;
if (task->flags == 2) {/* 指定要休眠的任务处于运行（唤醒）状态 */
if (task == taskctl->tasks[taskctl->now]) {
ts = 1; /* 自己让自己休眠，需要进行任务切换 */
}
/* 寻找要休眠task所在的位置 */
for (i = 0; i < taskctl->running; i++) {
if (taskctl->tasks[i] == task) {
/* 找到了 */
break;
}
}
taskctl->running--; /*正在运行的任务数量-1*/
if (i < taskctl->now) {
taskctl->now--; /* 需要移动成员，正在运行的任务也需要修改 */
}
/* 移动成员 */
for (; i < taskctl->running; i++) {
taskctl->tasks[i] = taskctl->tasks[i + 1];
}
task->flags = 1; /* 休眠任务处于不工作状态 */
if (ts != 0) {
/* 任务切换 */
if (taskctl->now >= taskctl->running) {
/* 如果now的值出现异常，需要修正 */
taskctl->now = 0;
}
farjmp(0, taskctl->tasks[taskctl->now]->sel);
}
}
return;
}- 任务休眠：i.任务A让任务B休眠；ii.任务A让任务A自己休眠（需要进行任务切换）。
- 实现向FIFO缓冲区写入数据时将任务唤醒的功能。
- 修改FIFO缓冲区结构体FIFO32：
struct FIFO32 {
int *buf;
int p, q, size, free, flags;
struct TASK *task;
};- task指向需要唤醒的任务。
- 修改fifo32_init函数：
void fifo32_init(struct FIFO32 *fifo, int size, int *buf, struct TASK *task)
/* FIFO缓冲区初始化 */
{
fifo->size = size;
fifo->buf = buf;
fifo->free = size;
fifo->flags = 0;
fifo->p = 0;
fifo->q = 0;
fifo->task = task; /* 数据写入时要唤醒的任务 */
return;
}- 添加参数task指针，用于指向数据写入FIFO缓冲区时需要唤醒的任务。如果不需要唤醒任务，task=0即可。
- 修改fifo32_put，实现向FIFO缓冲区写入数据时唤醒某个任务的功能：
int fifo32_put(struct FIFO32 *fifo, int data)
/* 向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--;
if (fifo->task != 0) { /*有需要唤醒的任务*/
if (fifo->task->flags != 2) {/*如果任务不处于运行状态*/
task_run(fifo->task); /* 唤醒指定的任务 */
}
}
return 0;
}- 修改HariMain和task_b_main：
void HariMain(void)
{
……
struct TASK *task_a, *task_b;
……
fifo32_init(&fifo, 128, fifobuf, 0); /*暂时没有需要唤醒的任务*/
……
task_a = task_init(memman); /*将程序HariMain变成任务task_a*/
fifo.task = task_a; /*向FIFO指定需要唤醒的任务*/
……
for (;;) {
io_cli();
if (fifo32_status(&fifo) == 0) {
task_sleep(task_a); /*先休眠，再恢复中断标志*/
io_sti();
} else {
……
}
}
}
void task_b_main(struct SHEET *sht_back)
{
……
fifo32_init(&fifo, 128, fifobuf, 0); /*任务B不需要唤醒*/
……
}- harib13a和harib13b任务B计数能力比较（VMware模拟器）：
- harib13a
- harib13b
- 显然，harib13b中任务B的计数能力是harib13b中任务B计数能力的2倍以上！
3. 增加窗口数量（harib13c）
- 任务A和任务B两个任务貌似不符合多任务中的“多”。这次，将B任务分裂成3个任务，即形成任务A、任务B0、任务B1和任务B2的格局。
- 任务B0~B2都是任务B的副本，都执行计数的功能。同时，任务A的3秒定时器和10秒定时器不再需要，故删除之。
- 修改bootpack.c中的HariMain、make_window8和task_b_main函数：
void HariMain(void)
{
……
unsigned char *buf_back, buf_mouse[256], *buf_win, *buf_win_b;
struct SHEET *sht_back, *sht_mouse, *sht_win, *sht_win_b[3];
struct TASK *task_a, *task_b[3];
struct TIMER *timer;
……
/* sht_back */
sht_back = sheet_alloc(shtctl);
buf_back = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);
sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1);
init_screen8(buf_back, binfo->scrnx, binfo->scrny);
/* sht_win_b */
for (i = 0; i < 3; i++) {
sht_win_b[i] = sheet_alloc(shtctl); /*分配图层*/
buf_win_b = (unsigned char *) memman_alloc_4k(memman, 144 * 52); /*分配缓冲区内存空间*/
sheet_setbuf(sht_win_b[i], buf_win_b, 144, 52, -1); /* 设置图层 */
sprintf(s, "task_b%d", i);
make_window8(buf_win_b, 144, 52, s, 0);
task_b[i] = task_alloc();
task_b[i]->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 8;
task_b[i]->tss.eip = (int) &task_b_main;
task_b[i]->tss.es = 1 * 8;
task_b[i]->tss.cs = 2 * 8;
task_b[i]->tss.ss = 1 * 8;
task_b[i]->tss.ds = 1 * 8;
task_b[i]->tss.fs = 1 * 8;
task_b[i]->tss.gs = 1 * 8;
*((int *) (task_b[i]->tss.esp + 4)) = (int) sht_win_b[i];
task_run(task_b[i]);
}
/* sht_win */
sht_win = sheet_alloc(shtctl);
buf_win = (unsigned char *) memman_alloc_4k(memman, 160 * 52);
sheet_setbuf(sht_win, buf_win, 144, 52, -1);
make_window8(buf_win, 144, 52, "task_a", 1);
make_textbox8(sht_win, 8, 28, 128, 16, COL8_FFFFFF);
cursor_x = 8;
cursor_c = COL8_FFFFFF;
timer = timer_alloc();
timer_init(timer, &fifo, 1);
timer_settime(timer, 50);
/* sht_mouse */
sht_mouse = sheet_alloc(shtctl);
sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99);
init_mouse_cursor8(buf_mouse, 99);
mx = (binfo->scrnx - 16) / 2;
my = (binfo->scrny - 28 - 16) / 2;
sheet_slide(sht_back, 0, 0);
sheet_slide(sht_win_b[0], 168, 56);
sheet_slide(sht_win_b[1], 8, 116);
sheet_slide(sht_win_b[2], 168, 116);
sheet_slide(sht_win, 8, 56);
sheet_slide(sht_mouse, mx, my);
sheet_updown(sht_back, 0);
sheet_updown(sht_win_b[0], 1);
sheet_updown(sht_win_b[1], 2);
sheet_updown(sht_win_b[2], 3);
sheet_updown(sht_win, 4);
sheet_updown(sht_mouse, 5);
sprintf(s, "(%3d, %3d)", mx, my);
putfonts8_asc_sht(sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);
sprintf(s, "memory %dMB free : %dKB",
memtotal / (1024 * 1024), memman_total(memman) / 1024);
putfonts8_asc_sht(sht_back, 0, 32, COL8_FFFFFF, COL8_008484, s, 40);
for (;;) {
io_cli();
if (fifo32_status(&fifo) == 0) {
task_sleep(task_a);
io_sti();
} else {
i = fifo32_get(&fifo);
io_sti();
if (256 <= i && i <= 511) { /* 鼠标数据 */
……
} else if (512 <= i && i <= 767) { /* 鼠标数据 */
……
} else if (i <= 1) { /* 光标定时器 */
……
}
}
}
}
void make_window8(unsigned char *buf, int xsize, int ysize, char *title, char act)
{
……
char c, tc, tbc;
if (act != 0) {
tc = COL8_FFFFFF;
tbc = COL8_000084;
} else {
tc = COL8_C6C6C6;
tbc = COL8_848484;
}
……
boxfill8(buf, xsize, tbc, 3, 3, xsize - 4, 20 );
boxfill8(buf, xsize, COL8_848484, 1, ysize - 2, xsize - 2, ysize - 2);
boxfill8(buf, xsize, COL8_000000, 0, ysize - 1, xsize - 1, ysize - 1);
putfonts8_asc(buf, xsize, 24, 4, tc, title);
……
return;
}
void task_b_main(struct SHEET *sht_win_b)
{
……
for (;;) {
count++;
io_cli();
if (fifo32_status(&fifo) == 0) {
io_sti();
} else {
i = fifo32_get(&fifo);
io_sti();
if (i == 100) {
sprintf(s, "%11d", count - count0);
putfonts8_asc_sht(sht_win_b, 24, 28, COL8_000000, COL8_C6C6C6, s, 11);
count0 = count;
timer_settime(timer_1s, 100);
}
}
}
}- HariMain更改了代码顺序。
- make_window8增加了一个参数act。act=1时，颜色不变。act=0时，窗口的标题栏变灰，类似于未被选中的感觉。
- task_b_main中删除了每0.01s显示一次count。只保留每1s显示一次count速度。
make后在VMware上运行:
- 由于没有修改窗口移动的代码，现在还是只能移动task_a的窗口。
- task_b0~b2的每秒计数差不多，这说明运行时成功的。
4. 设定任务优先级（1）（harib13d）
- 任务B0~B2以同样的速度运行，这样貌似很公平。在实际情况下，我们需要打破这种公平，调整任务的优先级，让任务占用CPU的时间出现差异。
- 具体做法：任务切换时间不再是固定的0.02s，而是每个任务维护一个优先级变量，这个优先级使得该任务在0.01s~0.1s的范围内设定不同的任务切换间隔。显然，优先级为0.1s的任务优先性最高（占用CPU时间越高，优先级越高）。
- 修改TASK结构体：
struct TASK {
int sel, flags;
int priority;
struct TSS32 tss;
};- priority是优先级的意思，priority=2，代表该任务每次占用CPU的时间是0.02s。
- 改写mtask.c中的相关函数：
- 修改task_init：
struct TASK *task_init(struct MEMMAN *memman)
{
……
task = task_alloc();
task->flags = 2; /* 正在运行 */
task->priority = 2; /* 0.02s */
taskctl->running = 1;
taskctl->now = 0;
taskctl->tasks[0] = task;
load_tr(task->sel);
task_timer = timer_alloc();
timer_settime(task_timer, task->priority); /*根据优先级设置定时器*/
return task;
}- 修改task_run：
void task_run(struct TASK *task, int priority)
{
if (priority > 0) {
task->priority = priority;
}
if (task->flags != 2) {
task->flags = 2; /* 正在运行中 */
taskctl->tasks[taskctl->running] = task;
taskctl->running++;
}
return;
}- 增加参数priority，根据该参数设定任务的优先级。
- 规定，当priority=0时，不改变任务的优先级。 这主要是在唤醒任务时使用。
- 即使任务正在运行，我们也可以调用task_run来强行改变任务的优先级。
- 修改task_switch，让它在设定能够定时器的时候，应用priority的值：
void task_switch(void)
{
struct TASK *task;
taskctl->now++;
if (taskctl->now == taskctl->running) {
taskctl->now = 0;
}
task = taskctl->tasks[taskctl->now];
timer_settime(task_timer, task->priority); /*根据任务的优先级设置定时器*/
if (taskctl->running >= 2) {
farjmp(0, task->sel);
}
return;
}- 修改fifo.c中的fifo32_put函数：
int fifo32_put(struct FIFO32 *fifo, int data)
{
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--;
if (fifo->task != 0) {
if (fifo->task->flags != 2) { /* 任务处于休眠状态的话 */
task_run(fifo->task, 0); /* priority=0 */
}
}
return 0;
}- 任务从休眠中唤醒需要调用task_run，此时，只是唤醒任务，不需要修改优先级，因此只需要将priority设置为0。
- 修改HariMain():
void HariMain(void)
{
……
for (i = 0; i < 3; i ++){
……
task_run(task_b[i], i + 1);
}
……
}- 将任务B0的优先级设置为1，B1的优先级设置为2，B2的优先级设置为3。这样，B1的速度应该是B0的2倍，B2的速度应该是B0的3倍。
make后在VMware上运行：
- 在误差允许范围内，B2的速度是B0的3倍，B1的速度是B0的2倍。
5. 设定任务优先级（2）（harib13e）
- 优先级是一个很好用的东西。在OS中，有一些处理，即使牺牲其他任务的性能也要尽快完成，否则对用户会不友好。比如，对鼠标的处理，我们可以让它在处理结束后马上休眠，而优先级可以设置得非常高。
- 类似的处理还有：键盘处理，网络处理，播放音乐等。
- 把这些操作的优先级都设置成10。但这样又会出现问题，比如，当播放音乐任务和鼠标处理任务同时进行时，优先哪个得凭运气了。运气好的那个任务会消耗较长的时间来完成它的工作，而另一个只能等待。
- 显然，播放音乐的优先级应该更高，用户可不想听音乐一卡一卡的，而鼠标反应稍微慢一点仍然是可以容忍的。
- 因此，需要一种数据结构，即便是最高优先级的几个任务同时运行，也能区分那个更加优先。
- 具体数据结构：
- 实例化几个结构体TASKCTL（这里以3个为例）。
- 工作原理
- 最上层的LEVEL0中只要存在哪怕一个任务，那么久完全忽略LEVEL1和LEVEL2中的任务，只在LEVEL0中进行任务切换。
- 当LEVEL0中的任务全部休眠，或者全部降级到下层LEVEL（也就是当LEVEL0中没有任何任务的时候），接下来开始轮到LEVEL1中的任务进行任务切换。
- 当LEVEL0和LEVEL1中的任务都休眠或者LEVEL0和LEVEL1中没有任务的时候，就轮到在LEVEL2中进行任务切换了。
- 在这种结构下，只需要把音乐播放放在LEVEL0中就可以获得比鼠标更高的优先级了。
- 定义结构体TASKLEVEL：
#define MAX_TASKS_LV 100
#define MAX_TASKLEVELS 10
struct TASKLEVEL {
int running; /* 当前LEVEL正在运行的任务数量 */
int now; /* 记录当前正在运行的是哪个任务 */
struct TASK *tasks[MAX_TASKS_LV]; /*该LEVEL对应的任务列表*/
};- 修改结构体TASKCTL：
struct TASKCTL {
int now_lv; /* 正在运行中的LEVEL */
char lv_change; /* 在下次任务切换时是否需要改变LEVEL */
struct TASKLEVEL level[MAX_TASKLEVELS]; /*对应每层的LEVEL*/
struct TASK tasks0[MAX_TASKS]; /*所有的任务*/
};- 规定：每层LEVEL最多允许创建100个任务，总共10个LEVEL。
- 编写用于操作TASKLEVEL的函数（mtask.c）：
- task_now函数：用于返回正在CPU运行的任务的地址
struct TASK *task_now(void)
{
/*先获得正在运行任务所在的LEVEL*/
struct TASKLEVEL *tl = &taskctl->level[taskctl->now_lv];
/*返回正在运行的任务的地址*/
return tl->tasks[tl->now];
}- task_add函数：用于向LEVEL添加一个任务，此时该任务已经可以运行
void task_add(struct TASK *task)
{
/*先获得正在运行任务所在的LEVEL*/
struct TASKLEVEL *tl = &taskctl->level[task->level];
tl->tasks[tl->running] = task; /*添加该任务*/
tl->running++;
task->flags = 2; /* 正在运行 */
return;
}- 这里应该增加代码
if (tl->running < MAX_TASKS_LV)，判断一个LEVEL中是否添加了超过100个任务。这里暂时省略。
- task_remove函数：从LEVEL中删除一个任务
void task_remove(struct TASK *task)
{
int i;
/*获取当前运行LEVEL*/
struct TASKLEVEL *tl = &taskctl->level[task->level];
/* 寻找要删除的task所在位置 */
for (i = 0; i < tl->running; i++) {
if (tl->tasks[i] == task) {
/* 找到了 */
break;
}
}
tl->running--;
if (i < tl->now) {
tl->now--; /* 需要移动成员，当前LEVEL正在运行的任务需要修改 */
}
if (tl->now >= tl->running) {
/* 如果now的值出现异常，修正 */
tl->now = 0;
}
task->flags = 1; /* 将任务休眠 */
/* 移动 */
for (; i < tl->running; i++) {
tl->tasks[i] = tl->tasks[i + 1];
}
return;
}- task_switchsub函数：用于在任务切换时决定接下来切换到哪个LEVEL
void task_switchsub(void)
{
int i;
/* 寻找最上层的LEVEL */
for (i = 0; i < MAX_TASKLEVELS; i++) {
if (taskctl->level[i].running > 0) { /*当前LEVEL有正在运行的任务*/
break; /* 就是这层，找到了 */
}
}
taskctl->now_lv = i; /*就在这层运行*/
taskctl->lv_change = 0; /*因为这层LEVEL还有任务，所以不需要切换LEVEL*/
return;
}- 修改task_init函数：
struct TASK *task_init(struct MEMMAN *memman)
{
……
for (i = 0; i < MAX_TASKS; i++) {
taskctl->tasks0[i].flags = 0;
taskctl->tasks0[i].sel = (TASK_GDT0 + i) * 8;
set_segmdesc(gdt + TASK_GDT0 + i, 103, (int) &taskctl->tasks0[i].tss, AR_TSS32);
}
for (i = 0; i < MAX_TASKLEVELS; i++) { /*每层LEVEL初始化*/
taskctl->level[i].running = 0;
taskctl->level[i].now = 0;
}
task = task_alloc();
task->flags = 2; /* 正在运行 */
task->priority = 2; /* 0.02s */
task->level = 0; /* HariMain处于第0层 */
task_add(task); /* 添加task任务*/
task_switchsub(); /* 确定运行的LEVEL */
load_tr(task->sel);
task_timer = timer_alloc();
timer_settime(task_timer, task->priority);
return task;
}- task_alloc函数没什么变化，所以不需要修改。
- 修改task_run：难点
void task_run(struct TASK *task, int level, int priority)
{
if (level < 0) {
level = task->level; /* 负数代表不改变LEVEL */
}
if (priority > 0) {
task->priority = priority;
}
if (task->flags == 2 && task->level != level) { /* 改变此任务的LEVEL */
task_remove(task); /* 先将task从它所属的LEVEL去除，此时task->flags=1，下面的if会被执行 */
}
if (task->flags != 2) {
/* 从休眠状态唤醒 */
task->level = level; /*修改LEVEL*/
task_add(task); /*在该层添加task*/
}
taskctl->lv_change = 1; /* 下次任务切换时检查LEVEL */
return;
}- task_add是运行一个任务。task_run是改变任务的level和优先级。
- 添加了参数level，代表此任务需要在第几LEVEL运行。
- 如果启动的这个任务的LEVEL比正在活动中的任务的LEVEL更高，那么下次任务切换时，必须无条件地跳转到该LEVEL中去。
- 如果当前活动中的任务LEVEL被下调，那么必须将其他LEVEL任务放在优先的位置。
- 只要运行task_run，下次任务切换就需要检查LEVEL。
- 修改task_sleep：
void task_sleep(struct TASK *task)
{
struct TASK *now_task;
if (task->flags == 2) {
/* 正在运行 */
now_task = task_now();
task_remove(task); /* 调用remove，执行后flag=1 */
if (task == now_task) {
/* 自己让自己休眠，需要进行任务切换 */
task_switchsub(); /*LEVEL*/
now_task = task_now(); /* 获取当前运行的任务 */
farjmp(0, now_task->sel);
}
}
return;
}- 修改task_switch：
void task_switch(void)
{
struct TASKLEVEL *tl = &taskctl->level[taskctl->now_lv];
struct TASK *new_task, *now_task = tl->tasks[tl->now];
tl->now++;
if (tl->now == tl->running) {
tl->now = 0; /*继续从当前LEVEL的开头运行*/
}
if (taskctl->lv_change != 0) { /*需要调查LEVEL*/
task_switchsub();
tl = &taskctl->level[taskctl->now_lv];
}
new_task = tl->tasks[tl->now];
timer_settime(task_timer, new_task->priority);
if (new_task != now_task) { /*保证下一个任务不是当前任务*/
farjmp(0, new_task->sel);
}
return;
}- 修改fifo.c中唤醒任务的代码：
int fifo32_put(struct FIFO32 *fifo, int data)
{
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--;
if (fifo->task != 0) {
if (fifo->task->flags != 2) { /* 休眠中 */
task_run(fifo->task, -1, 0); /* 任务唤醒，不更改LEVEL和priority */
}
}
return 0;
}- 修改HariMain，将任务A设置为LEVEL1，任务B0~B2设置为LEVEL2。优先级同harib12d。
void HariMain(void){
……
task_run(task_a, 1, 2);
……
for (i = 0; i < 3; i ++){
……
task_run(task_b[i], 2, i + 1);
}
……
}make后用VMware运行：
- 运行后不进行任何操作，画面和harib13d一模一样。
- 疯狂拖动鼠标移动，B0~B2任务会变得很慢。
- 多任务终于完成了。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
