实验1-进程调度

实验一先来先服务FCFS和短作业优先SJF进程调度算法一：需求分析程序设计的任务：设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。

假设有n个x进程分别在T1，… ,Tn时刻到达系统,它们需要的服务时间分别为S1，… ，Sn.分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

（1）输入的形式和输入值的范围为免去测试时候需要逐步输入数据的麻烦,输入时采用输入文件流方式将数据放在。

txt 文件中，第一行为进程个数，第二行为进程到达时间（各个进程的到达时间之间用空格隔开），第三行为进程的服务时间（每个服务时间之间用空格隔开）。

（2）输出的形式模拟整个调度过程，输出每个时刻的进程运行状态，同时输出了每个进程的完成时间，并且按要求输出了计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

（3）程序所能达到的功能能够模拟出进程的先来先服务FCFS算法和短作业优先SJF算法的调度过程，输入进程个数n；每个进程的到达时间T1, … ，Tn和服务时间S1, … ,Sn;选择算法1-FCFS,2-SJF,3—退出，用户做出选择即可输出对应的算法调度过程或者退出程序。

（4）测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果测试数据及其输出结果:二:概要设计程序包括主函数、FCFS算法函数、SJF算法函数、输出函数;主函数流程：输入文件中的数据—显示各进程数据-选择算法-调用相应算法的函数-输出结果三：详细设计算法流程图：调用结束四:调试分析(1)：调试过程中遇到的问题以及解决方法，设计与实现的回顾讨论和分析;开始的时候没有判断进程是否到达，导致短进程优先算法运行结果错误，后来加上了判断语句后就解决了改问题。

使用动态优先权的进程调度算法的模拟实验动态优先权调度算法是一种根据进程动态表现调整优先权的进程调度算法。

它不仅考虑了进程的优先级，还将进程的实际执行情况作为调度依据。

下面将介绍一个模拟实验，以更好地理解这种调度算法。

实验背景：假设有五个待执行的进程，它们的ID和初始优先权分别为P1（3）、P2（5）、P3（2）、P4（1）、P5（4）。

这五个进程的优先权在调度过程中会根据实际情况进行动态调整。

实验过程：1.初始化：在实验开始之前，首先需要对进程的初始状态进行初始化。

每个进程有两个属性：优先级和已运行时间。

优先级用于决定进程的调度优先级，已运行时间用于记录进程已经运行了多长时间。

设置一个全局时间片，表示每个时间单元中运行的时间。

2.进程调度：根据进程的优先权，选取最高优先权的进程进行调度。

从P1到P5，进程的优先权逐渐减小。

-选择进程：比如初始时最高优先权的进程为P2-进程执行：进程P2被调度后开始执行，运行一个时间片。

每运行一个时间片，该进程的已运行时间加一，重新计算进程的优先权。

-优先权调整：根据已运行时间的加一，重新计算进程的优先权。

优先权的计算公式可以根据实际需要进行调整，比如可以设为：新的优先权=原优先权+（已运行时间/其中一常量）。

-进程阻塞：如果进程运行的时间超过了一个时间片，则该进程被阻塞，进入就绪队列等待下一次轮转调度，其他进程继续执行。

3.调度进程更新：进程在执行和阻塞的过程中，它们的优先权会发生变化。

在每一轮调度后，需要更新进程的优先权，重新确定每个进程的调度顺序。

4.实验结果：重复进行步骤2和步骤3，直到所有进程都完成执行。

记录每次调度过程中的结果，包括进程的执行顺序、时刻和优先权的变化。

实验分析：通过模拟实验，可以得出以下一些结论：1.动态优先权调度算法能够根据实际情况调整进程的优先权，更好地适应不同进程的需求，增强了调度的灵活性。

2.在实验中，进程运行时间越长，优先权越低。

进程调度算法的实现实验报告记录————————————————————————————————作者：————————————————————————————————日期：南昌大学实验报告---（4）进程调度算法的实现学生姓名：学号：专业班级：实验类型：□验证□综合■设计□创新实验日期：实验成绩：一、实验目的通过实验加强对进程调度算法的理解和掌握。

二、实验内容编写程序实现进程调度算法，具体可以编写程序实现先来先服务算法或优先度高者调度算法。

三、实验要求1、需写出设计说明；2、设计实现代码及说明；3、运行结果；四、主要实验步骤1、分析实验内容，画出算法流程图；2、根据流程图写出实验代码；3、编译代码，验证结果正确与否；4、对程序进行修改，得到最后结果。

流程图如下：开始系统随机产生数据将数据按照到达时间从小到大排序用户输入数据进程到达时前一个进程是否已经完成完成时间=服务时间+前一个进程完成时间完成时间=服务时间+到达时间周转时间=完成时间-到达时间带权周转时间=完成时间/服务时间是否所有进程已完成计算输出结果结束YN YN YN五、实验数据及处理结果六、实验体会或对改进实验的建议在做这个实验的时候，一开始以为很简单，只要做简单的加减乘除就行了，但是仔细做过以后发现需要考虑很多情况。

