SPOOLING技术

最新推荐文章于 2021-03-12 22:23:45 发布
最新推荐文章于 2021-03-12 22:23:45 发布
阅读量1.6k 收藏 9
点赞数 1
分类专栏： 操作系统 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43576794/article/details/109856725
版权

实验七SPOOLING技术

【实验目的】
理解和掌握SPOOLING假脱机技术

【实验内容】
通过SPOOLING技术可将一台物理I/O设备虚拟为多台逻辑I/O设备，同样允许多个用户共享一台物理I/O设备，从而使其成为虚拟设备。该技术广泛应用与各种计算机的I/O，通过采用预输入和缓输出的方法，使用共享设备的一部分空间来模拟独占设备，以提高独占设备的利用率。
【实验步骤】
程序代码：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<iostream>
using namespace std;
struct REQ{
    int ioblock_id;//要求输出进程标识数
    int block_len;//本次输出长度
    int block_start;//本次输出的首地址
    REQ* next;
};
REQ *head=NULL,*tail=NULL;
struct PCB{
    int id;//进程标识数
    int state;//进程状态
    REQ* point;//输出指针(指向上次断点)
    int start;//信息块首地址
    int length;//输出长度
    int buffer;//输出缓冲字(-1表示没有断点)
};
PCB pcb[2];
FILE *f;
int freeioblock=10;//空闲输出请求块计数器
int freepoollen[2]={100,100};//两个输出井的计数器
int count[2];//用来控制两个请求输出进程的输出文件数，避免系统无限制循环下去
int buffer[2][100];
void init();
void scheduler();
void userproc(int i);
void spooling();
int main()
{
   init();
   scheduler();
   cout<<endl;
   cout<<"buffer[0] "<<endl;
   for(int m=0;m<100;m++)
    {
        if(m%10==0)
        cout<<endl;
        cout<<buffer[0][m];
   }
   cout<<endl;
   cout<<"buffer[1] "<<endl;
    for(int m=0;m<100;m++)
    {
        if(m%10==0)
        cout<<endl;
        cout<<buffer[1][m];
   }
   return 0;
}
void init()
{
    int i,n;
    f=fopen("out.txt","w");
    for(i=0;i<2;i++)
        for(n=0;n<100;n++)
        buffer[i][n]=0;
        for(i=0;i<2;i++){
            pcb[i].id=i;
            pcb[i].state=0;
            pcb[i].start=0;
            pcb[i].buffer=-1;
        }
        printf("输入用户1输出文件的次数  ");
        fprintf(f,"输入用户1输出文件的次数  ");
        scanf("%d",&count[0]);
        fprintf(f,"%d\n",count[0]);
        printf("输入用户2输出文件的次数 ");
        fprintf(f,"输入用户2输出文件的次数 ");
        scanf("%d",&count[1]);
        fprintf(f,"%d\n",count[1]);
}
void scheduler()
{
    int i;
     srand((unsigned)time(NULL));
        while(1){
            i=rand()%100;
            cout<<endl;
            cout<<"选择随机数i的值： "<<i<<endl;
            if(i<=45){
                if((pcb[0].state==0)&&count[0]>0)
                    userproc(0);
            }
            else if(i<=90&&count[1]>0){
                if(pcb[1].state==0)
                    userproc(1);
            }
            else
                spooling();
            if(count[0]==0)
                pcb[0].state=3;
            if(count[1]==0)
                pcb[1].state=3;
            if(pcb[0].state==3&&pcb[1].state==3)
                break;
        }
        fclose(f);
}

