C语言课程设计报告--进程调度

合集下载

实验三 进程调度(实验报告格式)

实验三 进程调度(实验报告格式)

实验三:进程调度一、实验目的(1)理解进程控制块和进程组织方式;(2)掌握时间片轮转调度算法实现处理机调度。

二、实验环境微型计算机,Ubuntu Linux10.04 ,gedit,gcc三、实验内容1建立合理的PCB数据结构,建立含有8个进程结点的就绪队列,每个进程的要求运行时间随机产生,要求每个进程的要求运行时间不大于15。

2 设置时间片大小(3~6),使用时间片轮转调度算法实现处理机调度。

四、实验结果五、源代码#include<stdio.h>#include<time.h>#include<malloc.h>#define T 8#define NUM 10typedef struct PCB{int name;int runtime;int runedtime;int killtime;struct PCB *next;}PCB;PCB *creat_jiuxu(PCB *top){PCB *temp;int i;srand((int)time(0));for(i=0;i<NUM;i++){temp=(PCB *)malloc(sizeof(PCB));temp->name=i;temp->runtime=rand()%15;temp->runedtime=0;temp->next=NULL;temp->killtime=0;if(i==0) top=temp;else{temp->next=top;top=temp;}}return top;}void run(PCB *top){PCB *tail=top;if(tail->next!=NULL)tail=tail->next;PCB *rq=NULL;while(top!=NULL){rq=top;if(rq->runtime<=rq->runedtime+T){printf("process_name:%d,runtime:%d,killtime:%d\n",rq->name,rq->runtime,rq->killtime);/*if(rq!=NULL) free(rq);*/top=top->next;}else{top=top->next;rq->runedtime+=T;rq->killtime++;tail->next=rq;tail=rq;rq->next=NULL;}}return;}int main(){PCB *top=NULL;top=creat_jiuxu(top);run(top);return 0;}。

实验一、进程调度实验报告

实验一、进程调度实验报告

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 CPU 资源给各个进程,以提高系统的整体性能和资源利用率。

通过本次实验,我们旨在深入理解进程调度的原理和算法,掌握进程状态的转换,观察不同调度策略对系统性能的影响,并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。

二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。

三、实验原理1、进程状态进程在其生命周期中会经历不同的状态,包括就绪态、运行态和阻塞态。

就绪态表示进程已经准备好执行,只等待 CPU 分配;运行态表示进程正在 CPU 上执行;阻塞态表示进程由于等待某个事件(如 I/O操作完成)而暂时无法执行。

2、调度算法常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)等。

先来先服务算法按照进程到达的先后顺序进行调度。

短作业优先算法优先调度执行时间短的进程。

时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片执行。

四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体,包含进程 ID、到达时间、执行时间、剩余时间等信息。

实现进程的创建、插入、删除等操作。

实现不同的调度算法。

2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。

分别采用先来先服务、短作业优先和时间片轮转算法进行调度。

记录每个算法下的平均周转时间、平均等待时间等性能指标。

五、实验步骤1、进程结构体的定义```c++struct Process {int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;};```2、进程创建函数```c++void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) {processesnumProcessespid = pid;processesnumProcessesarrivalTime = arrivalTime;processesnumProcessesexecutionTime = executionTime;processesnumProcessesremainingTime = executionTime;numProcesses++;}```3、先来先服务调度算法实现```c++void fcfsScheduling(Process processes, int numProcesses) {int currentTime = 0;for (int i = 0; i < numProcesses; i++){if (currentTime < processesiarrivalTime) {currentTime = processesiarrivalTime;}processesistartTime = currentTime;currentTime += processesiexecutionTime;processesifinishTime = currentTime;processesiwaitingTime = processesistartTime processesiarrivalTime;processesiturnaroundTime = processesifinishTime processesiarrivalTime;}}```4、短作业优先调度算法实现```c++void sjfScheduling(Process processes, int numProcesses) {int currentTime = 0;int minExecutionTime, selectedProcess;bool found;while (true) {found = false;minExecutionTime = INT_MAX;selectedProcess =-1;for (int i = 0; i < numProcesses; i++){if (processesiarrivalTime <= currentTime &&processesiremainingTime < minExecutionTime &&processesiremainingTime > 0) {found = true;minExecutionTime = processesiremainingTime;selectedProcess = i;}}if (!found) {break;}processesselectedProcessstartTime = currentTime;currentTime += processesselectedProcessremainingTime;processesselectedProcessfinishTime = currentTime;processesselectedProcesswaitingTime =processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime =processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime = 0;}}```5、时间片轮转调度算法实现```c++void rrScheduling(Process processes, int numProcesses, int timeSlice) {int currentTime = 0;Queue<int> readyQueue;for (int i = 0; i < numProcesses; i++){readyQueueenqueue(i);}while (!readyQueueisEmpty()){int currentProcess = readyQueuedequeue();if (processescurrentProcessarrivalTime > currentTime) {currentTime = processescurrentProcessarrivalTime;}if (processescurrentProcessremainingTime <= timeSlice) {currentTime += processescurrentProcessremainingTime;processescurrentProcessfinishTime = currentTime;processescurrentProcesswaitingTime =processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime =processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime = 0;} else {currentTime += timeSlice;processescurrentProcessremainingTime = timeSlice;readyQueueenqueue(currentProcess);}}}```6、性能指标计算函数```c++void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) {double totalWaitingTime = 0, totalTurnaroundTime = 0;for (int i = 0; i < numProcesses; i++){totalWaitingTime += processesiwaitingTime;totalTurnaroundTime += processesiturnaroundTime;}averageWaitingTime = totalWaitingTime / numProcesses; averageTurnaroundTime = totalTurnaroundTime / numProcesses;}```7、主函数```c++int main(){Process processes100;int numProcesses = 0;//创建进程createProcess(processes, numProcesses, 1, 0, 5);createProcess(processes, numProcesses, 2, 1, 3);createProcess(processes, numProcesses, 3, 2, 4);createProcess(processes, numProcesses, 4, 3, 2);//先来先服务调度fcfsScheduling(processes, numProcesses);double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime);cout <<"先来先服务调度的平均等待时间:"<<fcfsAverageWaitingTime << endl;cout <<"先来先服务调度的平均周转时间:"<<fcfsAverageTurnaroundTime << endl;//短作业优先调度sjfScheduling(processes, numProcesses);double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime);cout <<"短作业优先调度的平均等待时间:"<<sjfAverageWaitingTime << endl;cout <<"短作业优先调度的平均周转时间:"<<sjfAverageTurnaroundTime << endl;//时间片轮转调度(时间片为 2)rrScheduling(processes, numProcesses, 2);double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime);cout <<"时间片轮转调度(时间片为 2)的平均等待时间:"<< rrAverageWaitingTime << endl;cout <<"时间片轮转调度(时间片为 2)的平均周转时间:"<< rrAverageTurnaroundTime << endl;return 0;}```六、实验结果与分析1、先来先服务调度平均等待时间:40平均周转时间:85分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。

