操作系统实验(进程调度+存储管理+磁盘调度++银行家算法+文件系统设计)
操作系统十大算法具体内容

操作系统十大算法具体内容操作系统是计算机系统的核心组成部分,主要负责管理计算机的硬件资源和提供各种系统服务。
操作系统算法是操作系统实现各种功能和服务的基础,包括进程调度、内存管理、文件系统等方面。
下面将介绍操作系统中的十大算法,以及它们在操作系统中的具体内容:1.进程调度算法进程调度算法决定了操作系统如何选择就绪队列中的进程分配处理机资源。
常见的进程调度算法包括先来先服务调度算法(FCFS)、最短作业优先调度算法(SJF)、轮转调度算法(RR)等。
这些算法基于进程的优先级、执行时间、资源需求等考虑,来决定选择哪个进程获得处理机资源。
2.内存管理算法内存管理算法决定了如何有效地分配和回收内存资源。
常见的内存管理算法包括固定分区算法、动态分区算法和虚拟内存管理算法等。
这些算法根据进程的内存需求和空闲内存空间的情况,来决定如何分配和回收内存资源。
3.页面置换算法页面置换算法是一种在虚拟内存管理中使用的算法,用于将进程的页面从磁盘中换入内存,并选择合适的页面进行置换。
常见的页面置换算法有最佳置换算法(OPT)、先进先出置换算法(FIFO)、最近最少使用置换算法(LRU)等。
这些算法根据页面的访问情况和页面的驻留时间来决定选择哪个页面进行置换。
4.文件管理算法文件管理算法决定了如何组织和管理文件系统中的文件。
常见的文件管理算法有顺序文件组织算法、索引文件组织算法、哈希文件组织算法等。
这些算法根据文件的访问特点和性能需求,来决定如何组织和管理文件数据。
5.磁盘调度算法磁盘调度算法决定了操作系统如何调度磁盘上的IO请求,以提高磁盘的访问效率。
常见的磁盘调度算法有先来先服务调度算法(FCFS)、最短寻半径优先调度算法(SSTF)、扫描调度算法(SCAN)等。
这些算法根据磁盘的寻道距离和IO请求的到达时间等因素,来决定选择哪个IO请求进行调度。
6.死锁检测和解决算法死锁是指多个进程因为互相等待而无法继续执行的情况。
操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。
其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。
在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。
2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。
3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。
实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。
因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。
同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。
操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言操作系统是计算机系统中最核心的软件之一,它负责管理和调度计算机的资源,提供良好的用户体验。
在操作系统中,进程调度是其中一个重要的功能,它决定了进程的执行顺序和时间片分配,对于提高计算机系统的效率和响应能力至关重要。
本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念进程调度是操作系统中的一个重要组成部分,它负责决定哪个进程可以使用CPU,并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下,进程调度需要考虑多个进程之间的竞争和协作,以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度(FCFS)先来先服务调度算法是最简单的进程调度算法之一,它按照进程到达的顺序进行调度,即先到达的进程先执行。
这种算法的优点是公平性高,缺点是无法适应长作业和短作业混合的情况,容易产生"饥饿"现象。
2. 最短作业优先调度(SJF)最短作业优先调度算法是根据进程的执行时间来进行调度的,即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间,缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度(RR)时间片轮转调度算法是一种抢占式调度算法,它将CPU的执行时间划分为固定大小的时间片,并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后,它将被挂起,等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间,缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度(Priority Scheduling)优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度,缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中,我们使用了不同的进程调度算法,并对其进行了性能测试。
(完整word版)进程调度存储器管理银行家算法磁盘调度操作系统实验报告资料(word文档良心出品)

