[操作系统课程设计]Spooling假脱机输入输出模拟

题目要求

使用说明

  按提示输入用户进程需要输出文件的数量pcb[0].count和pcb[1].count，程序就能按要求输出pcb[0].count+pcb[1].count行，每行表示一个文件，以0结尾。
 代码第16行outputhelp变量表示是否输出详细过程，默认为false不输出，将其改为true后，程序可以输出调度的细节。
 代码第51行定义的Seed变量是随机种子，修改它的初值可以影响随机数的生成，从而影响程序运行结果。
 以pcb[0].count=21，pcb[1].count=2为例，运行结果为：

#include <cstdio>
#include <time.h>
#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
using namespace std;

#define READY_STATUS                0//就绪状态
#define WAIT_BUFFER_STATUS          1//等待状态1，表示输出井满，请求输出的用户进程等待；
#define WAIT_REQUEST_STATUS         2//等待状态2，表示请求输出井空，SP00LING输出进程等待；
#define WAIT_REQBLOCK_STATUS        3//等待状态3，表示请求输出井满，请求输出的用户进程等待；
#define FINISH_STATUS               4//结束态，进程执行完成。
#define RUN_STATUS                  5//运行态，表示正在运行

const bool outputhelp = false;

struct PCB {
    int id;         //进程标识数
    int status;     //进程状态
    int count;      //要输出的文件数
    int tmp_x;      //进程输出时的临时变量
}pcb[3];

int FINISH_STATUS_PCB_CNT;//处于结束态的进程个数

//请求输出块reqblock
struct Reqblock{
    int reqname;//请求进程名
    int length; //本次输出信息长度
    int addr;   //信息在输出井的首地址
}reqblock[10];

int buffer[2][100]; //两个输出井
int EMPTY_BUF_COUNT[2];  //分别表示两个用户进程可使用的输出井的空间

int BUF_BEGIN[2];//buffer[i]的第一个满缓冲指针
int BUF_END[2];//buffer[i]的第一个空缓冲指针

int REQBLOCK_COUNT;//请求块结构也有一个计数器
int ptr_begin,ptr_end;//表示请求输出块使用情况

void user_thread0();//用户进程0
void user_thread1();//用户进程1
void request(int pid);//将用户进程输出送入输出井
void spooling();//将输出井数据输出到显示器
int schedule();//调度进程


double random() { //生成0~1随机数
    static double Seed = 233;  //随机种子，在此处可改变初值
    Seed = 125.0 * (Seed + 1.0);
    Seed = Seed - 8192.0 * (int)(Seed/8192);
    return (Seed+0.5)/8192;
}


void init() {
    //对各进程的PCB、输出请求快、输出井初始化
    for (int i = 0; i < 3; i++) {
        pcb[i].id = i;
        pcb[i].status = READY_STATUS;
    }
    pcb[2].status = WAIT_REQUEST_STATUS;
    for (int i = 0; i < 10; i++) {
        reqblock[i].reqname = -1;
        reqblock[i].length = 0;
        reqblock[i].addr = 0;
    }
    EMPTY_BUF_COUNT[0] = EMPTY_BUF_COUNT[1] = 100;

    BUF_BEGIN[0] = BUF_END[0] = 0;
    BUF_BEGIN[1] = BUF_END[1] = 1;
    REQBLOCK_COUNT = 10;
    ptr_begin = ptr_end = 0;

    for (int i = 0 ;i < 2; i++) {
        printf("请输入进程%d申请输出文件数:\n",i);
        scanf("%d",&pcb[i].count);
    }
    FINISH_STATUS_PCB_CNT = 0;
}

void user_thread0() {
    pcb[0].tmp_x =  static_cast<int>(random()*10);
    //cout <<"第0号进程申请输出"<<pcb[0].tmp_x<<"\n";
    pcb[0].status = RUN_STATUS;
    request(0);
}

void user_thread1() {
    pcb[1].tmp_x = static_cast<int>(random()*10);
    //cout <<"第1号进程申请输出"<<pcb[1].tmp_x<<"\n";
    pcb[1].status = RUN_STATUS;
    request(1);
}