进程调度算法实验报告

进程调度算法实验报告

进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中的重要组成部分,它决定了进程在CPU上的执行顺序。

合理的进程调度算法能够提高系统的性能和效率,使得多个进程能够公平地共享CPU资源。

本实验旨在通过实际操作和数据分析,探究不同的进程调度算法对系统性能的影响。

二、实验方法1. 实验环境本次实验使用了一台配置较高的计算机作为实验环境,操作系统为Windows 10。

实验中使用了C语言编写的模拟进程调度程序。

2. 实验步骤(1)编写模拟进程调度程序,实现常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和优先级调度(Priority)。

(2)设计一组测试用例,包括不同执行时间的进程和不同优先级的进程。

(3)运行模拟进程调度程序,记录每个进程的等待时间、周转时间和响应时间。

(4)根据实验结果分析不同进程调度算法的性能差异。

三、实验结果与分析1. 先来先服务(FCFS)调度算法先来先服务调度算法按照进程到达的先后顺序进行调度,即先到达的进程先执行。

实验结果显示,该算法对于执行时间较短的进程表现良好,但对于执行时间较长的进程则存在明显的不公平性。

长作业的等待时间较长,导致整体执行效率较低。

2. 最短作业优先(SJF)调度算法最短作业优先调度算法按照进程执行时间的长度进行调度,即执行时间最短的进程先执行。

实验结果显示,该算法能够最大程度地减少平均等待时间和周转时间,提高系统的执行效率。

然而,该算法对于执行时间较长的进程存在饥饿问题,即长作业可能一直等待短作业的执行,导致长作业的等待时间过长。

3. 时间片轮转(RR)调度算法时间片轮转调度算法将CPU的执行时间划分为固定长度的时间片,每个进程按照轮流执行的方式进行调度。

实验结果显示,该算法能够保证每个进程都能够获得一定的执行时间,提高了系统的公平性。

然而,对于执行时间较长的进程而言,由于需要等待其他进程的轮转,其执行效率相对较低。

操作系统原理 实验一:进程调度实验报告书-模板

操作系统原理 实验一:进程调度实验报告书-模板

计算机科学系实验报告书课程名:《操作系统原理》题目:进程调度班级:学号:姓名:操作系统原理实验——进程调度实验报告一、目的与要求1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C 语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。

本实验可加深对进程调度算法的理解。

2)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果)3)于2012年10月22日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。

2 实验内容或题目1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。

2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。

3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。

4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。

3 实验步骤与源程序实验步骤:1、理解本实验中关于两种调度算法的说明。

2、根据调度算法的说明,画出相应的程序流程图。

3、按照程序流程图,用C语言编程并实现。

源程序:#include <stdlib.h>/*进程调度优先权法*/#include <stdio.h>#include <time.h>#define null 0struct PCB{int id;int prior;int used;int need;int run;char status;struct PCB * next;};main(){struct PCB *head,*rear,*temp,*run,*small,*p,*q;int i,j,t;printf("优先权进程调度算法\n\n 5个初始进程详细信息如下:\n\n");printf("\t进程号\t优先级\tused\tneed\t状态\t下一PCB\n\n");head=null;rear=null;for(i=1;i<=5;i++) { //动态生成含5个元素的队列temp=malloc(sizeof(struct PCB)); //动态分配一个PCB temp->id=i;temp->prior=rand()%5;temp->status='W';temp->next=null;if (head==null){head=temp;rear=head;}else{rear->next=temp;rear=temp;}}temp=head;while(temp!=null){printf("\t%d\t%d\t%c\t%d\n",temp->id,temp->prior,temp->status,temp->next);temp=temp->next;}getchar(); //让程序停下来,可以查看结果。

进程调度实验报告

进程调度实验报告

进程调度实验报告一、实验目的。

本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。

二、实验环境。

本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。

三、实验过程。

1. 先来先服务(FCFS)调度算法。

先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。

在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。

实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。

2. 最短作业优先(SJF)调度算法。

最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。

在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。

实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。

3. 时间片轮转(RR)调度算法。

时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。

在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。

实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。

4. 多级反馈队列(MFQ)调度算法。

多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。

在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。

实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。

四、实验总结。

通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。

进程调度操作系统实验报告

进程调度操作系统实验报告

进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理,通过实际编程和模拟,观察不同调度算法对系统性能的影响,并掌握进程调度的实现方法。

二、实验环境操作系统:Windows 10编程语言:C++开发工具:Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一,它负责决定哪个进程在何时获得 CPU 资源进行执行。

常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)、优先级调度等。

先来先服务算法按照进程到达的先后顺序进行调度,先到达的进程先获得 CPU 执行。

这种算法简单直观,但可能导致短作业等待时间过长。

短作业优先算法优先调度执行时间短的进程,能有效减少平均等待时间,但可能导致长作业饥饿。

时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片进行执行。

如果进程在时间片内未完成,则被放回就绪队列等待下一轮调度。

优先级调度根据进程的优先级来决定调度顺序,优先级高的进程先获得 CPU 资源。

四、实验步骤1、设计进程结构体定义进程的标识号(PID)、到达时间、服务时间、剩余时间、优先级等属性。

2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。

从就绪队列中取出第一个进程进行调度执行,直到其完成。

3、实现短作业优先算法计算每个进程的剩余服务时间。

将进程按照剩余服务时间从小到大排序,放入就绪队列。

从就绪队列中取出剩余服务时间最短的进程进行调度执行。

4、实现时间片轮转算法设定时间片大小。

将进程放入就绪队列,按照先来先服务的原则依次分配时间片执行。

进程在时间片内未完成的,放回就绪队列末尾。

5、实现优先级调度算法为每个进程设置优先级。