比如说输入进程到达时间的时候，要是乱序的该怎么办？还有到达时间和服务时间等等定义的都是整型变量，但是带权周转时间确会得到小数，此时就需要用到强制转换。

在做系统产生随机数的时候也要考虑随机数的范围，如到达时间可以为0，但是服务时间却不能为0，否则带权周转时间的计算会出错。

七、参考资料《计算机操作系统》《计算机操作系统实验指导书》《C程序设计》《C语言程序设计_现代方法》八、实验代码#include <stdio.h>#include <stdlib.h>#include <time.h>#define N 5 //进程个数，可改变int rt[N]; //到达时间int st[N]; //服务时间int ct[N]; //完成时间int cyt[N]; //周转时间float rct[N]; //带权周转时间float av[2];int n,m,c=1,which;void line() //美化程序，使程序运行时更加明朗美观{printf("------------------------------------------------------------------\n");}void start() //表示FCFS算法开始{line();printf(" FCFS算法开始\n");printf(" ——Designed by Zhang Hong\n"); line();}void end() //表示FCFS算法结束{line();printf(" FCFS算法结束,谢谢使用\n");line();}void input(){printf("请输入%d个进程的到达时间：",N);for (n=0;n<N;n++)scanf("%d",&rt[n]);printf("请输入%d个进程对应的服务时间：",N);for (n=0;n<N;n++)scanf("%d",&st[n]);}void random(){srand((unsigned)time(NULL));for (n=0;n<N;n++){rt[n]=rand()%100;for (m=0;m<n;m++)if (n!=0 && rt[n]==rt[m]){rt[n]=rand()%100;m=0;}st[n]=rand()%98+1;for (m=0;m<n;m++)if (n!=0 && st[n]==st[m]){st[n]=rand()%98+1;m=0;}}}void ordination() //重新排序，应对出现输入的到达时间为乱序的情况{int temp;for (n=0;n<N;n++)for (m=0;m<N-n-1;m++)if (rt[m+1]<rt[m]){temp=rt[m+1];rt[m+1]=rt[m];rt[m]=temp;temp=st[m+1];st[m+1]=st[m];st[m]=temp;}}void fcfs() //执行fcfs算法{av[0]=0;av[1]=0;ct[0]=rt[0]+st[0];for (n=1;n<N;n++){if (ct[n-1]>=rt[n]) //考虑当前一个进程完成而后一个进程还没有到达的情况ct[n]=ct[n-1]+st[n];elsect[n]=rt[n]+st[n];}for (n=0;n<N;n++)cyt[n]=ct[n]-rt[n];for (n=0;n<N;n++)rct[n]=(float)cyt[n]/(float)st[n];for (n=0;n<N;n++){av[0]+=(float)cyt[n]/N;av[1]+=rct[n]/N;}}void output() //输出结果{line();printf("进程名\t");for (n=0;n<N;n++)printf("\t%c",65+n);printf("\t平均\n到达时间");for (n=0;n<N;n++)printf("\t%d",rt[n]);printf("\n服务时间");for (n=0;n<N;n++)printf("\t%d",st[n]);printf("\n完成时间");for (n=0;n<N;n++)printf("\t%d",ct[n]);printf("\n周转时间");for (n=0;n<N;n++)printf("\t%d",cyt[n]);printf("\t%0.1f",av[0]);printf("\n带权周转时间");for (n=0;n<N;n++)printf("\t%0.1f",rct[n]);printf("\t%0.1f",av[1]);printf("\n");line();}void main(){start();for (;c==1;){for (;;){printf("输入数据还是由系统随机产生数据？\n1、输入数据\t2、系统随机产生数据\n请输入：");scanf("%d",&which);if (which==1){input();break;}elseif (which==2){random();break;}printf("输入错误，请重新输入！");}ordination(); //进程按照到达时间进行排序fcfs();output();printf("继续输入，退出输入。

时间片轮转法完成进程调度【实验目的】（1）加深对进程的理解（2）理解进程控制块的结构（3）理解进程运行的并发性（4）掌握时间片轮转法进程调度算法【实验内容】（1）建立进程控制块（2）设计三个链队列.分别表示运行队列、就绪队列和完成队列（3）用户输入进程标识符以及进程所需的时间.申请空间存放进程PCB信息。