江苏科技大学操作系统实验报告(2015/2016学年第2学期)课程名称:操作系统指导教师:实验地点:西校区图书馆计算机机房学生姓名:学生学号:院系:计算机科学与工程学院专业:计算机科学与技术2016年5 月15 日实验一进程调度一、实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。
二、实验内容1.优先权法、轮转法简化假设1)进程为计算型的(无I/O)2)进程状态:ready、running、finish3)进程需要的CPU时间以时间片为单位确定2.算法描述1)优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。
2)轮转法三、实验要求1.产生的各种随机数的取值范围加以限制,如所需的CPU时间限制在1~20之间。
2.进程数n不要太大通常取4~8个3.使用动态数据结构4.独立编程5.二种调度算法四、实验过程//秦魏编写要拷贝使用无(fa)偿(ge)使(hong)用(bao)#ifndef Maxpriority_H#define Maxpriority_H#define arrayLenth 100;template<class T>class Maxheap{T *heap;int heapsize, lenth;public:Maxheap(int n){ lenth = 0;heapsize = n;heap = new T[heapsize];}Maxheap(T *maxheap, int n){if (n < 0)return;lenth = n;heapsize = n;heap = new T[heapsize];int i;for (i = 0; i < heapsize; i++)heap[i] = maxheap[i];create();}~Maxheap(){ delete[]heap; }int Parent(int i){return (i+1)/ 2-1;//注意地址的转换,最后还要减去1}int Lchild(int i){ return 2 * (i+1)-1; }int Rchild(int i){ return 2 * i + 2; }void Maxheapify(int i){int l, r;l = Lchild(i);r = Rchild(i);int largest;if (l < lenth&&heap[l].priority>heap[i].priority)//第一个条件,起到一个判断是否为叶子节点的作用largest = l;else largest = i;if (r <lenth&&heap[r].priority > heap[largest].priority)largest = r;if (largest != i) swap(heap[largest], heap[i]),Maxheapify(largest);}void swap(T &a, T &b){T store;store = a;a = b;b = store;}void create(){int i;for (i = lenth / 2-1; i >= 0; i--)Maxheapify(i);}void insert(T &element){lenth++;heap[lenth-1] = element;create();}void print(){int i;for (i = 0; i < lenth; i++)cout << heap[i].priority;}int heapextractmax(){if (lenth==0) return -1;T max;max = heap[0];heap[0] = heap[lenth - 1];lenth--;Maxheapify(0);return max.task;}int empty(){ if (lenth == 0) return 1;return 0;}};#endif#ifndef Quene_H#define Quene_H#define size 1000//队列先进先出,从队尾进,从对头出template<class T>class Cirquene{T a[size];int front,rear;public:Cirquene(){front=rear=size-1;}~Cirquene(){ }void Enquene(T &e){if((rear+1)%size==front) throw"上溢";rear=(rear+1)%size;a[rear]=e;}int Dequene(){if(rear==size) throw"下溢";if (Empty()) return -1;else{front = (front + 1) % size;return a[front].task;}}int Getfront(){return front;}int Empty(){if (front == rear) return 1;return 0;}void print(){datatype e = a[rear];int i;do{i = e.pre;cout << e.x << '\t' << e.y << endl;e = a[i];} while (i!=-1);//注意这边i的取值}};#endif#include<iostream>#include "Maxheap.h"#include"Quene.h"using namespace std;enum State{//enum变量后用逗号隔开!!!!!ready,exe,blo,fin,};//任务状态struct PCB//优先级队列通过堆排序实现{int task;//任务int priority;//优先级int AexeTime;//已经运行时间int SexeTime;//剩余运行时间int blocktime;//阻塞时间State state;//任务状态};int checkstate(PCB *program){ int i;//检查是否所有程序都已运行结束for (i = 0; i < 5; i++)if (program[i].state != fin) return 0;return 1;}void PSA(Maxheap<PCB> Test,PCB *program,int Arrtime[],int quantum ){//1个单位时间检查一次用堆排序实现优先级队列int m = 0, alltime = 0,num=0,k,time=0;while (!checkstate(program)){if (num < 5)for (m = 0; m < 5; m++)if (alltime == Arrtime[m]) Test.insert(program[m]),cout << "进程" << m + 1 << "到达 " << endl,num++, program[m].state = ready;//到达到达时间进入就绪队列if(alltime==0||k==-1) k= Test.heapextractmax();//在无进程运行后序有进程进入时应该抛出!!!!alltime++, time++;if (k == -1) cout << "从" << alltime -1<< "到" << alltime << "单位时间无进程运行" << endl;if (k != -1){program[k].state = exe,program[k].AexeTime++,program[k].SexeTime--,program[k].priority-=3,//优先级减3cout << "从" << alltime-1 << "到" << alltime << "单位时间" << k + 1 << "进程运行" << endl;if (program[k].SexeTime == 0) program[k].state = fin, time = 0,cout << "进程" <<k + 1 << "在" << alltime<< "单位时间运行结束" << endl,k = Test.heapextractmax();if (program[k].SexeTime != 0&&time==quantum) program[k].state = ready,Test.insert(program[k]), time = 0, k = Test.heapextractmax();}}}void RR(PCB *program, int i, int Arrtime[], int quantum){//优先级列表用队列实现int m, k, num=0, alltime=0,time=0;Cirquene<PCB> priority;while (!checkstate(program)){if(alltime==0) for (m = 0; m < i; m++)if (alltime == Arrtime[m]) priority.Enquene(program[m]),cout << "进程" << m + 1 << "到达 " << endl,num++, program[m].state = ready;//找到第一个到达的进程if(alltime==0||k==-1) k = priority.Dequene();//开始调度alltime++, time++;if (alltime != 0 && num<i) for (m = 0; m < i; m++)//先判断下一个时刻是否有进程到达原因是在一个进程运行结束同时另外一个进程到达到达的那个进程应该首先进入就绪队列if (alltime == Arrtime[m]) priority.Enquene(program[m]),cout << "进程" << m + 1 << "到达 " << endl,num++, program[m].state = ready;if (k == -1) cout << "从" << alltime-1<< "到" << alltime << "单位时间无进程运行" << endl;else{program[k].state = exe,program[k].AexeTime++,program[k].SexeTime--;cout << "从" << alltime -1<< "到" << alltime << "单位时间" << k + 1 << "进程运行" << endl;if (program[k].SexeTime == 0)program[k].state = fin,time = 0,cout << "进程" << k + 1 << "在" << alltime << "单位时间运行结束" << endl, k = priority.Dequene();if (time == quantum)if (program[k].SexeTime != 0) program[k].state = ready,priority.Enquene(program[k]),k = priority.Dequene(),time=0;}}}int main(){int task[5] = { 0,1,2,3,4 };//任务int ExeTime[5] = { 5, 5, 3, 1, 3};//运行时间int priority[5] = {2,5,2,4,3 };//优先级int ArrTime[5] = { 4, 3, 2,0,4 };//到达时间PCB program[5],program2[5];int i;for (i = 0; i<5; i++){program[i].task = task[i],program2[i].task = task[i] ;program[i].priority = priority[i],program2[i].priority = priority[i];program[i].AexeTime = 0, program2[i].AexeTime = 0;program[i].SexeTime = ExeTime[i], program2[i].SexeTime = ExeTime[i];program[i].blocktime = 0, program2[i].blocktime = 0;program[i].state = blo,program2[i].state = blo ;}//初始化pcb*/Maxheap<PCB> Test(5);int quantum=2;//时间片为2cout << "优先权法:" << endl;PSA(Test, program, ArrTime,quantum);cout << "轮转调度法:" << endl;RR(program2, 5, ArrTime, quantum);system("pause");return 0;}五、实验分析与实现1.轮转法调度,具有先进先出的特点,所以利用队列实现2.优先级调度算法具有优先级动态变化的特点,每一次进行优先级要排序。
操作系统实验报告—磁盘调度算法