将进程按照优先级从高到低排序,放入就绪队列。

从就绪队列中取出优先级最高的进程进行调度执行。

6、计算平均周转时间和平均带权周转时间周转时间=完成时间到达时间带权周转时间=周转时间/服务时间平均周转时间=总周转时间/进程数平均带权周转时间=总带权周转时间/进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。

操作系统进程调度实验报告

操作系统进程调度实验报告

《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号2015年10月21日实验一进程调度1.实验目的:通过对进程调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度过程、调度算法的理解。

2.实验内容:用C语言实现对N个进程采用某种进程调度算法先来先服务调度、短作业优先调度的调度。

3.设计实现:要求给出设计源码,设计源码要有详细注释,#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/int atime; /*到达时间*/int stime; /*服务时间*/int ftime; /*完成时间*/int rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("根据到达时间重新排序:\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=0;i<n-1-j;i++)if(a[i].atime>a[i+1].atime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %d %d |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void fcfs(struct program a[],int n){int i;int time=0;for(i=0;i<n;i++){time=time+a[i].stime;a[i].ftime=a[0].atime+time;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=(float)a[i].rtime/a[i].stime;}printf("\nFCFS算法:\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %d %.2d %.2d %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******先来先服务算法****** \n");printf("请输入进程的数目:\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名,到达时间,服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);fcfs(pro,m);getchar();}#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/float atime; /*到达时间*/float stime; /*服务时间*/float ftime; /*完成时间*/float rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("重新排序:\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=1;i<n-1-j;i++)if(a[i].stime>a[i+1].stime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %f %f |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void SJF(struct program a[],int n){int i;a[0].ftime=a[0].atime+a[0].stime;a[0].rtime=a[0].ftime-a[0].atime;a[0].qrtime=a[0].rtime/a[0].stime;for(i=1;i<n;i++){a[i].ftime=a[i-1].ftime+a[i].stime;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=a[i].rtime/a[i].stime;}printf("\nSJF算法:\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %.2f %.2f %.2f %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******短作业优先算法****** \n");printf("请输入进程的数目:\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名,到达时间,服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);SJF(pro,m); getchar(); }4.实验结果5.实验过程中出现的问题及解决办法先来先服务调度算法就是根据进程达到的时间为依据,哪一个进程先来那么该进程就会先执行;最短进程优先调度算法则是以每个进程执行所需时间长短为依据,某一个进程执行所需花的时间要短些那么该进程就先执行。

实验进程调度的实验报告

实验进程调度的实验报告

一、实验目的1. 加深对进程概念和进程调度算法的理解。

2. 掌握进程调度算法的基本原理和实现方法。

3. 培养编程能力和系统分析能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块(PCB)3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一,负责将CPU分配给就绪队列中的进程。

常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、优先级调度、时间片轮转(RR)等。

1. 先来先服务(FCFS)算法:按照进程到达就绪队列的顺序进行调度。

2. 短作业优先(SJF)算法:优先调度运行时间最短的进程。

3. 优先级调度算法:根据进程的优先级进行调度,优先级高的进程优先执行。

4. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行,时间片结束后进行调度。

五、实验步骤1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、运行时间、优先级、状态等信息。

2. 创建进程队列,用于存储就绪队列、等待队列和完成队列。

3. 实现进程调度算法:a. FCFS算法:按照进程到达就绪队列的顺序进行调度。

b. SJF算法:优先调度运行时间最短的进程。

c. 优先级调度算法:根据进程的优先级进行调度。

d. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行。

4. 模拟进程调度过程:a. 初始化进程队列,将进程添加到就绪队列。

b. 循环执行调度算法,将CPU分配给就绪队列中的进程。

c. 更新进程状态,统计进程执行时间、等待时间等指标。

d. 当进程完成时,将其移至完成队列。

六、实验结果与分析1. FCFS算法:按照进程到达就绪队列的顺序进行调度,简单易实现,但可能导致短作业等待时间过长。

2. SJF算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。

操作系统C-进程调度算法实验报告

操作系统C-进程调度算法实验报告
华北科技学院计算机系综合性实验
实验报告
课程名称操作系统C
实验学期2012
至2013学年第2学期
学生所在系部
计算机系
年级2010
专业班级网络B10
学生姓名
学号
任课教师
杜杏菁
实验成绩
计算机系制
《操作系统
开课实验室:基础六机房2013年6月3日
实验题目进程调度算法模拟
一、
通过对进程调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度过程、 调度算法的理解。
进程标识数ID。
进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高。
进程已占用CPU时间CPUTIME
进程还需占用的CPU时间ALLTIME。当进程运行完毕时,ALLTIME变为0。
进程的阻塞时间STARTBLOCK表示当进程再运行STARTBLOC个时间片后,进程将进入阻塞 状态。
进程被阻塞的时间BLOCKTIME表示已阻塞的进程再等待BLOCKTIM个时间片后,将转换成 就绪状态。
进程状态STATE
队列指针NEXT用来将PCB排成队列。
(3)优先数改变的原则:
进程在就绪队列中呆一个时间片,优先数增加1。
进程每运行一个时间片,优先数减3。
(4)为了清楚地观察每个进程的调度过程,程序应将每个时间片内的进程的情况显示出来,包
括正在运行的进程,处于就绪队列中的进程和处于阻塞队列中的进程。
cin> >pro[i]. name»pro[i].atime»pro[i].stime;
}
xia nshi(pro,m);
fcfs(pro,m);
getchar();
}

进程的调度实验报告(3篇)

进程的调度实验报告(3篇)

第1篇一、实验目的通过本次实验,加深对操作系统进程调度原理的理解,掌握先来先服务(FCFS)、时间片轮转(RR)和动态优先级(DP)三种常见调度算法的实现,并能够分析这些算法的优缺点,提高程序设计能力。

二、实验环境- 编程语言:C语言- 操作系统:Linux- 编译器:GCC三、实验内容本实验主要实现以下内容:1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、优先级、状态等信息。

2. 实现三种调度算法:FCFS、RR和DP。

3. 创建一个进程队列,用于存储所有进程。

4. 实现调度函数,根据所选算法选择下一个执行的进程。

5. 模拟进程执行过程,打印进程执行状态和就绪队列。