（4）每一个时间片结束输出各进程的进程号.CPU时间（即已经占用的CPU时间）.所需时间（即还需要的CPU时间）.以及状态（即用W表示等待.R表示运行.F表示完成）【程序代码】#include "stdio.h"#include"stdlib.h"struct PCB{int pid; //进程标识符int rr; //已运行时间int time; //进程要求运行时间char sta; //进程的状态struct PCB *next; //链接指针};struct PCB pcb1,pcb2,pcb3,pcb4,pcb5,*tail,*head,*rp;init(){int i,time;pcb1.pid = 1;pcb2.pid = 2;pcb3.pid = 3;pcb4.pid = 4;pcb5.pid = 5;pcb1.rr =pcb2.rr =pcb3.rr =pcb4.rr =pcb5.rr = 0;pcb1.sta = pcb2.sta = pcb3.sta = pcb4.sta = pcb5.sta = 'w'; printf("请输入时间片p1需要运行的时间:");scanf("%d",&time);pcb1.time = time;printf("请输入时间片p2需要运行的时间:");scanf("%d",&time);pcb2.time = time;printf("请输入时间片p3需要运行的时间:");scanf("%d",&time);pcb3.time = time;printf("请输入时间片p4需要运行的时间:");scanf("%d",&time);pcb4.time = time;printf("请输入时间片p5需要运行的时间:");scanf("%d",&time);pcb5.time = time;pcb1.next=&pcb2;pcb2.next=&pcb3;pcb3.next=&pcb4;pcb4.next=&pcb5;pcb5.next=&pcb1;head = &pcb1;tail = &pcb5;}void printf1(){printf("+---------------|---------------|---------------|---------------+\n");printf("|\tpid\t|\trr\t|\ttime\t|\tSTA\t|\n");printf("|---------------|---------------|---------------|---------------|\n");}printf2(){printf("processes p%d running\n",head->pid);printf1();printf("|\t%d\t|\t%d\t|\t%d\t|\t%c\t|\n",head->pid,head->rr,head->time,head->sta);printf("|---------------|---------------|---------------|---------------|\n");rp=head;while(rp!=tail){rp=rp->next;printf("|\t%d\t|\t%d\t|\t%d\t|\t%c\t|\n",rp->pid,rp->rr,rp->time,rp->sta);printf("|---------------|---------------|---------------|---------------|\n");}}operation(){int flag=1;while (flag<=5){head->rr ++;if ((head->rr==head->time)||(head->time==0)){tail->sta='w';head->sta='f';printf2();head=head->next;tail->next=head;flag++;}else{tail->sta='w';head->sta='r';printf2();tail=head;head=head->next;}}}void main(){init(); //初始化printf("this is the begin state :\n"); printf2(); //显示初始状态operation(); //运行}【结果截图】。

一、实验目的1. 理解操作系统调度算法的基本原理和概念。

2. 掌握几种常见调度算法的原理和实现方法。

3. 分析不同调度算法的性能特点，为实际应用提供参考。

二、实验内容本次实验主要涉及以下几种调度算法：先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、最高响应比优先（HRRN）和时间片轮转（Round Robin）。

1. 先来先服务（FCFS）调度算法FCFS调度算法按照进程到达就绪队列的顺序进行调度，先到达的进程先执行。

该算法简单易实现，但可能导致长作业等待时间过长，从而降低系统吞吐量。

2. 最短作业优先（SJF）调度算法SJF调度算法优先选择执行时间最短的进程进行调度。

该算法可以最大程度地减少平均等待时间和平均周转时间，但可能导致长作业等待时间过长。

3. 优先级调度（Priority Scheduling）算法优先级调度算法为每个进程设置一个优先级，优先选择优先级高的进程进行调度。

该算法可以满足高优先级作业的需求，但可能导致低优先级作业长时间等待。

4. 最高响应比优先（HRRN）调度算法HRRN调度算法为每个进程设置一个响应比，优先选择响应比高的进程进行调度。

响应比是作业的等待时间与作业所需时间的比值。

该算法综合考虑了作业的等待时间和所需时间，是一种较为公平的调度算法。

5. 时间片轮转（Round Robin）调度算法时间片轮转调度算法将CPU时间划分为固定的时间片，按照进程到达就绪队列的顺序，每次只允许一个进程运行一个时间片。

如果进程在一个时间片内无法完成，则将其放入就绪队列的末尾，等待下一次调度。

该算法可以平衡各个进程的执行时间，但可能导致进程响应时间较长。

三、实验步骤1. 编写一个进程调度程序，实现上述五种调度算法。

2. 生成一个包含多个进程的作业队列，每个进程具有到达时间、所需运行时间和优先级等信息。

3. 分别采用五种调度算法对作业队列进行调度，并记录每个进程的执行情况。

xx大学操作系统实验报告姓名：学号：班级：实验日期：实验名称：先来先服务FCFS和短作业优先SJF进程调度算法实验一先来先服务FCFS和短作业优先SJF进程调度算法1. 实验目的：通过这次实验，理解FCFS和SJF进程调度算法的运行原理，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

：2. 需求分析(1) 输入的形式和输入值的范围；输入：进程个数N 范围：0<N<=100依次输入（进程名进程到达时间范围：0<time<=100进程服务时间）范围：0<time<=100选择一种算法：1—FCFS，2—SJF 范围：1或2或00—退出平均周转时间：平均带权周转时间：(3) 程序所能达到的功能输入进程的个数N，以及每个进程的到达时间和运行时间。