void userproc(int i)
{
    cout<<"in userproc !"<<endl;
    cout<<"  process "<<i<<": "<<endl;
    int j;
    if(freeioblock==0||freepoollen[i]==0)//输出井满或无空闲请求块
    {
        if(freepoollen[i]==0)
            pcb[i].state=1;//输出井满
        return;
    }
    int length=0;
    if(pcb[i].buffer==-1)//上次输入完成,无断点
    {
        cout<<"in first"<<endl;
        count[i]--;//进程i的工作量-1
        freeioblock--;//空闲请求块-1
        REQ* temp=new REQ;
        temp->ioblock_id=i;
        temp->next=NULL;
        for(int m=0;m<100;m++)
        {
            if(buffer[i][m]==0)
            {//在buffer中找到第一个空闲
                temp->block_start=m;
                break;
            }
        }
        if(head==NULL&&tail==NULL)
        {
            head=temp;
            tail=temp;
        }
        else
        {//新的请求块插到队尾
            tail->next=temp;
            tail=temp;
        }
        while(1)
        {
            j=rand()%10;
            cout<<j;
            if(j==0)
            {//结束
                temp->block_len=length;
                pcb[i].length+=length;
                pcb[i].buffer=-1;
               break;
            }
            if(buffer[i][temp->block_start+length+1]==0)
            {//输出井中空余连续
                buffer[i][temp->block_start+length]=j;
                freepoollen[i]--;
                length++;
            }
            else
            {
                if(freepoollen[i]==0)
                {//输出井满，退出
                    pcb[i].state=1;//状态1 输出井满
                    buffer[i][temp->block_start+length-1]=-1;
                    temp->block_len=length;
                    pcb[i].buffer=j;//记录未完成的输入
                    pcb[i].length+=length;
                    pcb[i].point=temp;//指向断点
                    break;
                }
                else{
                buffer[i][temp->block_start+length]=-1;//表示还未到0，后面没位置，挪位后还可写，不是指输出井满
                length++;
                freepoollen[i]--;
                temp->block_len=length;
                pcb[i].buffer=j;//记录未完成的输入
                pcb[i].length+=length;
                pcb[i].point=temp;//指向断点
                break;
                }
            }
        }

    }
    else
    {//前面未完成输入，有断点
        cout<<"in second"<<endl;
        length=0;
        freeioblock--;//空闲请求块-1，但count[i]不用减，还是属于上一个工作
        REQ* temp=new REQ;
        temp->ioblock_id=i;
        temp->next=NULL;
        for(int m=0;m<100;m++)
        {
            if(buffer[i][m]==0)
            {//寻找输出井中第一个空闲位
                temp->block_start=m;
                break;
            }
        }
        REQ *point=pcb[i].point;//恢复断点，将这个新建的请求块插入上次的断点后面
        if(point->next==NULL)
        {
            tail->next=temp;
            tail=temp;
        }
        else
        {//将这个新建的请求块插入上次的断点后面
            temp->next=point->next;
            point->next=temp;
        }
        while(1)
        {
            j=rand()%10;
            cout<<j;
            if(j==0)
            {//结束
                temp->block_len=length;
                pcb[i].length+=length;
                pcb[i].buffer=-1;
               break;
            }
            if(buffer[i][temp->block_start+length+1]==0)
            {
                buffer[i][temp->block_start+length]=j;
                freepoollen[i]--;
                length++;
            }
            else
            {
                if(freepoollen[i]==0)
                {//输出井满，退出
                    pcb[i].state=1;//状态1 输出井满
                    buffer[i][temp->block_start+length-1]=-1;
                    pcb[i].buffer=j;//记录未完成的输入
                    temp->block_len=length;
                    pcb[i].length+=length;
                    pcb[i].point=temp;//指向断点
                    break;
                }
                else{
                buffer[i][temp->block_start+length]=-1;//表示还未到0，后面没位置，挪位后还可写，不是指输出井满
                freepoollen[i]--;
                length++;
                pcb[i].buffer=j;//记录未完成的输入
                temp->block_len=length;
                pcb[i].length+=length;
                pcb[i].point=temp;//指向断点
                break;
                }
            }
        }
    }
    cout<<endl;

}

void spooling()
{
    cout<<"in spooling !"<<endl;
    if(freeioblock==10)//无请求块，即请求块全为空闲
        return;

    REQ *run=head;
    REQ *temp=head;
    int temp_id=head->ioblock_id;
    int temp_state=pcb[temp_id].state;
    printf("%d：",run->ioblock_id);
    fprintf(f,"%d：",run->ioblock_id);
    int x=buffer[temp_id][run->block_start+run->block_len-1];
    int flag=0;
    do{
        flag=0;
        for(int i=0;i<temp->block_len;i++)
        {
            if((buffer[temp_id][temp->block_start+i])!=-1)//没有断
            {
            printf("%d",buffer[temp_id][temp->block_start+i]);
            fprintf(f,"%d",buffer[temp_id][temp->block_start+i]);
            buffer[temp_id][temp->block_start+i]=0;
            freepoollen[temp_id]++;
            }
            else
            {//遇到断点
            flag=1;
            break;
            }
        }
        REQ* y=temp;
        temp=temp->next;
        head=head->next;//头指针向后移
        y->next=NULL;
       x=buffer[temp_id][temp->block_start+temp->block_len-1];
       free(y);//对应的请求块在输出井中的全部内容输入后释放
       freeioblock++;
    }while(x==-1);//以当前请求块末尾不为-1为结束条件
    if(pcb[temp_id].state==1)
        pcb[temp_id].state=0;

}