操作系统实验报告—磁盘调度算法操作系统实验报告实验3磁盘调度算法报告日期:20XX-6-17姓名:学号:班级:任课教师:实验3磁盘调度算法一、实验内容模拟电梯调度算法,实现对磁盘的驱动调度。
二、实验目的磁盘是一种高速、大量旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器,负担着繁重的输入输出任务,在多道程序设计系统中,往往同时会有若干个要求访问磁盘的输入输出请示等待处理。
系统可采用一种策略,尽可能按最佳次序执行要求访问磁盘的诸输入输出请求,这就叫驱动调度,使用的算法称驱动调度算法。
驱动调度能降低为若干个输入输出请求服务所须的总时间,从而提高系统效率。
本实验要求学生模拟设计一个驱动调度程序,观察驱动调度程序的动态运行过程。
三、实验原理模拟电梯调度算法,对磁盘调度。
磁盘是要供多个进程共享的存储设备,但一个磁盘每个时刻只能为一个进程服务。
当有进程在访问某个磁盘时,其他想访问该磁盘的进程必须等待,直到磁盘一次工作结束。
当有多个进程提出输入输出请求处于等待状态,可用电梯调度算法从若干个等待访问者中选择一个进程,让它访问磁盘。
当存取臂仅需移到一个方向最远的所请求的柱面后,如果没有访问请求了,存取臂就改变方向。
假设磁盘有200个磁道,用C语言随机函数随机生成一个磁道请求序列放入模拟的磁盘请求队列中,假定当前磁头在100号磁道上,并向磁道号增加的方向上移动。
请给出按电梯调度算法进行磁盘调度时满足请求的次序,并计算出它们的平均寻道长度。
四、实验过程1.画出算法流程图。
2.源代码#include #include #include int *Init(intarr) {int i = 0;srand((unsignedint)time(0)); for (i = 0; i = num) {a[j+1] = arr[i]; j++; } else {b[k+1] = arr[i]; k++; } }printf(\访问序列:\\n\); for (i = 1; i 0; i--) { printf(\, b[i]); }sum = ((a[j]-100)*2+(100- b[1]))/15;printf(\平均寻道长度:%d\, sum); }int main {int arr[15] = { 0 }; int *ret=Init(arr); two_part(ret); getchar ; return 0;}4运行结果:五、实验小结通过本次实验,我对scan算法更加深入理解,用C语言模拟电梯调度算法,实现对磁盘的驱动调度,这个相比前两个实验实现起来相对简单,理解了算法实现起来尤为简单,程序敲出来之后没有错误,可直接运行,结果验证也无误。
操作系统课程设计银行家算法算法的模拟实现

