第16天

继续多任务之旅。前一天实现了两个任务之间自动切换，今天开始写一个更通用的多任务切换程序。

首先定义存储每个任务的数据结构。

struct TASK {
  int sel, flags; 
  struct TSS32 tss;
};

sel表现段先择器，也就是CS的值，flags用于标记该任务是否被使用。

再创建一个用于存储操作系统中所有任务的数据结构。

struct TASKCTL {
  int running; 
  int now; 
  struct TASK *tasks[MAX_TASKS];
  struct TASK tasks0[MAX_TASKS];
};

数据结构有了，然后进行操作，首先我们想创建一个任务，先要获得TASKCTL中的某一个task0。

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;
      task->tss.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;
}

在TASKCTL中寻找一个还未使用的task用于存储，并对task结构进行初使化赋值，然后返回task的地址。

操作系统一开始运行的时候是单任务的，在进行到多任务管理之前，要先初使化TASKCTL数据结构，并为TASK数组申请内存空间，在多任务功能创建完毕之后，还要把自己本身纳入多任务管理的范围内。也就是说操作系统一启动，一开机时候，显示了桌面，第一个任务就是它自己本身。

struct TASK *task_init(struct MEMMAN *memman)
{
  int i;
  struct TASK *task;
   struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_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;
    set_segmdesc(gdt + TASK_GDT0 + i, 103, (int) &taskctl->tasks0[i].tss, AR_TSS32);
  }
  task = task_alloc();
  task->flags = 2; 
  taskctl->running = 1;
  taskctl->now = 0;
  taskctl->tasks[0] = task;
  load_tr(task->sel);
  task_timer = timer_alloc();
  timer_settime(task_timer, 2);
  return task;
}

首先定义一个TASKCTL类型的变量，并分配内存空间，然后用循环语句为这个变量赋初始值，flags全部赋为0，因为还未开始使用。然后为每个任务分配gdt序号。再申请一个task，把操作系统当前运行的任务放进去，并设置2ms的定时器。

用task_alloc函数取得task变量之后，再调用task_run函数运行。

void task_run(struct TASK *task)
{
  task->flags = 2; 
  taskctl->tasks[taskctl->running] = task;
  taskctl->running++;
  return;
}

在init_task函数中已经设置了2ms的定时器，定时器超时的时候，会调用task_switch函数

void task_switch(void)
{
  timer_settime(task_timer, 2);
  if (taskctl->running >= 2) {
    taskctl->now++;
    if (taskctl->now == taskctl->running) {
      taskctl->now = 0;
    }
    farjmp(0, taskctl->tasks[taskctl->now]->sel);
  }
  return;
}

先设置2ms定时器，然后判断任务数，任务数如果只有一个就不用切换了。如果多于1个，那么切换到下一个任务。如果已经是最后一个任务，那么就运行第一个任务，重新循环一次。改造之后的多任务程序看上去就好多了，不管什么任务，只要alloc一个，放进run里面，操作系统会自动且平均分配2ms的时间运行。平均分配时间也有缺点，如果一个任务创建之后都没有使用，那么也分配2ms的话就太浪费cpu的计算能力了，我们就实现让任务休眠的机制。

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--;
    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;
}

首先判断准务休眠的任务是不是当前正在运行的任务。然后寻找将要休眠的任务所处于TASKCTL变量中的位置，然后将这个位置覆盖，如果判断是正在运行的任务马上切换任务。将下来的问题是接收鼠标、键盘或者其它中断后，如何唤醒体眠的任务。

每次中断发生后都会往消息队列中发送数据，如果唤醒某一个任务也应该从队列入手。改造队列的数据结构，增加存储TASK指针的字段。

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

然后在中断处理程序往消息队列写入数据的时候将任务唤醒，我们修改一下入队函数。

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); 
    }
  }
  return 0;
}

增加了return 0之前的5行，就是说中断处理程序往队列中写入消息的时候，判断当前队列所代表的任务是否处于活动状态，如果休眠的话那就唤醒。

接下来我们另外再创建3个任务，每个任务都显示一下窗口，在窗口中只做一件事情，那就是不停得计数并把计数结果显示到窗口上。

要实现也比较简单，先创建3个TASK类型的指针，再调用task_alloc函数分配任务存储空间。创建SHEET指针，再调用sheet_alloc函数分配存储空间。再调用task_run函数运行。

我在看源代码时候看到3个窗口任务的入口地址都是task_b_main函数，突然有一个疑问，入口地址都是一样的的，那么这个函数中定义的变量和消息队列会不会混淆。前前后后看了好几遍，task_b[i]->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 8;这句程序为每个任务申请了不同的栈空间。程序入口函数中定义的int i; int fifobuf[128],虽然是在入口函数中直接定义，但是C语言分配内存空间的时候是把栈中的内存空间拿过来使用。所以虽然的任务入口函数是一样的，程序的入口也在内存中的同一位置，但是每个任务所使用的数据都是不一样的。通过近半个小时的思考，我觉得对C语言的内存分配方式有了更加深入的了解。

我们现在为每个任务平均分配了2ms的运行时间，但是如果要把操作系统做得更好，肯定要分出任务的轻重缓急，也就是要设置每个任务的优先级。我们可以设置10 个等级，分配运行的时间从0.01秒~0.1秒。在TASK结构体中增加int priority字段，用于表示优先级。我们把任务a设置成10，也就是说任务a运行的时间有0.1秒，但是由于a不运行的时候会自动休眠，所以也不会影响其他任务的运行。

运用为任务分配定时器的时间方式是最简单的方式。如果任务A是最重要的，只是给A设置高一点的优先级，那么其他任务还是会运行。有时候我们会碰到一种情况，希望如果任务A需要运行，那么在任务A运行完之前其它任务都不能运行。

我们假设给任务分3个等级，分别是level0~2。其中level0优先级最高，如果level0里的任务需要运行，那么，level1和2都不能运行。

之前我们处理多任务的数据结构有2层，首先是表示具体任务的TASK结构，然后是把TASK结构统一管理的TASKCTL结构。现在我们在这两者之前增加TASKLEVEL结构，用于表示任务的级别关系。

struct TASK {
  int sel, flags; 
  int level, priority;
  struct TSS32 tss;
};

level变量表示任务所处的级别。

struct TASKLEVEL {
  int running; /* 正在运行的任务数量 */
  int now; /* 这个变量表示正在运行的是哪个任务 */
  struct TASK *tasks[MAX_TASKS_LV];
};

struct TASKCTL {
  int now_lv; /* 现在活动中的LEVEL */
  char lv_change; /* 在下次任务切换时是否需要改变LEVEL */
  struct TASKLEVEL level[MAX_TASKLEVELS];
  struct TASK tasks0[MAX_TASKS];
};

现在TASKCTL不再直接是管理任务，而是管理TASKLEVEL，再由TASKLEVEL管理各个任务。书中处理这部分代码不是很复杂，我也就不贴出来了。主要注意的地方是task_switch函数里如果TASKCTL中lv_change字段为1就要重新查看LEVEL是否有新的更高级的层次任务需要执行。