【实验结果分析】
在这里插入图片描述

【实验体会总结】
该技术通过采用预输入和缓输出的方法，使用共享设备的一部分空间来模拟独占设备，以提高独占设备的利用效率。通过设计一个SPOOING 假脱机输出的模拟程序，我对该技术有了更深的理解和掌握，同时也锻炼了自己的编程能力。

半夏风情
关注
专栏目录
【操作系统】SPOOLing技术（外部设备联机并行操作/假脱机技术）
柳婼 の blog
07-21 1万+
SPOOling技术便可将一台物理I/O设备虚拟为多台逻辑I/O设备，同样允许多个用户共享一台物理I/O设备（生活中最常见的就是多台电脑共享同一个打印机） 目的：为了缓和CPU的高速性与I/O设备低速性之间的矛盾而引入了脱机输入/输出技术。该技术是利用专门的外围控制机，将低速I/O设备上的数据传送到高速磁盘上；或者相反。 SPOOLing的意思是外部设备同时联机操作，又称为假脱机输入/输出操作，...
SPOOLing技术
deserts的博客
03-17 1385
SPOOLing技术 SPOOLing是什么？最近一直在学操作系统，这个名词和假脱机一起频繁出现，阅读了一些资料后写下总结留个记录。 SPOOLing：SPOOLing技术是低速输入输出设备与主机交换的一种技术，通常也称为“假脱机真联机”，他的核心思想是以联机的方式得到脱机的效果。低速设备经通道和外设在主机内存的缓冲存储器与高速设备相联，该高速设备通常是辅存。为了存放从低速设备上输入的信息，或者存放将要输出到低速设备上的信息（来自内存），在辅存分别开辟一固定区域，叫“输出井”（对输出），或者“输入井”（
SPOOLing技术【十全十美】
weixin_33910460的博客
12-19 176
虚拟机是OS的四大特性之一，如果说可以通过多道程序技术将一台物理CPU虚拟为多台逻辑CPU，从而允许多个用户共享一个主机，那么，通过SPOOLing技术便可将一台物理I/O设备虚拟为多台逻辑I/O设别，同样允许多个用户共享一台物理I/O。 1、什么事SPOOLing 为了缓和CPU的高速性和I/O设备的低速性之间的矛盾而引入了脱机输入、脱机输出技术，...
操作系统课程设计-Spooling技术Java实现
04-12
操作系统课程设计-Spooling技术Java实现 在计算机科学领域，SPOOLing（Simultaneous Peripheral Operations On Line）技术是一种改善I/O（输入/输出）效率的机制，它使得多个进程可以共享有限的独占型外围设备，如...
构建SPOOLING 技术例程库.zip
08-03
题目：构建SPOOLING 技术例程库。 *构建支持 SPOOLING 的例程库 *建立一个可以替代输入机或输出机的输入进程/线程或者输出进程/线程； *设置一个磁盘文件作为输入井或输出井； *输入进程/线程或者输出进程/线程从...
操作系统Spooling技术
01-09
Spooling技术：利用高速共享设备（通常是磁鼓或者是磁带）将低速的独享设备模拟为高速的共享设备，这样，从逻辑上讲，计算机系统为每一个用户都分配了一台独立的高速独享设备 　SPOOLing是Simultaneous Peripheral ...
C-Spooling.rar_SPOOLING_SPOOLING技术_spooling打印机
最新发布
09-24
**SPOOLING技术详解** SPOOLING（Simultaneous Peripheral Operations On-Line）即“联机外围设备同时操作”，是计算机操作系统中的一种重要技术，主要用于提高输入/输出（I/O）设备的利用率和系统效率。在早期的...
操作系统实验——spooling技术
06-23
SPOOLING技术 一、实验目的 理解和掌握SPOOLING技术。 二、实验内容 编写程序实现SPOOLING技术的模拟。 三、实验要求 1、设计一个实现SPOOLING技术的进程 设计一个SPOOLING输出进程和两个请求输出的用户进程及一个SPOOLING输出服务程序。 SPOOLING输出进程工作时，根据请求块记录的各进程要输出的信息，将其实际输出到打印机或显示器。这里，SPOOLING进程与请求输出的用户进程可并发运行。 2、设计进程调度算法 进程调度采用随机算法，这与进程输出信息的随机性相一致。两个请求输出的用户进程的调度概率各为45%，SPOOLING输出进程为10%，这由随机数发生器产生的随机数模拟决定。 3、进程状态 进程基本状态有3种，分别为可执行、等待和结束。可执行状态就是进程正在运行或等待调度的状态；等待状态又分为等待状态1、等待状态2、等待状态3。 状态变化的条件为： （1）进程执行完成时，置为“结束”状态。 （2）服务程序在将输出信息送至输出井时，如发现输出井已满，将调用进程置为“等待状态1”。 （3）SPOOLING进程在进行输出时，若输出井空，则进入“等待状态2”。 （4）SPOOLING进程输出一个信息块后，应立即释放该信息块所占的输出井空间，并将正在等待输出的进程置为“可执行状态”。 （5）服务程序在输出信息到输出井并形成输出请求信息块后，若SPOOLING进程处于等待状态则将其置为“可执行状态”。 （6）当用户进程申请请求输出块时，若没有可用请求块时，调用进程进入“等待状态3”。 4、数据结构 1）进程控制块PCB struct pcb { int status; int length; }pcb[3]; 其中status表示进程状态，其取值： 0 表示可执行状态； 1 表示等待状态1； 2 表示等待状态2； 3 表示等待状态3 2）请求输出块reqblock struct{ int reqname;//请求进程名 int length;// 本次输出信息长度 int addr;// 信息在输出井的首地址 }reqblock[10]; 3)输出井BUFFER SPOOLING系统为每个请求输出的进程在输出井中分别开辟一个区。本实验可设计一个二维数组（int buffer[2][10]）作为输出井。每个进程在输出井最多可占用10个位置。 5、编程说明 为两个请求输出的用户进程设计两个输出井。每个可存放10个信息，即buffer[2][10]。当用户进程将其所有文件输出完时，终止运行。 为简单起见，用户进程简单的设计成：每运行一次，随机输出数字0~9之间的一个数，当输入10个数时形成一个请求信息块，填入请求输出信息块reqblock结构中。
SPOOLing系统实验及代码
12-07
设备管理（设计SPOOLing系统）,设计并运行一个简单的SPOOLing系统来模拟实际的SPOOLing输入/输出过程，以掌握这种以空间换时间的技术。
spooling技术的服务器端代码
12-05
spooling技术的服务器端代码 SPOOLing技术是对脱机输入、输出系统的模拟，主要是为了缓和CPU的高速性与I/O设备低俗性间的矛盾。通过SPOOLing技术可将一台物理I/O设备虚拟为多台逻辑I/O设备，同样实现多个用户共享一台物理I/O设备。
spooling技术（源代码+word实验报告）
06-05
设计并实现一个spooling输出的模拟系统 ①进程控制块（PCB） 对于输出进程和spooling进程两种不同的进程，采用相同的结构处理，包括进程标识、进程状态、输出缓冲、输出指针、信息块首地址、输出长度等内容。需要支持在不同状态之间的转换，输出缓冲清空等操作。 ②输出请求块 包括要求输出的进程标识、输出长度、输出首地址等内容。 ③输出井 使用队列结构模拟，需要支持队列重整，取队首元素，删除队首元素，在队尾插入等操作，需要使用两个指针协助操作。
spooling技术
qq_43774324的博客
03-12 6665
简介SPOOLing技术（假脱机技术） SPOOLing系统组成：1.输入井和输出井 2.输入缓冲区和输出缓冲区 3.输入进程和输出进程 SPOOLing技术的主要特点：提高了I/O速度，将独占设备改造为共享设备，实现了虚拟设备功能。 1.输入井和输出井 输入井和输出井是在磁盘上开辟出的存储区域，输入井用于存储I/O设备输入的数据。输出井用于存储用户程序的输出数据。 2.输入缓冲区和输出缓冲区 输入缓冲区和输出缓冲区是在内存中开辟的缓冲区，输入缓冲区用于暂存由输入设备送来的数据，以后在传送...
SPOOLING技术解析与实现
"本文档详细介绍了SPOOLING技术的实现，包括其设计思想、伪码算法、函数调用关系图以及测试过程。通过SPOOLING技术，可以将独占设备如打印机变为共享设备，实现多道程序系统中的速度匹配，提高系统效率。文档还涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

半夏风情

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值