枣庄学院信息科学与工程学院课程设计任务书题目银行家算法算法的模拟实现学生1: __________________________________________________学生2: __________________________________________________专业: ________________ 计算机应用技术 __________________课程: ________________ 操作系统 _________________________指导教师:__________ 职称: ________________完成时间:2014年12月----2015年1月枣庄学院信息科学与工程学院制2014年12月10日课程设计任务书及成绩评定课程设计的任务和具体要求操作系统课程设计是操作系统课程学习的延续。
主要目的是配合操作系统课程的学习,对Linux操作系统有一定掌握,能够熟练操作,并能在Linux系统下模拟实现操作系统的功能,有助于对操作系统的理解。
本次课程设计共分两部分,其中第一部分为操作题,同学们需要对Linux的基本的命令(常用的几个,讲课的时候强调的),这部分,任课教师实时检查,让学生用命令完成一定的功能,然后,根据完成情况评定成绩。
第二部分为编程设计题,每组同学必须独立完成,可以选择进程调度,也可以根据自己的兴趣,选择模拟实现磁盘调度、银行家算法、页面置换算法等。
指导教师签字:_________________ 日期: ______________________________指导教师评语成绩:______________ 指导教师签字: _______________________ 日期: _____________目录1引言1.1linux 及其特点 .................. ... .. (4)1.1.1Linux 的概述 (4)1.2Linux 的结构 (4)1.3Linux 的版本............. ... . (5)2常用命令基本介绍2.1Linux目录命令 (5)2.2Linux文件命令 ...... (5)3银行家算法3.1实验目的......... (6)3.2实验内容.......................... ................................................................ .. (6)3.3实验方法........................................................................................... .. (7)3.3.1算法流程图............................................................................ ....... .. (7)3.3.2算法数据结构 (7)3.4实验代码........................................................................................................................................ …3.5运行示例 (17)4实验小结................................................................................................................................... .. (17)实用程序:的Linux标准系统都有一套称为应用程序的程序集,它们是专门的程序,包括文本编辑器,编程语言,X Win dow,办公套件,In ternet工具,数据库等1.3Lin ux 的版本:内核版本:根据约定,次版本号为奇数时,表示该版本加入新内容,但不一定很稳定,相当于测试版;次版本号为偶数时,表示这是一个可以使用的稳定版本。
《操作系统》上机实验报告—进程调度