四、实验步骤1. 定义PCB结构体:```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待,1: 运行,2: 完成} PCB;```2. 创建进程队列:```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法:(1)FCFS调度算法:```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(2)RR调度算法:```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(3)DP调度算法:```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程:```cvoid simulateProcess() {printf("请选择调度算法(1:FCFS,2:RR,3:DP):");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。

C语言课程设计报告--进程调度

C语言课程设计报告--进程调度

C语言程序设计课程设计题目:进程调度院(系):专业班级:学号:学生姓名:指导教师:教师职称:起止时间:课程设计(报告)任务及评语目录第1章课程设计的目的与要求 (1)1.1 课程设计目的 (1)1.2 课程设计的实验环境 (1)1.3 课程设计的预备知识 (1)1.4 课程设计要求 (1)第2章课程设计内容 (2)2.1程序功能介绍 (2)2.2程序整体设计说明 (2)2.2.1设计思路 (2)2.2.2数据结构设计及用法说明 (3)2.2.3程序结构(流程图) (4)2.2.4各模块的功能及程序说明 (4)2.2.5程序结果 (5)2.3程序源代码及注释 (6)第3章课程设计总结 (13)参考资料 (14)第1章课程设计的目的与要求1.1 课程设计目的本课程设计是计算机科学与技术专业重要的实践性环节之一,是在学生学习完《程序设计语言(C)》课程后进行的一次全面的综合练习。

本课程设计的目的和任务:1. 巩固和加深学生对C语言课程的基本知识的理解和掌握2. 掌握C语言编程和程序调试的基本技能3. 利用C语言进行基本的软件设计4. 掌握书写程序设计说明文档的能力5. 提高运用C语言解决实际问题的能力1.2 课程设计的实验环境硬件要求能运行Windows 2000/XP操作系统的微机系统。

C语言程序设计及相应的开发环境。

1.3 课程设计的预备知识熟悉C语言及C语言开发工具。

1.4 课程设计要求1. 分析课程设计题目的要求2. 写出详细设计说明3. 编写程序代码,调试程序使其能正确运行4. 设计完成的软件要便于操作和使用5. 设计完成后提交课程设计报告第2章课程设计内容2.1程序功能介绍在多道程序环境下,进程数目往往多于处理机数目,致使他们争用处理机。

这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之运行。

分配处理机的任务是由进程调度程序完成的。

一个进程被建立后,系统为了便于对进程进行管理,将系统中的所有进程按其状态,将其组织成不同点进程队列。

进程调度算法实验报告

进程调度算法实验报告

操作系统实验报告(二)实验题目:进程调度算法实验环境:C++实验目得:编程模拟实现几种常见得进程调度算法,通过对几组进程分别使用不同得调度算法,计算进程得平均周转时间与平均带权周转时间,比较各种算法得性能优劣.实验内容:编程实现如下算法:1、先来先服务算法;2、短进程优先算法;3、时间片轮转调度算法。

设计分析:程序流程图:1、先来先服务算法2、短进程优先算法3、时间片轮转调度算法实验代码:1.先来先服务算法#include <iostream、h〉#definen20typedef struct{int id;//进程名int atime; //进程到达时间intruntime; //进程运行时间}fcs;voidmain(){intamount,i,j,diao,huan;fcs f[n];cout<<”请输入进程个数:”<〈endl;cin>>amount;for(i=0;i<amount;i++){cout<<"请输入进程名,进程到达时间,进程运行时间:”〈<endl;cin>>f[i]、id;cin〉>f[i]、atime;cin〉〉f[i]、runtime;}for(i=0;i〈amount;i++)//按进程到达时间得先后排序{ //如果两个进程同时到达,按在屏幕先输入得先运行for(j=0;j〈amount—i—1;j++){if(f[j]、atime〉f[j+1]、atime){diao=f[j]、atime;f[j]、atime=f[j+1]、atime;f[j+1]、atime=diao;huan=f[j]、id;f[j]、id=f[j+1]、id;f[j+1]、id=huan;}}}for(i=0;i<amount;i++){cout〈<”进程:"<〈f[i]、id<〈”从"〈<f[i]、atime〈<”开始”〈<",”<<"在"〈〈f[i]、atime+f[i]、runtime<<”之前结束。

操作系统C-进程调度算法实验报告

操作系统C-进程调度算法实验报告

操作系统C-进程调度算法实验报告1. 实验背景操作系统涉及到的进程调度算法是操作系统中的核心知识之一,这也是操作系统中较为重要的内容之一。

进程调度算法可以直接影响到操作系统的性能和系统的响应时间,因此这一方面是操作系统学习中不可避免的。

为了更好的理解和掌握进程调度算法,本次实验选用了比较经典的进程调度算法——SJF算法和RR算法,并对其进行详细的实验和分析。

2. 实验环境•操作系统:Windows 10•编译器:Dev-C++3. 实验内容本次实验分为两部分,第一部分为SJF算法的实验,第二部分为RR算法的实验。

3.1 实验一:SJF算法本实验中,我们首先编写了一个随机生成进程的程序,并为每个进程随机分配一个运行时间。

然后,我们用SJF算法对这些进程进行调度,记录下调度过程和每个进程的运行情况,最后统计出SJF算法的平均等待时间、平均周转时间和吞吐量。

3.1.1 实验步骤以下是我们在SJF算法实验中采取的步骤和操作:•首先编写程序生成随机进程•对每个进程分配随机运行时间•对进程按照时间长度进行排序•模拟SJF算法进行调度•计算平均等待时间、平均周转时间和吞吐量3.1.2 实验结果经过实验,得到以下结果:•平均等待时间:13.97•平均周转时间:18.53•吞吐量:4.763.2 实验二:RR算法本实验中,我们使用Round Robin调度算法,对进程进行调度,并记录下调度过程和每个进程的运行情况,最后统计出RR算法的平均等待时间、平均周转时间和吞吐量。

3.2.1 实验步骤以下是我们在RR算法实验中采取的步骤和操作:•首先编写程序生成随机进程•对每个进程分配随机运行时间•设定时间片大小•模拟RR算法进行调度•计算平均等待时间、平均周转时间和吞吐量3.2.2 实验结果经过实验,得到以下结果:•平均等待时间:25.63•平均周转时间:30.18•吞吐量:1.094. 实验分析4.1 SJF算法分析从SJF算法的实验结果可以看出,该算法能够在大多数情况下有效地减少进程的平均等待时间和平均周转时间,但是也存在一些问题,比如会导致优先级反转等情况,需要进一步考虑如何避免这些问题。

进程调度实验报告

进程调度实验报告

进程调度实验报告进程调度实验报告一、引言进程调度是操作系统中重要的一个组成部分,它负责管理和分配系统资源给不同的进程,以实现系统的高效运行。

本次实验旨在通过实际操作和观察,深入理解进程调度算法的原理和应用。

二、实验目的1. 理解进程调度的概念和作用;2. 掌握常见的进程调度算法;3. 分析不同调度算法的优缺点。

三、实验环境本次实验使用的是Linux操作系统,并通过编写C语言程序来模拟进程的创建和调度过程。

四、实验过程1. 创建进程在实验开始时,我们首先编写了一个简单的C程序,用于创建多个进程。

通过调用系统函数fork(),我们可以实现进程的复制和创建。

在实验中,我们创建了5个子进程,并分别给它们设置了不同的优先级。

2. 进程调度算法的实现为了模拟不同的进程调度算法,我们在程序中实现了以下几种常见的调度算法:- 先来先服务(FCFS):按照进程到达的先后顺序进行调度,即先到先服务。

- 短作业优先(SJF):按照进程的执行时间进行排序,优先调度执行时间最短的进程。

- 优先级调度:按照进程的优先级进行排序,优先调度优先级最高的进程。

- 时间片轮转调度:将CPU时间分成若干个时间片,每个进程在一个时间片内执行,超过时间片后,将CPU让给下一个进程。

3. 实验结果分析通过运行程序,我们观察到不同调度算法下进程的执行情况,并进行了分析。

- 在先来先服务算法下,进程按照到达的先后顺序进行调度,执行时间较长的进程可能会导致其他进程的等待时间增加。

- 在短作业优先算法下,执行时间短的进程会被优先调度,可以减少平均等待时间,但可能会导致长作业的饥饿。

- 在优先级调度算法下,优先级高的进程会被优先调度,但如果优先级设置不合理,可能会导致低优先级进程长时间等待。

- 在时间片轮转调度算法下,每个进程被分配一个时间片,可以保证每个进程公平地获得执行机会,但如果时间片过小,会导致频繁的上下文切换。

五、实验总结通过本次实验,我们深入了解了进程调度的原理和应用。

进程调度实验报告源码

进程调度实验报告源码

一、实验目的本次实验旨在通过模拟进程调度过程,加深对进程调度算法的理解,并掌握进程调度程序的设计与实现方法。

实验内容主要包括:创建进程、进程调度、进程执行、进程结束等。

二、实验环境操作系统:Linux编程语言:C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法:FIFO(先进先出)、时间片轮转法、多级反馈队列调度算法。

2. 进程调度程序设计进程调度程序主要由以下部分组成:(1)进程控制块(PCB)PCB用于描述进程的基本信息,包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。

(2)就绪队列就绪队列用于存储处于就绪状态的进程,按照进程的优先级或到达时间进行排序。

(3)进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行,并将CPU分配给该进程。

(4)进程执行函数进程执行函数负责模拟进程的执行过程,包括进程的创建、执行、结束等。

四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明,FIFO调度算法按照进程的到达时间进行调度,可能导致短作业等待时间长,效率较低。

进程调度算法 实验报告

进程调度算法 实验报告

进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中非常重要的一部分,它决定了系统中各个进程的执行顺序和时间分配。

在本次实验中,我们将研究和比较几种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、轮转法(RR)和优先级调度算法。

二、实验目的本次实验的目的是通过模拟不同的进程调度算法,观察它们在不同情况下的表现,并比较它们的优缺点,以便更好地理解和应用这些算法。

三、实验过程1. 实验环境准备我们使用C语言编写了一个简单的进程调度模拟程序,该程序可以模拟不同的进程调度算法,并输出每个进程的执行顺序和等待时间等信息。

2. 实验步骤(1)先来先服务(FCFS)算法FCFS算法是最简单的一种进程调度算法,它按照进程的到达顺序来执行。

我们通过模拟多个进程的到达时间和执行时间,观察它们的执行顺序和等待时间。

(2)最短作业优先(SJF)算法SJF算法是根据进程的执行时间来进行调度的,执行时间越短的进程优先执行。

我们通过模拟多个进程的执行时间,观察它们的执行顺序和等待时间。

(3)轮转法(RR)算法RR算法是一种时间片轮转的调度算法,每个进程被分配一个时间片,当时间片用完后,进程被挂起,等待下一次调度。

我们通过模拟不同的时间片大小,观察进程的执行顺序和等待时间。

(4)优先级调度算法优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程优先执行。

我们通过模拟不同的进程优先级,观察进程的执行顺序和等待时间。

四、实验结果与分析1. 先来先服务(FCFS)算法当进程的执行时间相差不大时,FCFS算法的等待时间较长,因为后到达的进程需要等待前面的进程执行完毕。

但如果有一个进程的执行时间很长,其他进程的等待时间就会很短。

2. 最短作业优先(SJF)算法SJF算法能够保证最短执行时间的进程先执行,因此平均等待时间较短。

但如果有一个执行时间很长的进程到达,其他进程的等待时间就会变长。

c语言编写的进程调度算法

c语言编写的进程调度算法

c语言编写的进程调度算法C语言编写的进程调度算法进程调度是操作系统的核心功能之一,它负责按照一定的策略和算法,合理地分配CPU资源给正在运行或即将运行的进程,从而提高操作系统的性能和资源利用率。

在操作系统中,存在多种不同的进程调度算法,本文将以C语言编写进程调度算法为主题,一步一步回答。

第一步:定义进程结构体首先,我们需要定义一个进程的数据结构体,以便在调度算法中使用。

进程结构体包括进程ID、进程优先级、进程状态等信息。

以下是一个简单的进程结构体示例:ctypedef struct {int pid; 进程IDint priority; 进程优先级int state; 进程状态} Process;第二步:初始化进程队列进程队列是存储所有待调度进程的数据结构,可以使用链表或数组来实现。

在初始化进程队列之前,需要先创建一个空的进程队列。

以下是一个简单的初始化进程队列函数:c#define MAX_PROCESSES 100 最大进程数Process processQueue[MAX_PROCESSES]; 进程队列int processCount = 0; 当前进程数void initProcessQueue() {processCount = 0;}第三步:添加进程到队列在调度算法中,需要将新创建或运行的进程添加到进程队列中,这样才能对其进行调度。

以下是一个简单的添加进程到队列的函数:void addProcess(int pid, int priority, int state) {if (processCount >= MAX_PROCESSES) {printf("进程队列已满,无法添加进程!\n");return;}Process newProcess;newProcess.pid = pid;newProcess.priority = priority;newProcess.state = state;processQueue[processCount] = newProcess;processCount++;}第四步:实现进程调度算法进程调度算法决定了操作系统如何决定哪个进程应该被调度并获得CPU 资源。

进程调度程序设计报告

进程调度程序设计报告

1、目的进程调度是处理机管理的核心内容。

本设计要求用C语言编写和调试一个简单的进程调度程序。

通过设计本可以加深理解有关进程控制块、进程队列的概念,并体会和了解最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法的具体实施办法。

2、要求1)进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。

2)每个进程有一个进程控制块(PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

3)进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

4)每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。

5)就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤销该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

6)每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。

7)重复以上过程,直到所有进程都完成为止。

二、课程设计环境要求1、硬件环境联想系列电脑Intel(R)Pentium(R)DualCPU主频2GHz内存1G2、软件环境Microsoft Windows Xp Professional版本2002装有Turbo C2.0软件三、设计任务介绍及系统需求分析1、设计任务的介绍根据设计任务书的要求,画出程序设计流程图,确定程序的功能,把整个程序根据功能要求分解为各个子程序,利用TC语言编写程序代码,然后进行上机调试、修改、进行连接、测试,写出设计总结报告。

进程调度设计

进程调度设计

实验报告院(系):数学与计算机科学学院专业班级:学号:姓名:实验地点:嵌入式实验室实验日期:年月日课程名称实验项目名称实验学时实验类型计算机操作系统进程调度设计 2一、实验目的及要求进程调度是处理机管理的核心内容。

本实验要求用C语言编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念,并体会和了解FIFO调度算法的具体实现方法。

二、实验环境PC /Windows系统/Visual C++6.0三、实验内容①设计进程控制块PCB表结构。

②编制FIFO进程调度算法.四、实验步骤#include<stdio.h>#include<stdlib.h>typedef struct node{char name; //进程名字int status; //进程数据int precendence; //进程优先级int ax,bx,cx,dx; //寄存器int pc;int psw; //程序状态struct node *next; //指向下个进程的指针}pcb;pcb *CreateProcess(pcb *head,int n);void ProcessFiFo(pcb *head);pcb *CreateProcess(pcb *head,int n){pcb *p,*q;head = (pcb *)malloc(sizeof(pcb));head->next = NULL;p = head;for(int i = 0;i < n;i++){q = (pcb *)malloc(sizeof(pcb));printf("请输入第%d个进程名字:",i+1);scanf("%c",&q->name);getchar();printf("输入进程相关数据:");scanf("%d",&q->status);fflush(stdin);q->next = p->next;p->next = q;p = q;}return head;}void ProcessFiFo(pcb *head) /*use fifo */{pcb *p;p = head->next;printf("进程运行顺序:");while(p){printf("%c ",p->name);p = p->next;}printf("\n");}void main(){pcb *head;int n;printf("请输入需创建进程个数:");scanf("%d",&n);getchar();head = CreateProcess(head,n);ProcessFiFo(head);}五、总结在本次实验中通过对有关进程控制块、进程队列的概念的了解,在实践中学会了简单的操作,但还是有些许问题有待改进。

进程调度算法设计报告

进程调度算法设计报告

操作系统课程设计进程调度算法姓名班级学号一,实验目的:通过时间片轮转调度算法的模拟加深对进程概念和进程调度过程的理解,掌握进程状态之间的切换,同时掌握进程调度算法的实现方法和技巧。

二,实验内容:用C++语言来实现对N个进程采用优先算法以及轮转算法的进程调度。

三,程序设计细节:1.定义描述程序的结构体PCBtypedef struct pcb{char pname[N]; //进程名int runtime; //运行时间int arrivetime; //到达时间char state; //进程状态struct pcb*next; //连接指针}PCB;static char R='r',C='c';//可选进程的状态unsigned long current;//记录系统当前时间的变量2.建立进程的函数void inputprocess(){PCB*p1,*p2;int num;printf("How many process do you want to run:"); scanf("%d",&num);//输入进程数p1=&head_input;p2=p1;p1->next=new PCB;p1=p1->next; //P1指向头指针的下一个结点for(int i=0;i<num;i++){printf("Input NO.%3d process pname:",i+1);scanf("%s",p1->pname);printf("runtime:");scanf("%d",&(p1->runtime));printf("arrivetime:");scanf("%d",&(p1->arrivetime));p1->runtime=(p1->runtime)*1000;p1->arrivetime=(p1->arrivetime)*1000;p1->state=R;p1->next=new PCB;p2=p1;p1=p1->next;} //采用链表的尾插法将所有进程连接起来delete p1;p1=NULL;p2->next=NULL;} //P2始终指向最后一个进程3.判断是否有就绪进程的函数int readydata()//判断就绪队列是否为空的函数{if(head_input.next==NULL){if(head_run.next==NULL)//当就像且运行队列均为空时{return 0;}else{return 1;}}PCB*p1,*p2,*p3;p1=head_run.next;p2=&head_run;while(p1!=NULL)//判断运行队列是否为空{p2=p1;p1=p2->next;}p1=p2;p3=head_input.next;p2=&head_input;while(p3!=NULL)//判断就绪队列不空时,将它们移到运行队列{if(((unsignedlong)p3->arrivetime<=current)&&(p3->state==R)) {printf("Time is%4d;Process%s start,\n",\(current+500)/1000,p3->pname);p2->next=p3->next;p3->next=p1->next;p1->next=p3;p3=p2;}p2=p3;p3=p3->next;}return 1;}4.运行进程的函数int runprocess(){PCB*p1,*p2;if(head_run.next==NULL)//运行队列为空时,修改当前时间{current++;return 1;}else{p1=head_run.next; //指向下一个进程p2=&head_run;while(p1!=NULL)//由运行队列顺序取一个进程运行{p1->runtime--;current++;if(p1->runtime<=0){printf("Time is%4d;Process%s end,\n",\ (current+500)/1000,p1->pname);p1->state=C;p2->next=p1->next; delete p1;p1=NULL;}else{p2=p1;p1=p2->next;}}return 1;}}int readyprocess(){while(1){if(readydata()==0)//判断就绪队列是否为空的函数{return 1;}else{runprocess();//运行进程函数}}}void main(){printf("time l=1000 time slice\n");//定义时间片为1000 current=0;inputprocess();readyprocess();}四.测试截图。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

C语言程序设计课程设计题目:进程调度院(系):专业班级:学号:学生姓名:指导教师:教师职称:起止时间:课程设计(报告)任务及评语目录第1章课程设计的目的与要求 (1)1.1 课程设计目的 (1)1.2 课程设计的实验环境 (1)1.3 课程设计的预备知识 (1)1.4 课程设计要求 (1)第2章课程设计内容 (2)2.1程序功能介绍 (2)2.2程序整体设计说明 (2)2.2.1设计思路 (2)2.2.2数据结构设计及用法说明 (3)2.2.3程序结构(流程图) (4)2.2.4各模块的功能及程序说明 (4)2.2.5程序结果 (5)2.3程序源代码及注释 (6)第3章课程设计总结 (13)参考资料 (14)第1章课程设计的目的与要求1.1 课程设计目的本课程设计是计算机科学与技术专业重要的实践性环节之一,是在学生学习完《程序设计语言(C)》课程后进行的一次全面的综合练习。

本课程设计的目的和任务:1. 巩固和加深学生对C语言课程的基本知识的理解和掌握2. 掌握C语言编程和程序调试的基本技能3. 利用C语言进行基本的软件设计4. 掌握书写程序设计说明文档的能力5. 提高运用C语言解决实际问题的能力1.2 课程设计的实验环境硬件要求能运行Windows 2000/XP操作系统的微机系统。

C语言程序设计及相应的开发环境。

1.3 课程设计的预备知识熟悉C语言及C语言开发工具。

1.4 课程设计要求1. 分析课程设计题目的要求2. 写出详细设计说明3. 编写程序代码,调试程序使其能正确运行4. 设计完成的软件要便于操作和使用5. 设计完成后提交课程设计报告第2章课程设计内容2.1程序功能介绍在多道程序环境下,进程数目往往多于处理机数目,致使他们争用处理机。

这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之运行。

分配处理机的任务是由进程调度程序完成的。

一个进程被建立后,系统为了便于对进程进行管理,将系统中的所有进程按其状态,将其组织成不同点进程队列。

于是系统中有运行进程队列、就绪队列和各种事件的进程等待队列。

进程调度的功能就是从就绪队列中挑选一个进程到处理机上运行。

2.2程序整体设计说明用C语言实现进程调度-操作系统课程设计设计思想:“最高优先数优先”调度算法的基本思想是把cpu分配给就绪队列中优先数最高的进程。

采用动态优先数,即优先数在创建进程时给定一个初始值,当进程获得一次cpu后其优先数就减少1。

它用C语言编写的实现模拟进程调度的程序,用户模拟几个进程,输入它们的进程名,优先级,运行时间等,进程的初使状态为就绪状态。

然后就按优先级优先方式调度各个进程,进程的状态也因此会变成等待状态或完成状态。

2.2.1设计思路进程是当前操作系统下一个被加载到内存的、正在运行的应用程序的实例。

每一个进程都是由内核对象和地址空间所组成的,内核对象可以让系统在其内存放有关进程的统计信息并使系统能够以此来管理进程,而地址空间则包括了所有程序模块的代码和数据以及线程堆栈、堆分配空间等动态分配的空间。

进程仅仅是一个存在,是不能独自完成任何操作的,必须拥有至少一个在其环境下运行的线程,并由其负责执行在进程地址空间内的代码。

在进程启动的同时即同时启动了一个线程,该线程被称作主线程或是执行线程,由此线程可以继续创建子线程。

如果主线程退出,那么进程也就没有存在的可能了,系统将自动撤消该进程并完成对其地址空间的释放。

加载到进程地址空间的每一个可执行文件或动态链接库文件的映象都会被分配一个与之相关联的全局唯一的实例句柄。

该实例句柄实际是一个记录有进程加载位置的基本内存地址。

进程的实例句柄在程序入口函数中通过第一个参数传递,其实际值即为进程所使用的基本地址空间的地址。

对于VC++链接程序所链接产生的程序,其默认的基本地址空间地址为0x00400000,如没有必要一般不要修改该值。

通过创建一个新的进程及在其地址空间内运行的主线程来启动并运行一个新的程序。

具体的,在执行函数时,首先由操作系统负责创建一个进程内核对象,初始化计数为1,并立即为新进程创建一块虚拟地址空间。

随后将可执行文件或其他任何必要的动态链接库文件的代码和数据装载到该地址空间中。

在创建主线程时,也是首先由系统负责创建一个线程内核对象,并初始化为1。

最后启动主线程并执行进程的入口函数RunProc(),完成对进程和执行线程的创建。

2.2.2数据结构设计及用法说明数据结构设计:本程序运用了struct函数,并用if语句判断运行指针,用while循环语句确定插入位置。

int round; /*进程时间轮转时间片*/int cputime; /*进程占用CPU时间*/int needtime; /*进程到完成还要的时间*/int count; /*计数器*/char state; /*进程的状态*/用法说明:1.进程通过定义一个进程控制块的数据结构(PCB)来表示;2.每个进程需要赋予进程信息、进程到达时间、进程需要运行的总时间的属性;3.在程序进程中,以1为时间片单位;4.运行时,输入5个进程序列,按照进程的信息输出其执行序列。

2.2.3程序结构(流程图)2.2.4各模块的功能及程序说明①高级调度模块:又称作业调度。

其主要功能是根据一定的算法,从输人的一批作业中选出若干个作业,分配必要的资源,如内存、外设等,为它建立相应的用户作业进程和为其服务的系统进程(如输人、输出进程),最后把它们的程序和数据调人内存,等待进程调度程序对其执行调度,并在作业完成后作善后处理工作。

②中级调度模块:又称交换调度。

为了使内存中同时存放的进程数目不至于太多,有时就需要把某些进程从内存中移到外存上,以减少多道程序的数目,为此设立了中级调度。

特别在采用虚拟存储技术的系统或分时系统中,往往增加中级调度这一级。

所以中级调度的功能是在内存使用情况紧张时,将一些暂时不能运行的讲程从内存对换到外存上等待。

当以后内存有足够的空闲空间时,再将合适的进程重新换人内存,等待进程调度。

引人中级调度的主要目的是为了提高内存的利用率和系统吞吐量。

它实际上就是存储器管理中的对换功能。

③低级调度模块:又称进程调度。

其主要功能是根据一定的算法将CPU分派给就绪队列中的一个进程。

执行低级调度功能的程序称做进程调度程序,由它实现CPU在进程间的切换。

进程调度的运行频率很高,在分时系统中往往几十毫秒就要运行一次。

进程调度是操作系统中最基本的一种调度。

在一般类型的操作系统中都必须有进程调度,而且它的策略的优劣直接影响整个系统的计能。

2.2.5程序结果2.3程序源代码及注释int round; /*进程时间轮转时间片*/int cputime; /*进程占用CPU时间*/int needtime; /*进程到完成还要的时间*/int count; /*计数器*/char state; /*进程的状态*/struct node *next;} /*链指针*/PCB;PCB *finish,*ready,*tail,*run; /*队列指针*/int N; /*进程数*//*将就绪队列中的第一个进程投入运行*/firstin(){run=ready; /*就绪队列头指针赋值给运行头指针*/ run->state='R'; /*进程状态变为运行态*/ready=ready->next;} /*就绪对列头指针后移到下一进程*/ /*标题输出函数*/void prt1(char a){if(toupper(a)=='P') /*优先数法*/printf(" name cputime needtime priority state\n");elseprintf(" name cputime needtime count round state\n");} /*进程PCB输出*/void prt2(char a,PCB *q){if(toupper(a)=='P') /*优先数法的输出*/printf(" %-10s%-10d%-10d%-10d %c\n",q->name,q->cputime,q->needtime,q->prio,q->state);else /*轮转法的输出*/printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);} /*输出函数*/ void prt(char algo){PCB *p;prt1(algo); /*输出标题*/if(run!=NULL) /*如果运行指针不空*/prt2(algo,run); /*输出当前正在运行的PCB*/p=ready; /*输出就绪队列PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}p=finish; /*输出完成队列的PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}getch();} /*压任意键继续*//*优先数的插入算法*/insert1(PCB *q){PCB *p1,*s,*r;int b;s=q; /*待插入的PCB指针*/p1=ready; /*就绪队列头指针*/r=p1; /*r做p1的前驱指针*/b=1;while((p1!=NULL)&&b) /*根据优先数确定插入位置*/if(p1->prio>=s->prio){r=p1;p1=p1->next;}elseb=0;if(r!=p1) /*如果条件成立说明插入在r与p1之间*/{r->next=s;s->next=p1;}else{s->next=p1; /*否则插入在就绪队列的头*/ready=s;}}__page_break__ /*轮转法插入函数*/insert2(PCB *p2){tail->next=p2; /*将新的PCB插入在当前就绪队列的尾*/tail=p2;p2->next=NULL;} /*优先数创建初始PCB信息*/void create1(char alg){PCB *p;int i,time;char na[10];ready=NULL; /*就绪队列头指针*/finish=NULL; /*完成队列头指针*/run=NULL; /*运行队列指针*/printf("Enter name and time of process\n"); /*输入进程标识和所需时间创建PCB*/ for(i=1;i<=N;i++){p=malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='w';p->prio=50-time;if(ready!=NULL) /*就绪队列不空调用插入函数插入*/insert1(p);else{p->next=ready; /*创建就绪队列的第一个PCB*/ready=p;}}clrscr();printf(" output of priority:\n");printf("************************************************\n"); prt(alg); /*输出进程PCB信息*/run=ready; /*将就绪队列的第一个进程投入运行*/ready=ready->next;run->state='R';} /*轮转法创建进程PCB*/void create2(char alg){PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;printf("Enter name and time of round process\n");for(i=1;i<=N;i++){p=malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->count=0; /*计数器*/p->state='w';p->round=2; /*时间片*/if(ready!=NULL)insert2(p);else{p->next=ready;ready=p;tail=p;}}clrscr();printf(" output of round\n");printf("************************************************\n"); prt(alg); /*输出进程PCB信息*/run=ready; /*将就绪队列的第一个进程投入运行*/ready=ready->next;run->state='R';}__page_break__ /*优先数调度算法*/priority(char alg){while(run!=NULL) /*当运行队列不空时,有进程正在运行*/{run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/if(run->needtime==0) /*如所需时间为0将其插入完成队列*/ {run->next=finish;finish=run;run->state='F'; /*置状态为完成态*/run=NULL; /*运行队列头指针为空*/if(ready!=NULL) /*如就绪队列不空*/firstin();} /*将就绪对列的第一个进程投入运行*/else /*没有运行完同时优先数不是最大,则将其变为就绪态插入到就绪队列*/ if((ready!=NULL)&&(run->prio<ready->prio)){run->state='W';insert1(run);firstin();} /*将就绪队列的第一个进程投入运行*/prt(alg);}} /*输出进程PCB信息*//*时间片轮转法*/roundrun(char alg){while(run!=NULL){run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->count=run->count+1;if(run->needtime==0)/*运行完将其变为完成态,插入完成队列*/{run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)firstin();} /*就绪对列不空,将第一个进程投入运行*/elseif(run->count==run->round) /*如果时间片到*/{run->count=0; /*计数器置0*/if(ready!=NULL) /*如就绪队列不空*/{run->state='W'; /*将进程插入到就绪队列中等待轮转*/insert2(run);firstin();}} /*将就绪对列的第一个进程投入运行*/prt(alg);}} /*输出进程信息*/main() /*主函数*/{char algo; /*算法标记*/clrscr();printf("type the algorithm:P/R(priority/roundrobin)\n"); scanf("%c",&algo); /*输入字符确定算法*/printf("Enter process number\n");scanf("%d",&N); /*输入进程数*/if(algo=='P'||algo=='p'){create1(algo); /*优先数法*/priority(algo);}elseif(algo=='R'||algo=='r'){create2(algo); /*轮转法*/roundrun(algo)}第3章课程设计总结我对C语言的敬仰,由来已久,C语言在我的世界里占有的地位无所能及,就像一位多年的老朋友,纵然是有那么多的课程,那么多的纷扰,他始终在我左右。

相关文档
最新文档