通过选择FCFS或是SJF进程调度算法进行调度，计算出每个进程的开始运行时间、结束时间、执行顺序、周转时间、带权周转时间，并最终求得平均周转时间和平均带权周转时间。

(4) 测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。

正确一（FCFS）正确二（SJF）输入参数错误3、概要设计所有抽象数据类型的定义：static int MaxNum=100;int ArrivalTime[MaxNum];//到达时间int ServiceTime[MaxNum];//服务时间int FinishTime[MaxNum];//结束时间int WholeTime[MaxNum];//周转时间double WeightWholeTime[MaxNum];//带权周转时间double AverageWT_FCFS,AverageWT_SJF; //平均周转时间double AverageWWT_FCFS,AverageWWT_SJF; //平均带权周转时间主程序的流程:●变量初始化●接受用户输入的N，T1…..Tn,S1….Sn;●选择算法进行进程调度，计算进程的开始运行时间、结束时间、执行顺序、周转时间、带权周转时间；●计算所有进程的平均周转时间、平均带权周转时间；●按照格式输出调度结果。

第1篇一、实验背景进程调度是操作系统核心功能之一，它负责在多道程序环境下，按照一定的策略对进程进行调度，以确保系统资源的合理分配和高效利用。

为了加深对进程调度算法的理解，本次实验采用模拟的方式，实现了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种算法，并对实验过程进行了详细记录和分析。

二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。

2. 掌握进程控制块（PCB）的设计与实现。

3. 通过模拟实验，验证三种调度算法的执行效果。

三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验内容1. 定义进程控制块（PCB）进程控制块是操作系统用于描述和管理进程的实体，它包含了进程的基本信息。

本实验中，PCB包含以下字段：- 进程ID：唯一标识一个进程。

- 到达时间：进程进入就绪队列的时间。

- 需要运行时间：进程完成所需的时间。

- 已运行时间：进程已运行的时间。

- 状态：进程当前的状态（就绪、运行、阻塞、完成）。

2. 实现三种调度算法（1）先来先服务（FCFS）算法FCFS算法按照进程到达就绪队列的顺序进行调度，先到先服务。

具体实现如下：- 将进程按照到达时间排序，形成就绪队列。

- 遍历就绪队列，依次执行进程，直到进程完成或被阻塞。

（2）时间片轮转（RR）算法RR算法将CPU时间划分为时间片，每个进程运行一个时间片后，让出CPU，等待下一个时间片。

具体实现如下：- 设置一个时间片大小。

- 将进程按照到达时间排序，形成就绪队列。

- 遍历就绪队列，每个进程执行一个时间片，如果进程未完成，则将其加入就绪队列队尾。

（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度，优先级高的进程优先执行。

具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。

- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。

计算机操作系统实验报告一、实验目的本次计算机操作系统实验旨在深入了解计算机操作系统的工作原理和核心功能，通过实际操作和观察，增强对操作系统的认知和理解，提高解决实际问题的能力。

二、实验环境本次实验在以下环境中进行：操作系统：Windows 10开发工具：Visual Studio 2019硬件配置：Intel Core i5 处理器，8GB 内存，512GB 固态硬盘三、实验内容与步骤（一）进程管理实验1、创建进程使用 C+＋语言编写程序，通过调用系统函数创建新的进程。

在程序中，设置不同的参数和条件，观察进程的创建过程和资源分配情况。

2、进程调度编写模拟进程调度的程序，实现不同的调度算法，如先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等。

通过改变进程的到达时间、执行时间和优先级等参数，观察不同调度算法对系统性能的影响。

3、进程同步与互斥使用信号量和互斥锁等机制实现进程之间的同步与互斥。

编写多进程程序，模拟生产者消费者问题、读者写者问题等经典的同步互斥场景，观察程序的运行结果，分析同步互斥机制的有效性和性能。

（二）内存管理实验1、内存分配实现不同的内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。

通过模拟内存请求和释放的过程，观察不同算法下内存的使用情况和碎片产生的情况。

2、虚拟内存配置系统的虚拟内存设置，观察虚拟内存的工作原理。

编写程序访问超过物理内存大小的数据，观察系统如何利用虚拟内存进行数据交换和页面置换。

3、内存保护设置内存访问权限，编写程序尝试越界访问内存，观察系统的保护机制如何防止非法访问和错误操作。

（三）文件系统实验1、文件操作使用系统提供的文件操作接口，进行文件的创建、读写、删除等操作。

观察文件在磁盘上的存储方式和文件系统的目录结构。

2、文件权限管理设置文件的访问权限，包括读取、写入、执行等权限。

通过不同用户身份访问文件，观察权限管理的效果和安全性。

3、磁盘调度实现不同的磁盘调度算法，如先来先服务（FCFS）、最短寻道时间优先（SSTF）、扫描算法（SCAN）等。