《操作系统》上机实验报告实验算法主体内容及#include<stdio.h>#include<dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5 // 共有5 个进程#define P_TIME 50 //作为优先数计算时所用的值enum state{ready,execute,block, finish};//进程的状态,使用枚举struct pcb{char name[4]; // 进程名称int priority; //进程优先级int cputime; //已经占有cpu运行的时间int needtime; //还需要运行的时间int count; //在时间片轮转法中使用的int round; //在时间片轮转法中使用的state process; //进程的状态pcb *next; //指向下一个进程的pcb};pcb *get_process() //通过输入各进程的值来建立pcb队列,并返回其首元素的指针{pcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"<<endl;while(i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name; cin>>q->needtime; q->cputime=O;q->priority=P_TIME-q->needtime;q->round=0; q->count=0;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{ t->next=q; t=q; } i++;}return p;}void display(pcb *p) //显示本轮运行后的进程各状态情况{coutvv" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"优先级"vv" "vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";cout<vp_>priority;coutvv"";switch(p->process) //对枚举类型的输出方法{case ready:cout< <"就绪"<<endl;break;case execute:cout< <"执行"<<endl;break;case block:cout<<"阻塞"<<endl;break;case finish:cout<<"完成"<<endl;break;} p=p->next;}}int process_finish(pcb *q) //判断所有的进程是否运行结束{ -int b=1;while(q&&b){b=b&&q->needtime==O; q=q_>next;} return b;}void cpuexe(pcb *q) //优先级调度算法的一次执行{pcb *t;t=q;int i=0;while(q){if (q->process!=finish){q_>process=ready;if(q->needtime==0) q->process=finish;} if(i<q->priority) if(q->process!=finish){ t=q;i=q->priority;} q=q->next;}t->needtime-=1;t_>priority_=3; if(t->needtime==0)t->process=finish; t->cputime+=1;}void priority_cal() //优先级调度算法{pcb *p;P=get_process();〃取得进程队列int cpu=0;while(!process_finish(p)) //若进程并未全部结束,则还需要执行{cpu++;coutvv"运行次数:"vvcpuwendl; cpuexe(p);//一次cpu的执行display(p);//显示本次执行结果}}pcb * get_process_round()Jpcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"《endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime; q->cputime=O;q->round=0;q->count=0;q_>process=ready; q->next=NULL; if(i==0){p=q;t=q;}else{} i++; } return p;} t->next=q; t=q;void cpu_round(pcb *q){-q->count++;q->cputime+=2;q->needtime-=2;if(q->needtime<0)q->needtime=0;q->round++;q->process=execute;}pcb *get_next(pcb *k,pcb *head){ -pcb *t;t=k; do{t=t->next;}while (t && t->process==finish);if(t==NULL){} return t; t=head;while (t->next!=k && t->process==finish) {t=t->next;}void set_state(pcb *p){-while(p){if (p->needtime==O){p->process=finish;}if (p->process==execute){p_>process=ready;} p=p_>next;}}void display_round(pcb *p){ -cout«" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"时间片"vv"" vv"次数"vv""vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";coutvvp->round;coutvv"";coutvvp->count;coutvv"";switch(p->process){case ready:coutv v"就绪"vvendl;break;case execute:coutvv'执行"vvendl;break;case finish:coutvv"完成"vvendl;break;}p=p->next;}}void round_cal(){pcb *p;pcb *r;p=get_process();int cpu=0;r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);coutvv"运行次数"vvcpuvvendl;display_round(p);set_state(p);} }-void display_menu(){ -coutvv"进程调度算法操作:"vvendl;coutvv"1 优先数"vvendl;coutvv"2 时间片轮转"vvendl;coutvv"3 退出"vvendl;}void main(){display_menu();int k;printf("请选择:");scanf("%d",&k);switch(k){case 1:priority_cal();break;case 2:round_cal();break;case 3:break;}} ----------------------------------------------------------------------------------------------------------测试数据:¥间出择1A.时退选r 5642 3込簷运行结果:1优先数S却曰石石<奪--a S 亠 亡疋出尢尤扫 亡、 ^a ^T B a 抄各时 各时 进还进还称进入时|可0 3 0I! IS 运行次数 “称进入时间II态成養成成忧完就完完完&0 94 2R p f c 32 3 4 3 % 扰冋运行次数心 泊称进入吋冋R5 R 5 C4 卜2佳行次数陰态成成成成成状§_f c s ^H Z B6 4 28尸尤32 3 4结果截图与分析2、时间片轮转10 0名称进入时问64 42 运行次数t k 称进入吋间A称进入时间竇鶴躺翻聶s _^->4p 者者者奁廿者_J-^□者者HiH8 数 謝还轎時 0 00 0 0次数0 口2 1 21 2 3 3216 6 42 2 1 20 Q 0D F次数3 E34 4 1 1 e s 02 0 0态成成态成衣成成些兀执完lla兀。
操作系统课程设计报告进程调度