void request(int pid) {

    while (EMPTY_BUF_COUNT[pid] == 0) {
        if(outputhelp) printf("输出井已满,进程%d等待\n",pid);
        pcb[pid].status = WAIT_BUFFER_STATUS;
        //转spooling
        spooling();
    }

    buffer[pid][BUF_END[pid]] = pcb[pid].tmp_x;//修改空缓冲区
//printf("buff[%d][%d]=%d\n",pid,BUF_END[pid],pcb[pid].tmp_x);
    BUF_END[pid]++;
    if (BUF_END[pid] == 100)
        BUF_END[pid] = 0;
    EMPTY_BUF_COUNT[pid]--;

    if (pcb[pid].tmp_x == 0) { //一个文件输出结束
        if(outputhelp) printf("进程%d完成一个文件\n",pid);
        while (REQBLOCK_COUNT == 0) {
            if(outputhelp) printf("进程%d输出因缺少空闲请求块等待\n",pid);
            pcb[pid].status = WAIT_REQBLOCK_STATUS;
            spooling();
        }
        //将文件在输出井的位置和长度填入空闲请求块
        reqblock[ptr_end].reqname = pid;
        reqblock[ptr_end].addr = BUF_BEGIN[pid];
        reqblock[ptr_end].length = BUF_END[pid]>BUF_BEGIN[pid] ? BUF_END[pid]-BUF_BEGIN[pid] :
                                                                 100+BUF_END[pid]-BUF_BEGIN[pid];
        if(outputhelp) printf("空闲请求块申请成功，位置:%d,长度%d\n",reqblock[ptr_end].addr,reqblock[ptr_end].length);
        ptr_end++;
        BUF_BEGIN[pid] = BUF_END[pid];
        if (ptr_end == 10)
            ptr_end = 0;
        REQBLOCK_COUNT--;//空闲请求块数减1
        if (pcb[2].status == WAIT_REQUEST_STATUS) {//SPOOLING进程是等待状态
            //唤醒SPOOLING进程
             pcb[2].status = RUN_STATUS;
           //  thread(spooling).join();
             spooling();
        }

        pcb[pid].count--;//完成一个文件
        if (outputhelp)
            cout << "进程" << pid << "完成一个文件，还剩" << pcb[pid].count << "个文件\n";
        if (pcb[pid].count == 0) {
            pcb[pid].status = FINISH_STATUS;
            FINISH_STATUS_PCB_CNT++;
            if(outputhelp)
               cout << "进程" << pid << "运行结束\n";
            //进程i运行结束
            return;//转进程调度
        } else {
            //本文件未结束，继续输出
            if (pid==0)
                user_thread0();
            else
                user_thread1();
        }
    } else {
       //还有其他文件输出
      if (pid==0)
        user_thread0();
      else
        user_thread1();
    }
}


void spooling() {
    if(outputhelp) cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~进入spooling~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
    int pid = 2;
    pcb[pid].status = RUN_STATUS;
    if (REQBLOCK_COUNT == 10) {//请求输出块空
        if (outputhelp) cout<<"spooling请求输出块空\n";
        if (pcb[0].status==FINISH_STATUS && pcb[1].status==FINISH_STATUS) {//两个请求输出的进程结束了
            pcb[pid].status = FINISH_STATUS;
            FINISH_STATUS_PCB_CNT++;
            //SPOOLING进程结束
            if(outputhelp) puts("太好了！所以工作完成了！");
            return;
        }
        else {
            pcb[pid].status = WAIT_REQUEST_STATUS;
            if (outputhelp) puts("无申请块,SPOOLING进程等待");
            return;//SPOOLING进程等待
        }
    }

    int buf_begin = reqblock[ptr_begin].addr;
    int buf_end = (buf_begin + reqblock[ptr_begin].length)%100;
    int userpid = reqblock[ptr_begin].reqname;

    if(outputhelp) printf("下面是来自进程%d的输出:\n",userpid);
    for (int i = buf_begin; i != buf_end; i=(i+1)%100)
        printf("%d ",buffer[userpid][i]);
    puts("");
    if(outputhelp) puts("~~~~~~~~~~~~~~~~~~~~~~~spooling输出完成~~~~~~~~~~~~~~~~~~~~~~~~~~");
    EMPTY_BUF_COUNT[userpid] += reqblock[ptr_begin].length;//释放输出井空间
    for (int i = 0; i < 2; i++)
        if (pcb[i].status == WAIT_BUFFER_STATUS) {
            pcb[i].status = RUN_STATUS;//唤醒相应进程
            if (outputhelp) printf("进程%d又可以执行了\n",userpid);
         }
    ptr_begin++;//释放该请求输出块
    if (ptr_begin == 10)
        ptr_begin -= 10;
    REQBLOCK_COUNT++;
    for (int i = 0; i < 2; i++)
        if (pcb[i].status == WAIT_REQBLOCK_STATUS) {
            pcb[i].status = RUN_STATUS;//唤醒相应进程
            if (outputhelp) printf("进程%d又可以执行了\n",userpid);
        }

    pcb[pid].status = READY_STATUS;
}


int schedule() {
    float rand_num =random();
    if (rand_num <= 0.45 && pcb[0].status==READY_STATUS) {
        if (outputhelp) puts("schedule::调用用户进程0");
        user_thread0();
        return 0;
    }
    if (rand_num <= 0.9 && pcb[1].status==READY_STATUS) {
        if (outputhelp) puts("schedule::调用用户进程1");
        user_thread1();
        return 1;
    }
    if (pcb[2].status == READY_STATUS) {
        if (outputhelp) puts("schedule::调用spooling");
        spooling();
        return 2;
    }
    return -1;
}

int main() {
    init();//对各进程的PCB、输出请求快、输出井初始化
    while (FINISH_STATUS_PCB_CNT < 3) {
        schedule();
    }
    return 0;
}

将outputhelp值设为true后，进行同样操作，可以得到详细的过程