实验一：进程调度程序的实现思路：将每个进程作为链表的一个元素实现，元素用结构体表示，输入进程根据优先数插入适当位置，程序每运行一次打印运行情况，然后扫描程序是否有进程插入，若有插入适当位置，若无，则进程继续运行，直至全部进程运行完成。

程序实现代码：struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB; /* pcb替换为PCB*/sort( ) /* 建立一个对进程进行优先级排列函数*/printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}实验二:作业调度程序算法及实现思路：先来先服务算法、最短作业优先算法、响应比高者优先算法。

将作业用结构体表示，并用指针把所有作业链接为一个链表，选择调度模式排列作业，然后按顺序运行，在运行一个程序时将作业从队列中除去，运行后再根据模式的排列要求插入队列，再顺序运行程序。

程序实现代码:struct jcb /*作业控制块*/{char name[10];int reachtime;int starttime;int needtime;float super;int finishtime;float cycletime;float cltime;char state;struct jcb *next;}*ready=NULL,*p,*q;do{if(padv->state=='W'&&padv->reachtime<=times)padv->super=(float)(times-padv->reachtime+padv->needtime)/padv->needtime;padv=padv->next;}while(padv!=NULL);}void final() /*最后打印作业的平均周转时间,平均带权周转时间*/{float s,t;t=T1/n;s=T2/n;getch();printf("\n\n作业已经全部完成!");printf("\n%d个作业的平均周转时间是：%f",n,t);printf("\n%d个作业的平均带权周转时间是%f：\n\n\n",n,s);}实验三分区式存储管理程序的实现思路：使用程序中自由链队列的结点，并且内存占用区可以用链表描述其结点类型，其中，空闲分区通过空闲分区链来管理；在进行内存分配时，系统优先使用空闲区低端的空间。

实验五:进程调度实验目的：实现先来先服务FCFS、短作业优先SJF以及时间片轮转调度算法。

实验内容：①实现FCFS算法：根据进程的到达时间的先后次序来完成对若干进程的调度。

②实现SJF算法：根据当前时间已经到达进程的需要运行时间选取其中时间最小的进程最先运行。

③实现时间片轮转算法：首先要求确定时间片的大小，依据进程的到达时间依次加入队列，每次分配一个时间片大小的时间，如果没有完成参与下一次的竞争，当最后需要一个小于等于时间片的时间时本进程完成，同时退出队列。

④计算每种算法调度后，系统的平均周转时间和平均带权周转时间。

算法实现：[cpp]view plaincopy1.void FCFS()2.{3.int i;4.float sumT = 0.0;5.float sumW = 0.0;6.float last ;7. process[0].start = process[0].arrive;8. process[0].finish = process[0].start + process[0].service;9.10. last = process[0].finish;11.12. i = 1;13.while(i != N)14. {15.if(process[i].arrive > last)16. last = process[i].arrive;17. process[i].start = last;18. process[i].finish = last + process[i].service;19. last += process[i].service;20. i++;21. }22.23.for(i = 0 ; i < N; i++)24. {25. process[i].T = process[i].finish - process[i].arrive;26. process[i].W = process[i].T / (float)process[i].service;27. sumT += process[i].T;28. sumW += process[i].W;29. }30. FCFS_T = sumT / N;31. FCFS_W = sumW / N;32.}33.34.35.int getmin(float t)36.{37.int i;38.int addr = -1;39.float min=10000.0;40.41.for(i = 0 ; i < N ; i++)42. {43.if(process[i].state == 0 && process[i].service < min44. && process[i].arrive <= t)45. {46. addr = i;47. min = process[i].service;48. }49. }50.51. process[addr].finish = t + process[addr].service;52.53.return addr;54.}55.void SJF()56.{57.int i;58.float sumT = 0.0;59.float sumW = 0.0;60.61. process[0].finish = process[0].arrive + process[0].service;62. process[0].state = 1;63.64.int addr = 0;65.int sign = 0;66.float last = process[0].finish;67.68.while(sign != N-1)69. {70. addr = getmin(last);71.if(addr == -1)72. {73. last = process[getmin(1000)].arrive;74.continue;75. }76. process[addr].start = last;77. process[addr].state = 1;78. last = process[addr].finish;79. sign++;80. }81.82.for(i = 0 ; i < N; i++)83. {84. process[i].T = process[i].finish - process[i].arrive;85. process[i].W = process[i].T / (float)process[i].service;86. sumT += process[i].T;87. sumW += process[i].W;88. }89.90. SJF_T = sumT / N;91. SJF_W = sumW / N;92.}93.94.void RR()95.{96.int i = 0;97.int j;98.int t = process[0].arrive;99.float sumT = 0.0;100.float sumW = 0.0;101.for(j = 0 ; j < N ; j++)102. {103. process[j].state = 0;104. process[j].start = -1;105. process[j].left = process[j].service;106. }107. process[0].start = t;108.while(1)109. {110.for(j = 0 ; j < N ; j++)111.if(process[(i+j)% N].state == 0 && t >= process[(i+ j)% N].arrive)112.break;113. i = (i+j)% N;114.115.if( process[i].state == 1)116. {117.break;118. }119.120.if(process[i].start == -1)121. process[i].start = t;122.123.for(j = 0 ; j < min(process[i].left,q) ; j++)124. cout <<process[i].name;125.if(process[i].left > q)126. {127. t += q;128. process[i].left -= q;129. }130.else131. {132. t += process[i].left;133. process[i].left = 0;134. process[i].finish = t;135. process[i].state = 1;136. }137. i = (++i) %N;138. }139.140.for(i = 0 ; i < N ; i++)141. {142. process[i].T = process[i].finish - process[i].arrive; 143. process[i].W = process[i].T / (float)process[i].service; 144. sumT += process[i].T;145. sumW += process[i].W;146. }147.148. RR_T = sumT / N;149. RR_W = sumW / N;150.}。