前言操作系统(Operating System, 简称OS)是管理和控制计算机硬件与软件资源旳计算机程序, 是直接运营在“裸机”上旳最基本旳系统软件, 任何其他软件都必须在操作系统旳支持下才干运营。
操作系统是顾客和计算机旳接口, 同步也是计算机硬件和其他软件旳接口。
操作系统旳功能涉及管理计算机系统旳硬件、软件及数据资源, 控制程序运营, 改善人机界面, 为其他应用软件提供支持, 让计算机系统所有资源最大限度地发挥作用, 提供多种形式旳顾客界面, 使顾客有一种好旳工作环境, 为其他软件旳开发提供必要旳服务和相应旳接口等。
事实上, 顾客是不用接触操作系统旳, 操作系统管理着计算机硬件资源, 同步按照应用程序旳资源祈求, 分派资源, 如: 划分CPU时间, 内存空间旳开辟, 调用打印机等。
操作系统旳重要功能是资源管理, 程序控制和人机交互等。
计算机系统旳资源可分为设备资源和信息资源两大类。
设备资源指旳是构成计算机旳硬件设备, 如中央解决器, 主存储器, 磁盘存储器, 打印机, 磁带存储器, 显示屏, 键盘输入设备和鼠标等。
信息资源指旳是寄存于计算机内旳多种数据, 如系统软件和应用软件等。
操作系统位于底层硬件与顾客之间, 是两者沟通旳桥梁。
顾客可以通过操作系统旳顾客界面, 输入命令。
操作系统则对命令进行解释, 驱动硬件设备, 实现顾客规定。
本次课程设计我们将对上学期所学旳知识进行系统旳应用, 而达到巩固知识旳作用目录1问题概述 (2)2需求分析 (2)3 概要设计 (2)3.1重要功能 (2)3.2 模块功能构造 (3)3.3 软硬件环境 (3)3.4数据构造设计 (3)4 具体设计 (4)4.1“先来先服务(FCFS)调度算法” (4)4.2“短进程调度算法(SPF)” (7)4.3“高响应比优先调度算法” (10)4.4“优先级调度(非抢占式)算法” (13)5 系统测试及调试 (15)5.1测试 (15)5.2调试过程中遇到旳问题 (16)6 心得体会 (17)7 参照文献 (18)8 附录 (19)1问题概述编写一种进程调度程序, 容许多种进程并发执行。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验三 进程调度一、 实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。
二、 实验要求1. 设计进程调度算法,进程数不定2. 包含几种调度算法,并加以实现3. 输出进程的调度过程——进程的状态、链表等。
三、 参考例1. 题目——优先权法、轮转法简化假设1) 进程为计算型的(无I/O )2) 进程状态:ready 、running 、finish3) 进程需要的CPU 时间以时间片为单位确定2. 算法描述1) 优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。
2) 轮转法四、 实验流程图 开始 键盘输入进程数n ,和调度方法的选择 优先权法? 轮转法产生n 个进程,对每个进程产生一个PCB ,并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小,把n 个进程拉成一个就绪队列撤销进程就绪队列为空?结束 N YY注意:1. 产生的各种随机数的取值范围加以限制,如所需的CPU 时间限制在1~20之间。
2. 进程数n 不要太大通常取4~8个3. 使用动态数据结构4. 独立编程5. 至少三种调度算法6. 若有可能请在图形方式下,将PCB 的调度用图形成动画显示。
五.实验过程:(1)输入:进程流文件(1.txt ),其中存储的是一系列要执行的进程, 每个作业包括四个数据项:进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1进程5 3 8 7输出: 进程执行流等待时间,平均等待时间本程序包括:FIFO 算法,优先数调度算法,时间片轮转调度算法产生n需的时间片数,已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0? 撤销该进程就绪队列为空吗? =轮转时间片数?NY YY 结束 N(2)程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time; }pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status, &pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].status<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0; pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){ pcbs[j].wait_time+=pcbs[i].time; }}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){ p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<<e ndl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ number++; j=i; }}if(number==1){ queue[total]=j; total++; pcbs[j].finished=1; }if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){ total--; }cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度 ********************/ ";cout<<endl<<endl; }//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){ FIFO();init();privilege();init();timer();}}(3)运行结果:输入进程流文件名1.txt即可得出以下输出结果:实验二银行家算法一、实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。