MacOS环境-手写操作系统-32-进程挂起和恢复原创

进程挂起和恢复

1.简介

有了进程的自动调度后接下来的任务在于

如何将空闲进程挂起空闲进程往往是那些没有具体任务需要处理的进程

因此如果继续让其运行的话那么必然会耗费宝贵的CPU资源

如果能让它先挂起等到它需要执行具体任务时再把它调度到前台那才是一种合理的进程管理机制

我们实现的进程调度是依赖于进程控制器

也就是taskctl中的任务数组来实现的当我们想要启动某个进程时

在该数组中找到对应的任务对象然后把它加载到CPU那就可以了

2.代码

修改multi_task.c 增加一个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;
        }

    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) {
        //如果当前挂起的任务正好是当前正在前台运行的任务，那么将第0个任务调度到前台
        if (taskctl->now >= taskctl->running) {
            taskctl->now = 0;
        }

       farjmp(0, taskctl->tasks[taskctl->now]->sel);
    }

   }

   return;
}

该函数的逻辑是根据要挂起的任务在整个任务数组中查找找到其对应的数组下标

然后把后面的任务向前覆盖这样的话要移除的任务就在数组中就会被覆盖掉

从而实现将任务从数组中移除的目的

需要注意的是如果要挂起的任务正好是当前正在前台运行的进程那么ts==1

我们就把下标为0的任务调度到前台并且把任务的数量也就是running的值减一

这样处于数组最后的那个任务将不会有机会被调度

任务挂起是实现了那么当我们想重新把任务调度到前台时

我们可以利用现有的队列机制一旦鼠标键盘的事件发生时

我们会把硬件产生的数据加入到他们对应的队列中然后在CMain主循环中将队列中的数据取出来处理

同理当我们挂起一个任务时我们把挂起的任务对象放入到一个队列中当想要重新调度这个对象时

我们往队列里发送一个数据然后在主循环中对该队列进行检查

一旦发现队列中含有数据的话那么就把队列中寄存的任务重新加入调度数组

代码修改如下，在global_define.c中

void fifo8_init(struct FIFO8 *fifo, int size, unsigned char *buf, 
    struct TASK *task) {
    fifo->size = size;
    fifo->buf = buf;
    fifo->free = size;
    fifo->flags = 0;
    fifo->p = 0;
    fifo->q = 0;
    fifo->task = task;
    return ;
}

在初始化一个队列时把一个任务对象添加进去

如果队列不需要寄存任务对象那么把task设置为0就可以

int fifo8_put(struct FIFO8 *fifo, unsigned char data) {
    if (fifo == 0) {
        return -1;
    }    

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

当队列中有数据加入时顺便查看该队列是否寄存着一个任务对象

如果是那么把该任务对象加入调度数组

由于timer.c中对计时器的运行需要使用到队列既然队列的数据结构有变动

因此timer.c中需要做一点小改动

static struct TIMERCTL timerctl;
extern struct TIMER *task_timer;

void  init_pit(void) {
    io_out8(PIT_CTRL, 0x34);
    io_out8(PIT_CNT0, 0x9c);
    io_out8(PIT_CNT0, 0x2e);

    timerctl.count = 0;
    int i;
    for (i = 0; i < MAX_TIMER; i++) {
        timerctl.timer[i].flags = 0; //not used
        timerctl.timer[i].fifo = 0;
    }
}

上面的改动在于把每个timer对象的fifo队列成员设置为0

接下来的改动主要在主入口CMain函数中

void CMain(void) {
    ....
    fifo8_init(&timerinfo, 8, timerbuf, 0);
    ....
    fifo8_init(&keyinfo, 32, keybuf, 0);
    ....
    task_a = task_init(memman);
    keyinfo.task = task_a;
    ....
}

上面代码的逻辑是先通过task_init得到CMain函数所对应的任务对象

并把该任务对象寄存在键盘事件列表中也就是

keyinfo.task = task_a;

void CMain(void) {
    ....
    task_run(task_b);
    ...
    int pos = 0;
    int stop_task_A = 0;
     for(;;) {

       io_cli();
       ....
       else if (fifo8_status(&timerinfo) != 0) {
           io_sti();
           int i = fifo8_get(&timerinfo);
           if (i == 10) {
                showString(shtctl, sht_back, pos, 144, COL8_FFFFFF,
                 "A"); 

                timer_settime(timer, 100);
                pos += 8;
                if (pos > 40 && stop_task_A == 0) {
                    io_cli();
                    task_sleep(task_a);
                    io_sti();
                 }
           }
       ....
    }
}

上面代码的逻辑时当CMain函数在主循环中

连续打印字符”A”,当打印的字符超过5个时

通过task_sleep(task_a)把CMain进程挂起

这样的话系统运行时我们会发现原来是字符A和B 是同时打印到桌面上的

此时便只剩下字符B在继续打印了

由于我们把task_A寄存到键盘队列那么当我们点击键盘

键盘数据就会存储到键盘队列中

由于键盘队列存储了任务Ad的任务对象

那么此时他会把对应任务对象重新加入到调度队列中

由此字符A会从恢复打印状态也就是说打印字符A的进程重新获得了被调度的机会