操作系统实验一As a person, we must have independent thoughts and personality.本科实验报告操作系统课程名称：学号：姓名：专业：班级：指导教师：课内实验目录及成绩信息技术学院实验(实验一)1 实验名称：基本shell命令及用户管理2 实验目的掌握安装Linux操作系统的方法。

掌握Linux操作系统的基本配置。

了解GNOME桌面环境。

掌握基本shell命令的使用。

3 实验准备下载VMware Workstation虚拟机软件（版本不限）。

准备Linux操作系统的安装源（内核版本和发行版本均不限）。

注：实验准备、实验内容和作为回家作业布置，同学们利用课余时间可在私人计算机上完成。

4 实验要求、步骤及结果安装虚拟机软件。

【操作要求】安装VMware Workstation虚拟机软件，并填写以下4.1.1和的内容。

4.1.1【VMware Workstation虚拟机版本号】4.1.2【主要配置参数】安装Linux操作系统。

【操作要求】安装Linux操作系统，版本不限。

Linux发行版本：Linux内核版本：【主要操作步骤：包括分区情况】1、创建一台虚拟机安装操作系统时客户机操作系统选择Linux2、修改虚拟机的安装路径。

3、建一个新的虚拟磁盘，磁盘的空间20GB，并且将单个文件存储虚拟磁盘。

4、设置分区完毕，安装虚拟机了解Linux操作系统的桌面环境之一GNOME。

【操作要求】查看桌面图标，查看主菜单，查看个人用户主目录等个人使用环境。

【操作步骤1】桌面图标【操作步骤2】主菜单【操作步骤3】个人用户主目录【操作步骤4】启动字符终端【操作步骤5】注销[root@localhost~]# exit【操作步骤6】重启系统[root@localhost~]# reboot【操作步骤7】关闭[root@localhost~]# halt【回答问题】简述Windows桌面环境与Linux桌面环境的主要区别。

实验二时间片轮转RR进程调度算法【实验目的】通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

【实验内容】问题描述：设计程序模拟进程的时间片轮转RR调度过程。

假设有n个进程分别在T1, …,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。

分别利用不同的时间片大小q，采用时间片轮转RR进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

程序要求：1）进程个数n；每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n；输入时间片大小q。

2）要求时间片轮转法RR调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。

【源程序】#include<iostream.h>#include<iomanip.h>#include<stdio.h>#include<conio.h>#include<malloc.h>#include<stdlib.h>typedef int QElemType;#define OK 1#define ERROR 0#define OVERFLOW -1typedef int Status;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;Status InitQueue(LinkQueue &Q);Status DestroyQueue(LinkQueue &Q);Status EnQueue(LinkQueue &Q,QElemType e);int DeQueue(LinkQueue &Q,QElemType e);bool QueueEmpty(LinkQueue &Q);static const int MaxNum=100;intn,q,ArrivalTime[MaxNum],ServiceTime[MaxNum],FinishedTime[MaxNum],Whol eTime[MaxNum];double WeightWholeTime[MaxNum],Average_WT=0,Average_WWT=0;LinkQueue Q;void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q); void main(){cout<<"请输入进程数n:";cin>>n;while(n<0||n>100){cout<<"输入的n值不正确，请重新输入！"<<endl;cin>>n;}cout<<"请输入各个进程的到达时间：";for(int i=0;i<n;i++)cin>>ArrivalTime[i];cout<<"请输入各个进程的服务时间：";for( i=0;i<n;i++)cin>>ServiceTime[i];cout<<"请输入时间片q:";cin>>q;while(q<0||q>200){cout<<"输入的q值不正确，请重新输入！"<<endl;cin>>q;}RR(ArrivalTime,ServiceTime,n,q,Q);}void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q){ int countTime=0,e;int STime[MaxNum],pushed[MaxNum];for(int i=0;i<n;i++){STime[i]=ServiceTime[i];pushed[i]=0;}InitQueue(Q);EnQueue(Q,0);pushed[0]=1;int time=0;while(QueueEmpty(Q)==false){e=DeQueue(Q,e);if(STime[e]>q){STime[e]=STime[e]-q;countTime+=q;}else{countTime+=STime[e];STime[e]=0;FinishedTime[e]=countTime;}while(time<countTime){if(STime>0){cout<<"时刻"<<setw(2)<<time<<":进程"<<e<<"正在运行"<<endl;}time++;}for(i=1;i<n;i++){if(STime!=0&&i!=e&&ArrivalTime[i]<countTime&&pushed[i]==0||STime! =0&&i!=e&&ArrivalTime[i]==countTime){EnQueue(Q,i);pushed[i]=1;}}if(STime[e]>0){EnQueue(Q,e);}}for(i=0;i<n;i++){WholeTime[i]=FinishedTime[i]-ArrivalTime[i];WeightWholeTime[i]=(double)(WholeTime[i]*1.000000/ServiceTime[i]) ;Average_WT+=WholeTime[i];Average_WWT+=WeightWholeTime[i];}Average_WT/=n;Average_WWT/=n;cout<<"完成:"<<" ";for(i=0;i<n;i++)cout<<setw(8)<<FinishedTime[i]<<" ";cout<<endl;cout<<"周转:"<<" ";for(i=0;i<n;i++)cout<<setw(8)<<WholeTime[i]<<" ";cout<<endl;cout<<"带权："<<" ";for(i=0;i<n;i++)cout<<setw(8)<<setiosflags(ios::fixed)<<setprecision(2)<<WeightWholeT ime[i]<<" ";cout<<endl;cout<<"平均周转时间为："<<Average_WT<<endl;cout<<"平均带权周转时间为:"<<Average_WWT<<endl;DestroyQueue(Q);}Status InitQueue(LinkQueue &Q){Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(OVERFLOW);Q.front->next=NULL;return OK;}Status DestroyQueue(LinkQueue &Q){while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}Status EnQueue(LinkQueue &Q,QElemType e){QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}int DeQueue(LinkQueue &Q,QElemType e){QueuePtr p;if(Q.front==Q.rear) return ERROR;p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p) {Q.rear=Q.front;}free(p);return e;}bool QueueEmpty(LinkQueue &Q){if(Q.front==Q.rear)return true;else return false;}【实例截图】小结：通过这次实验，感觉时间片轮转RR进程调度算法还是挺复杂的，关键要掌握队列的特点，也就是顺序要清楚，哪个时刻对应运行哪一个进程要明白，再者就是要熟悉算法和进程调度的执行过程，多动手，多思考，就可以解决。

实验优先级和时间片轮转调度一、实验要求通过编写程序实现进程高优先权和按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。

二、实验内容进程调度算法有优先数调度算法，时间片轮转调度算法，分级调度算法。

选两种种算法实现。

进程调度算法的数据结构主要有：进程函数定义，建立进程函数，进程调度函数。

源程序代码部分：#include "stdio.h"#include <malloc.h>#define max 100#define etime 4#define pfree 0#define running 1#define aready 2#define blocking 3typedef struct node{char name;int status;int pri;int ptime;int ax,bx,cx,dx;int pc;int psw;}pcb;pcb *processarray[max];static int processnum;pcb *createprocess(pcb *processarray[]) 组{pcb *p,*q;int a,b,c,d,m,n,r,t;char ID;q=NULL;printf("input the first nine status pcb:");scanf("\n%c%d%d%d%d%d%d%d%d",&ID,&a,&b,&c,&d,&m,&n,&r,&t);for(int i=0;i<max;i++){p=(pcb*)malloc(sizeof(pcb));p->name=ID;p->ax=a;p->bx=b;p->cx=c;p->dx=d;p->pc=m;p->psw=n;p->pri=r;p->ptime=t;p->status=aready;processnum++;processarray[i]=p;printf("input the next seven status pcb: ");scanf("\n%c",&ID);if (ID == '*')break;scanf("%d%d%d%d%d%d%d%d",&a,&b,&c,&d,&m,&n,&r,&t);}for(int j=0;j<processnum;j++){q=processarray[j];printf("\n process name. status.ax. bx. cx. dx. pc. psw. pri. ptime\n ");printf("%10c%5d%5d%5d%5d%5d%5d%5d%5d%5d",q->name,q->status,q->ax,q->bx,q->cx,q->dx,q->pc,q->psw,q->pri,q->ptime);}return *processarray;}void processRR(pcb *processarray[]){int i;int j;pcb *q;int totaltime=0;for(i=0;i<processnum;i++){ if(processarray[i]->ptime%4==0)totaltime+=processarray[i]->ptime;elsetotaltime+=(processarray[i]->ptime/4+1)*4;}printf("\nUsing RR method:");printf("\n process name. status.ax. bx. cx. dx. pc. psw. pri. ptime\n ");for(i=0;i<processnum&&totaltime;j=0){ q=processarray[i];if(q->ptime==0)j=0;else if(q->ptime<=etime){q->status=pfree;q->ptime=0;printf("\n%10c%5d%8d%5d%5d%5d%5d%5d%5d%5d",q->name,q->status,q->ax,q->bx,q->cx,q->dx,q->pc,q->psw,q->pri,q->ptime); /*check process running status */ totaltime-=etime;}else if(q->ptime>etime){q->status=running;q->ptime=q->ptime-etime;printf("\n%10c%5d%8d%5d%5d%5d%5d%5d%5d%5d",q->name,q->status,q->ax,q->bx,q->cx,q->dx,q->pc,q->psw,q->pri,q->ptime); /*check process running status */q->status=aready;totaltime-=etime;}if(i<processnum-1)i++;else if(i==processnum-1)i=0;}}void processStaPri(pcb *processarray[]){pcb *q;int i,j;printf("\n the process use StaPri method.\n");printf("running the frist process:\n");for(i=0;i<processnum;i++)for(j=0;j<processnum-1;j++){if(processarray[j]->pri>processarray[j+1]->pri){q=processarray[j];processarray[j]=processarray[j+1];processarray[j+1]=q;}}for(i=0;i<processnum;i++){processarray[i]->status=running;q=processarray[i];printf("\n process name. status.ax. bx. cx. dx. pc. psw. pri. ptime\n ");printf("\n%10c%5d%8d%5d%5d%5d%5d%5d%5d%5d",q->name,q->status,q->ax,q->bx,q->cx,q->dx,q->pc,q->psw,q->pri,q->ptime); /*check process running status */ q->status=pfree;}for(j=0;j<processnum;j++){q=processarray[j];printf("\n检查进程%3c是否结束,进程当前状态:%3d",q->name,q->status);}printf("\ngame is over!\n");}void main(){*processarray=createprocess(processarray);processRR(processarray);processStaPri(processarray);}。

《操作系统原理》课程设计报告课题名称：使用简单轮转法实现操作系统进程调度姓名：班级：学号：指导老师:二〇一三年十二月二十日目录第1章课题介绍 (4)1.1 课程设计的目的 (4)1.2 课程设计的要求 (4)第2章总体设计 (5)2.1程序流程图 (5)2.2软件模块图 (6)2.3设计原理 (7)2.4设计内容 (7)2.5主要功能 (8)2.6实现环境 (8)第3章详细设计及思考题 (9)3.1详细设计 (9)3.1.1数据结构 (9)3.1.3函数input() (9)3.2 思考题 (10)第4章程序测试 (12)第5章总结 (14)参考文献 (15)第1章课题介绍1.1 课程设计的目的进程是操作系统最重要的概念之一，进程调度又是操作系统核心的主要内容。

本次课程设计是要求学生独立地用高级语言编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先权调度算法和时间片轮转调度算法的具体实施办法。

调度算法可任意选择或自行设计。

任务一是采用简单轮转法。

本课题可以加深对进程调度和各种调度算法的理解，并通过课程设计，让我们更好的掌握操作系统的原理以及实现方法，加深对操作系统基础理论和重要算法的理解，加强我们自身的动手能力。

1.2 课程设计的要求1）设计一个有n个进程并发的进程调度程序。

每个进程由一个进程控制块（PCB）表示。

进程控制块一般应该包含下述信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等，且可按调度算法的不同而增删。

2）调度程序应包含1～2种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。

3）算法应能显示或打印各个进程的PID、状态（运行状态R、等待状态W 等）和参数（已运行时间等）的变化情况，便于观察诸进程的调度过程第2章总体设计2.1程序流程图轮转法进程调用先输入进程的格式及信息，然后对进程进行轮转法调度，按队列中进程的顺序依次运行程序，每运行完一次对其时间片相减，直到时间片用完，程序结束。

实验一处理器调度一、实验内容选择一个调度算法，实现处理器调度。

二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

三、实验题目第二题：设计一个按时间片轮转法实现处理器调度的程序。

[提示]：(1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：其中，Q1，Q2，Q3，Q4，Q5。

指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。

要求运行时间——假设进程需要运行的单位时间数。

已运行时间——假设进程已经运行的单位时间数，初始值为“0”。

状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。

当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如，当前轮到P2执行，则有：标志单元K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4)处理器调度总是选择标志单元指示的进程运行。

由于本实习是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。

在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。

处理器调度一、实习内容选择一个调度算法，实现处理器调度。

二、实习目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

三、实习题目本实习有两个题，学生可选择其中的一题做实习。

第二题：设计一个按时间片轮转法实现处理器调度的程序。

[提示]：(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：Q1，Q2，Q3，Q4，Q5。

指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。

要求运行时间——假设进程需要运行的单位时间数。

已运行时间——假设进程已经运行的单位时间数，初始值为“0”。

状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。

当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如，当前轮到P2执行，则有：标志单元，K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选择标志单元指示的进程运行。

由于本实习是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。

在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5) 进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。