当前位置：文档之家› 操作系统实验处理机调度C语言实现

操作系统实验处理机调度C语言实现

#include

#define N 20

#define MAX 100

typedef struct PCB //pcb进程控制块定义

{

int num[N]; //进程序号

char name[10]; //进程名

char state; //进程状态

int tijiaotime; //进程到达时间

int runtime; //进程开始时间

int finishtime; //进程结束时间

int needtime; //服务时间

int pro;//进程优先级

struct PCB *next; //链接指针指向下个作业的

}pcb;

struct PCB *head_input;

struct PCB *head_run;

struct PCB *head_run_pre;

unsigned long current; //记录系统当前时间的变量

int time=10000,n; //计时器

pcb *head=NULL,*p,*q;

void getInfo() //创建进程

{

int num;

printf("\n请输入要建立的进程个数:");

scanf("%d",&n);

for(num=0;num

{

p=(pcb *)malloc(sizeof(pcb));

if(head==NULL) {head=p;q=p;}

printf("依次输入：\n进程号进程名到达时间服务时间\n");

scanf("%s\t%s\t%d\t%d",&p->num,&p->name,&p->tijiaotime,&p->needtime); if(p->tijiaotime < time) time=p->tijiaotime;

q->next=p;

p->runtime=0;

p->finishtime=0;

p->next=NULL;

p->state='W';

q=p;

}

// *********************1.先来先服务调度算法*******************************

void run_fcfo(pcb *p1)//定义先来先到服务的算法

{

time = p1->tijiaotime > time? p1->tijiaotime:time;

p1->runtime=time;

printf("\n现在时间是%d,开始运行进程%s\n",time,p1->name);

time+=p1->needtime;

p1->state='F';

p1->finishtime=time;

printf("进程名开始时间所需时间结束时间\n");

printf("%s %d %d %d ",p1->name,p1->runtime,p1->needtime,p1->finishtime);

}

void fcfo()//定义运行进程函数

{

int i,j,t;

for(j=0;j

{

p=head;

t=10000;

for(i=0;i

{

if(p->tijiaotimestate=='W')

{

t=p->tijiaotime;

q=p; //标记当前未完成的进程

}

p=p->next;

}

run_fcfo(q);

}

// ************************2.优先级调度服务算法************************************

int readydata()

{ //建立就绪队列

if(head_input->next==NULL)

{

return 0;

}

struct PCB *p1=head_input->next,*pmax,*p2;

int maxpro=0xffff;

pmax=p1;

p2=head_input;

while(p1!=NULL)

{

if(p1->pro

{

maxpro=p1->pro;

head_run_pre=p2;

pmax=p1;

}

p2=p1;

p1=p1->next;

}

head_run=pmax;

head_run_pre->next=head_run->next;

return 1;

}

void runprocess() //运行进程函数

{

head_run->runtime-=10;

head_run->pro++;

struct PCB *p1,*p2;

printf("时间片的大小%d",current);

current+=10;

printf(" %s 开始\n",head_run->name);

printf("时间片的大小%d",current);

printf(" %s 结束\n",head_run->name);

if(head_run->runtime<=0)

{//判断进程是否运行结束

}

else

{

p1=head_input;

p2=head_input->next;

p1->next=head_run;

head_run->next=p2;

}

int readyprocess()

{

while(1)

{

if(readydata()==0)

return 0;

else runprocess();

}

void Init()

{

head_input=new PCB;

head_input->next=NULL;

current=0;

int numpro;

printf("请重新输入要建立的进程个数:");

scanf("%d",&numpro);

printf("请依次输入进程名运行时间优先级\n");

for(int i=0;i

{

struct PCB *p1=new PCB;

scanf("%s",p1->name);

scanf("%d",&p1->runtime);

scanf("%d",&p1->pro);

p1->state='C';

p1->next=NULL;

struct PCB *p2=head_input->next;

head_input->next=p1;

p1->next=p2;

}

// ************************3.时间片轮转调度服务算法************************************

void shijianpian()

{ int b,i,X,t,k;

int a[MAX];//存放进程的剩余时间

int cnt[MAX];//存放进程调度次数

printf("请输入进程数:");

scanf("%d",&X);

printf("\n请输入时间片t大小:");

scanf("%d",&t);

printf("\n请依次输入各个进程的服务时间");

for(i=0;i

{

scanf("%d",&a[i]);

cnt[i]=0;

}

printf("被调度进程\t进程调度次数\t本次运行时间结果\t剩余时间\n");

k=1;

while(k)

{

for(i=0;i

{

if(a[i]!=0)

if(a[i]>=t)

{

a[i]-=t;

b+=t;

cnt[i]=cnt[i]+1;

printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);

}

else

{

b=b+a[i];

cnt[i]=cnt[i]+1;

a[i]=0;

printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);

}

else continue;

}

for(i=0;i

if(a[i]!=0)

{ k=1;break;}

else continue;

if(i>=X)

k=0;

}

void main()

{

printf(" *******************************"); printf("\n 1. 按先来先到服务调度的算法模拟\n"); printf(" *******************************"); getInfo();

fcfo();

printf("\n *******************************"); printf("\n 2. 按优先级调度的算法模拟\n");

printf("\n *******************************\n");

Init();

readyprocess();

printf("\n *******************************"); printf("\n 3. 按时间片轮转调度的算法模拟\n"); printf(" *******************************\n"); shijianpian();

printf(" \n");

}

实验二--单处理器系统的进程调度

实验二单处理器系统的进程调度（附实验报告） 1．实验目的加深对进程概念的理解，明确进程和程序的区别；深入了解系统如何组织进程、创建进程；进一步认识如何实现处理器调度。 2．实验预备知识进程的概念；进程的组织方式；进程的创建；进程的调度。 3．实验内容

编写程序完成单处理机系统中的进程调度，要求采用时间片轮转调度算法。实验具体包括：首先确定进程控制块的内容，进程控制块的组成方式；然后完成进程创建原语和进程调度原语；最后编写主函数对所作工作进程测试。 4．提示与讲解这个实验主要要考虑三个问题：如何组织进程、如何创建进程和如何实现处理器调度。考虑如何组织进程，首先就要设定进程控制块的内容。进程控制块PCB 记录各个进程执行时的情况。不同的操作系统，进程控制块记录的信息内容不一样。操作系统功能越强，软件也越庞大，进程控制块记录的内容也就越多。这里的实验只使用了必不可少的信息。一般操作系统中，无论进程控制块中信息量多少，信息都可以大致分为以下四类： ①标识信息每个进程都要有一个惟一的标识符，用来标识进程的存在和区别于其他进程。这个标识符是必不可少的，可以用符号或编号实现，它必须是操作系统分配的。在后面给出的参考程序中，采用编号方式，也就是为每个进程依次分配一个不相同的正整数。 ②说明信息

用于记录进程的基本情况，例如进程的状态、等待原因、进程程序存放位置、进程数据存放位置等等。实验中，因为进程没有数据和程序，仅使用进程控制块模拟进程，所以这部分内容仅包括进程状态。 ③现场信息现场信息记录各个寄存器的内容。当进程由于某种原因让出处理器时，需要将现场信息记录在进程控制块中，当进行进程调度时，从选中进程的进程控制块中读取现场信息进行现场恢复。现场信息就是处理器的相关寄存器内容，包括通用寄存器、程序计数器和程序状态字寄存器等。在实验中，可选取几个寄存器作为代表。用大写的全局变量AX、BX、CX、DX模拟通用寄存器、大写的全局变量PC模拟程序计数器、大写的全局变量PSW模拟程序状态字寄存器。 ④管理信息管理信息记录进程管理和调度的信息。例如进程优先数、进程队列指针等。实验中，仅包括队列指针。因此可将进程控制块结构定义如下： struct pcb {int name; int status;

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

一、实验目的通过对进程调度算法的设计，深入理解进程调度的原理。进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。进程调度分配处理机，是控制协调进程对CPU的竞争，即按一定的调度算法从就绪队列中选中一个进程，把CPU的使用权交给被选中的进程。进程通过定义一个进程控制块的数据结构（PCB）来表示；每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性；在RR中，以1为时间片单位；运行时，输入若干个进程序列，按照时间片输出其执行序列。二、实验环境 VC++6.0 三、实验内容实现短进程优先调度算法（SPF）和时间片轮转调度算法（RR） [提示]： (1) 先来先服务（FCFS）调度算法原理：每次调度是从就绪队列中，选择一个最先进入就绪队列的进程，把处理器分配给该进程，使之得到执行。该进程一旦占有了处理器，它就一直运行下去，直到该进程完成或因发生事件而阻塞，才退出处理器。将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理，是一种最普遍和最简单的方法。它优先考虑在系统中等待时间最长的作业，而不管要求运行时间的长短。按照就绪进程进入就绪队列的先后次序进行调度，简单易实现，利于长进程，CPU繁忙型作业，不利于短进程，排队时间相对过长。 (2) 时间片轮转调度算法RR

原理：时间片轮转法主要用于进程调度。采用此算法的系统，其程序就绪队列往往按进程到达的时间来排序。进程调度按一定时间片（q）轮番运行各个进程. 进程按到达时间在就绪队列中排队，调度程序每次把CPU分配给就绪队列首进程使用一个时间片，运行完一个时间片释放CPU，排到就绪队列末尾参加下一轮调度，CPU分配给就绪队列的首进程。固定时间片轮转法： 1 所有就绪进程按 FCFS 规则排队。 2 处理机总是分配给就绪队列的队首进程。 3 如果运行的进程用完时间片，则系统就把该进程送回就绪队列的队尾，重新排队。 4 因等待某事件而阻塞的进程送到阻塞队列。 5 系统把被唤醒的进程送到就绪队列的队尾。可变时间片轮转法： 1 进程状态的转换方法同固定时间片轮转法。 2 响应时间固定，时间片的长短依据进程数量的多少由T = N × （ q + t ）给出的关系调整。 3 根据进程优先级的高低进一步调整时间片，优先级越高的进程，分配的时间片越长。多就绪队列轮转法： (3) 算法类型 (4)模拟程序可由两部分组成，先来先服务（FCFS）调度算法，时间片轮转。流程图如下:

操作系统实验报告-作业调度

作业调度一、实验目的 1、对作业调度的相关内容作进一步的理解。 2、明白作业调度的主要任务。 3、通过编程掌握作业调度的主要算法。二、实验内容及要求 1、对于给定的一组作业, 给出其到达时间和运行时间，例如下表所示： 2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。 3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。

测试数据 workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8} 运行结果先来先服务算法调度顺序:['A', 'B', 'C', 'D', 'E', 'F'] 周转时间: 带权周转时间:

短作业优先算法调度顺序:['A', 'D', 'F', 'C', 'E', 'B'] 周转时间: 带权周转时间:1. 响应比高者优先算法调度顺序:['A', 'D', 'F', 'E', 'C', 'B'] 周转时间: 带权周转时间: 五、代码 #encoding=gbk workA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8} list1=[workB,workA,workC,workD,workE,workF] list2=[workB,workA,workC,workD,workE,workF] list3=[workB,workA,workC,workD,workE,workF] #先来先服务算法 def fcfs(list): resultlist = sorted(list, key=lambda s: s['到达时间']) return resultlist #短作业优先算法 def sjf(list): time=0 resultlist=[] for work1 in list: time+=work1['服务时间'] listdd=[] ctime=0 for i in range(time): for work2 in list: if work2['到达时间']<=ctime: (work2) if len(listdd)!=0: li = sorted(listdd, key=lambda s: s['服务时间']) (li[0]) (li[0]) ctime+=li[0]['服务时间'] listdd=[]

操作系统原理实验-系统内存使用统计5

上海电力学院计算机操作系统原理实验报告题目：动态链接库的建立与调用院系：计算机科学与技术学院专业年级：信息安全2010级学生姓名：李鑫学号：20103277 同组姓名：无 2012年11 月28 日上海电力学院

实验报告课程名称计算机操作系统原理实验项目线程的同步姓名李鑫学号20103277 班级2010251班专业信息安全同组人姓名无指导教师姓名徐曼实验日期2012/11/28 实验目的和要求： (l)了解Windows内存管理机制，理解页式存储管理技术。 (2)熟悉Windows内存管理基本数据结构。 (3)掌握Windows内存管理基本API的使用。实验原理与内容使用Windows系统提供的函数和数据结构显示系统存储空间的使用情况，当内存和虚拟存储空间变化时，观察系统显示变化情况。实验平台与要求能正确使用系统函数GlobalMemoryStatus()和数据结构MEMORYSTATUS了解系统内存和虚拟空间使用情况，会使用VirtualAlloc()函数和VirtualFree()函数分配和释放虚拟存储空间。操作系统：Windows 2000或Windows XP 实验平台：Visual Studio C++ 6.0 实验步骤与记录 1、启动安装好的Visual C++ 6.0。 2、选择File->New，新建Win32 Console Application程序, 由于内存分配、释放及系统存储空间使用情况均是Microsoft Windows操作系统的系统调用，因此选择An application that support MFC。单击确定按钮，完成本次创建。 3、创建一个支持MFC的工程，单击完成。

实验一处理器调度实验报告

处理器调度一、实验内容选择一个调度算法，实现处理器调度。二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下处理器调度，帮助学生加深了解处理器调度的工作。三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示：（1）假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。进程控制块的格式为：其中，进程名----作为进程的标识，假设五个进程的进程名分别是R, P2, P3， P4，R。指针—按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块

首地址，最后一个进程中的指针为“ 0”。要求运行时间-- 假设进程需要运行的单位时间数。优先数-赋予进程的优先数，调度时总是选取优先数大的进程先执行。状态-可假设有两种状态，“就绪”状态和“结束“状态，五个进程的初始状态都为 “就绪“状态，用“ R”表示，当一个进程运行结束后，它的状态变为“结束”，用“ E”表示。（2）在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数” 和“要求运行时间”。（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列，用一单元指出队首进程，用指针指出队列的连接情况。例：队首标志（4）处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“ 1”。由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数－ 1 要求运行时间－1 来模拟进程的一次运行提醒注意的是：在实际的系统中，当一个进程被选中运

操作系统实验报告(进程调度算法)

实验1 进程调度算法一、实验内容按优先数调度算法实现处理器调度。二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。三、实验原理设计一个按优先数调度算法实现处理器调度的程序。 (1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：进程名指针要求运行时间优先数

状态其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。要求运行时间——假设进程需要运行的单位时间数。优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。状态——可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。 (2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。 (3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。例：队首标志 K2

1P1 K 2 P2 K 3 P3 K 4 P4 K 5 P5 0 K4K5K3K1 2 3 1 2 4 1 5 3 4 2 R R R R R PC B1 PC B2 PC B3 PC B4 PC B5 (4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数-1 要求运行时间-1 来模拟进程的一次运行。提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。

操作系统作业调度实验报告

实验二作业调度一.实验题目 1、编写并调试一个单道处理系统的作业等待模拟程序。作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）的调度算法。（1）先来先服务算法：按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。（2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行时间最短的作业。二.实验目的：本实验要求用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解三.实验过程 <一>单道处理系统作业调度 1)单道处理程序作业调度实验的源程序: zuoye.c 执行程序: zuoye.exe 2)实验分析： 1、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU 时限等因素。 2、每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待 W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。 3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间。 3)流程图:

代替二.最短作业优先算法代替三.高响应比算法图一.先来先服务流程图 4)源程序: #include #include #include #define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0 int n; float T1=0,T2=0; int times=0; struct jcb //作业控制块 { char name[10]; //作业名 int reachtime; //作业到达时间

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

设计性实验报告一、实验目的 1.在Linux下用C语言编程模拟优先级进程调度算法和时间片轮转进程调度算法。 2.为了清楚地观察每个进程的调度过程，每次调度程序应将各个进程的情况显示出来。二、总体设计（设计原理、设计方案及流程等） 1、优先级进程调度算法采用动态优先级进程调度算法，其基本思想是每次调度总是把处理机分配给优先级最高的进程，同时在运行过程中进程的优先级随着执行或等待的时间而降低或增加。在该实验中每个进程用一个进程控制块（ PCB）表示。进程控制块包含如下信息：进程号，进程名、优先数、需要运行时间、已用CPU时间、进程状态。进程号，名字，优先数，运行的时间，事先人为地指定。每个进程的状态可以是就绪，执行，阻塞或完成4种状态之一。就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。就绪队列中的进程在等待一个时间片后，优先级增1。如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时将进程的优先级减1，然后把它插入就绪队列等待CPU。 2、时间片轮转调度算法采用简单时间片轮转调度算法，其基本思想是：所有就绪进程按 FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。如果运行进程用完它的时间片后还未完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。直至所有的进程运行完毕。三、实验步骤（包括主要步骤、代码分析等） 1.打开linux虚拟机，用vim编辑器打开代码进行修改和调整。用gcc编译器进行编译编译运行首先运行优先级算法，如图所示：

操作系统实验报告-作业调度实验

作业调度实验一．实验目的及要求：用高级语言编写和调试一个或多个作业调度的模拟程序，以加深对作业调度算法的理解。二. 实验环境：操作系统：Windows XP 编译环境：Visual C++ 6.0 三．算法描述由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU时限等因素。作业调度算法：采用先来先服务（FCFS）调度算法，即按作业提交的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。各个等待的作业按照提交时刻的先后次序排队，总是首先调度等待队列中队首的作业。每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间，这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。四. 实验步骤： 1.、作业等待算法：分别采用先来先服务（FCFS），最短作业优先（SJF）调度算法。对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间。 2.程序流程图

3、程序源码结构： void main() { void fcfs(); void sjf(); ... while(1){ printf("\n\t\t/* 1、fcfs */"); printf("\n\t\t/* 2、sjf */"); printf("\n\t\t/* 0、Exit */\n"); printf("\n\n\t请选择：\t"); scanf("%d",&a); printf("\n"); switch(a){ case 1: fcfs();break; case 2: sjf();break; default: break; } if(a!=1&&a!=2) break; } }

操作系统原理实验四

实验4 进程控制 1、实验目的（1）通过对WindowsXP进行编程，来熟悉和了解系统。（2）通过分析程序，来了解进程的创建、终止。 2、实验工具（1）一台WindowsXP操作系统的计算机。（2）计算机装有Microsoft Visual Studio C++6.0专业版或企业版。 3、预备知识（3）·CreateProcess（）调用：创建一个进程。（4）·ExitProcess（）调用：终止一个进程。 4、实验编程（1）编程一利用CreateProcess()函数创建一个子进程并且装入画图程序(mspaint.exe)。阅读该程序,完成实验任务。源程序如下： # include < stdio.h > # include < windows.h > int main(VOID) ﹛STARTUPINFO si; PROCESS INFORMA TION pi; ZeroMemory(&si,sizeof(si)); Si.cb=sizeof(si); ZeroMemory(&pi,sizeof(pi)); if(!CreateProcess(NULL, “c: \ WINDOWS\system32\ mspaint.exe”, NULL, NULL, FALSE, 0, NULL, NULL, &si,&pi)) ﹛fprintf(stderr,”Creat Process Failed”); return—1; ﹜ WaitForSingleObject(pi.hProcess,INFINITE); Printf(“child Complete”); CloseHandle(pi.hProcess); CloseHandle(pi hThread); ﹜

作业调度实验报告

作业调度实验报告 Document number：NOCG-YUNOO-BUYTT-UU986-1986UT

实验二作业调度一.实验题目 1、编写并调试一个单道处理系统的作业等待模拟程序。作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。（1）先来先服务算法：按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。（2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行时间最短的作业。（3）响应比高者优先算法：是在每次调度前都要计算所有被选作业（在后备队列中）的响应比，然后选择响应比最高的作业执行。 2、编写并调度一个多道程序系统的作业调度模拟程序。作业调度算法：采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。二.实验目的：本实验要求用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解三 .实验过程 <一>单道处理系统作业调度 1)单道处理程序作业调度实验的源程序: 执行程序: 2)实验分析：

1、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU 时限等因素。 2、每个作业由一个作业控制块JCB 表示，JCB 可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W 。 3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间。 3)流程图: 二.最短作业优先算法三.高响应比算法图一.先来先服务流程图 4)源程序: #include <> #include <> #include <> #define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0 int n; float T1=0,T2=0; int times=0; struct jcb .\n",p->name); free(p); .wait...",time); if(times>1000) 代替代替

计算机操作系统进程调度实验报告材料

操作系统实验题：设计一若干并发进程的进程调度程序一、实验目的无论是批处理系统、分时系统还是实时系统，用户进程数一般都大于处理机数，这将导致用户进程互相争夺处理机。这就要求进程调度程序按一定的策略，动态地把处理及分配给处于就绪队列中的某一进程，以使之执行。进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。二、实验要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．三、实验内容进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法（将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理）。每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。四、实验算法流程调度算法的流程图如下:

操作系统实验 FCFS和短作业优先SJF调度算法模拟

. 题目先来先服务FCFS和短作业优先SJF进程调度算法姓名：学号：专业：学院：指导教师：林若宁二零一八年十一月

一、实验目的模拟单处理器系统的进程调度，分别采用短作业优先和先来先服务的进程调度算法作为进程设计算法，以加深对进程的概念及进程调度算法的理解．二、实验内容 1. 短作业优先调度算法原理短作业优先调度算法，是指对短作业或断进程优先调度的算法。它们可以分别可以用于作业调度和进程调度。短作业优先调度算法，是从后备队列中选择一个或若干个运行时间最短的作业，将它们调入内存运行。短进程优先调度算法，是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 2. 先来先服务调度算法原理先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。三、程序设计 1.概要设计程序包括主函数、FCFS算法函数、SJF算法函数、输出函数；主函数流程：输入文件中的数据—显示各进程数据—选择算法—调用相应算法的函数—输出结果 2.算法流程

SJF算法流程图：

3.详细设计（1）定义一个结构体 typedef struct PCB { char job_id[10]; //作业ID float Arr_time; //到达时刻 float Fun_time; //估计运行时间 float Wait_time; //等待时间 float Start_time; //开始时刻 float Fin_time; //完成时刻 float Tur_time; //周转时间 float WTur_time; //带权周转时间 int Order; //优先标记 }list; （2）先来先服务算法函数 void fcfs(list *p,int count) //先来先服务算法{ list temp; //临时结构体变量int i; int j;

操作系统原理实验五

实验五线程的同步 1、实验目的（1）进一步掌握Windows系统环境下线程的创建与撤销。（2）熟悉Windows系统提供的线程同步API。（3）使用Windows系统提供的线程同步API解决实际问题。 2、实验准备知识：相关API函数介绍 ①等待对象等待对象（wait functions）函数包括等待一个对象（WaitForSingleObject （））和等待多个对象（WaitForMultipleObject（））两个API函数。 1）等待一个对象 WaitForSingleObject（）用于等待一个对象。它等待的对象可以为以下对象之一。 ·Change ontification:变化通知。 ·Console input: 控制台输入。 ·Event:事件。 ·Job:作业。 ·Mutex:互斥信号量。 ·Process:进程。 ·Semaphore:计数信号量。 ·Thread:线程。 ·Waitable timer:定时器。原型： DWORD WaitForSingleObject( HANDLE hHandle, // 对象句柄 DWORD dwMilliseconds // 等待时间）；参数说明：（1）hHandle:等待对象的对象句柄。该对象句柄必须为SYNCHRONIZE访问。（2）dwMilliseconds:等待时间，单位为ms。若该值为0，函数在测试对象的状态后立即返回，若为INFINITE，函数一直等待下去，直到接收到一个信号将其唤醒，如表2-1所示。返回值：如果成功返回，其返回值说明是何种事件导致函数返回。

Static HANDLE hHandlel = NULL; DWORD dRes; dRes = WaitForSingleObject(hHandlel,10); //等待对象的句柄为hHandlel，等待时间为10ms 2）等待对个对象 WaitForMultiple（）bject（）在指定时间内等待多个对象，它等待的对象与 WaitForSingleObject（）相同。原型： DWORD WaitForMultipleObjects（ DWORD nCount， //句柄数组中的句柄数 CONST HANDLE * lpHandles， //指向对象句柄数组的指针 BOOL fWaitAll， //等待类型 DWORD dwMilliseconds //等待时间）；参数说明：（1）nCount：由指针 * lpHandles指定的句柄数组中的句柄数，最大数是MAXIMUM WAIT OBJECTS。（2）* lpHandles：指向对象句柄数组的指针。（3）fWaitAll：等待类型。若为TRUE，当由lpHandles数组指定的所有对象被唤醒时函数返回；若为FALSE，当由lpHandles数组指定的某一个对象被唤醒时函数返回，且由返回值说明是由于哪个对象引起的函数返回。（4）dwMilliseconds：等待时间，单位为ms。若该值为0，函数测试对象的状态后立即返回；若为INFINITE，函数一直等待下去，直到接收到一个信号将其唤醒。返回值：、如果成功返回，其返回值说明是何种事件导致函数返回。各参数的描述如表2-2所示。

计算机操作系统-处理机调度实验报告

中南大学实验名称：处理机调度课程名称：计算机操作系统学生姓名盛希玲学号 05 学院信息科学与工程学院专业班级电子信息工程0602 完成时间 2008年10月12日

目录一实验内容........................... 错误!未定义书签。二实验目的........................... 错误!未定义书签。三实验题目........................... 错误!未定义书签。四基本思想........................... 错误!未定义书签。五算法分析........................... 错误!未定义书签。六流程图............................. 错误!未定义书签。七算法描述........................... 错误!未定义书签。八运行输出结果....................... 错误!未定义书签。

一实验内容选择一个调度算法，实现处理机调度。二实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。本实验模拟实现处理机调度，以加深了解处理机调度的工作。三实验题目设计一个按优先权调度和时间片轮转算法实现处理机调度的程序。四基本思想先选择时间片的个数和每个时间片需要的时间，正在运行的进程每运行一秒其优先权数目加一，即其优先权减小。每个时间片运行结束后，选择进入时间片进程优先权数目最小的进程，开始下一个时间片的运行。如果有进程运行结束，则离开，再在就绪队列中选择优先权数目最小的进程进入。在运行期间，如果有新的进程来到，按优先权大小放入就绪队列中。五算法分析定义一个结构体，此包含了PCB的信息： struct PCB { char PID[5]; /*进程名*/ int needtime; /*要求运行的时间*/ int cputime; /*已运行时间*/ int priority; /*优先权(越小越高)*/ int starttime; /*进入就绪队列的时间*/ int overtime; /*运行完成的时间*/ int state; /*状态:1就绪2运行3完成*/ struct PCB *next; }; 子函数struct PCB *create(int num,int n)用来建立一个按优先级大小排列的就绪进程链表和一个按时间先后循序排列的将进入就绪进程的链表。

《操作系统原理实验》试卷A及答案

《中山大学授予学士学位工作细则》第六条考试作弊不授予学士学位计算机科学系2012第二学期《操作系统原理实验》期末考试试题(A) 任课教师：李才伟考试形式：开卷考试时间：2小时年级：11 班别：3 专业：计科姓名：________ 学号：___ _ 成绩___ _ 注意：答案一定要写在答卷中，写在本试题卷中不给分。本试卷要和答卷一起交回。一．填空题（每小题2分，共30分） 1．在我们的操作系统实验中，C与汇编语言混合编程的操作系统环境为___，其所用的虚拟机为___。2．测试用软盘映像文件的大小为___MB，使用的文件系统格式为___。 3．Intel 80386新增加的两个段寄存器分别为___和___。 4．Intel处理器实模式下的中断向量表包含___个中断向量，每个中断向量有___位。 5．Linux中挂载磁盘映像的命令为___，C语言的编译器为___。 6．将程序的入口安排在指定位置的汇编操作符为___、LD的链接选项为___。 7．ELF的英文原文是___，中文译文为___。 8．在FAT的文件条目中，普通文件和子目录的文件属性值分别为___和___。 9．在IA-32的保护模式下，分段用于___，分页用于___。 10．IA-32处理器的4个系统地址寄存器分别为___。 11．IA-32中的描述符和选择符大小分别为___位和___位。 12．TSS的主要功用为___，TSS描述符只能位于___描述符表中。 13．控制保护模式的寄存器为___，激活保护标志位于其___位。 14．IA-32的三种特权级类型分别为___、___和___。 15．在Make文件中，$@ 和$< 分别表示___和___。二．问答题（每小题5分，共30分） 1．在实模式下的进程调度中是如何实现堆栈切换的？ 2．IA-32的保护模式相比实模式的主要优点有哪些？ 3．给出IA-32保护模式下的段寄存器的内容、组成和功用。 4．给出GDT和LDT的英文原文和中文译文，它们有哪些主要功用和区别？ 5．启动分页机制的主要步骤有哪些？ 6．给出IA-32段页式保护模式下（采用4KB页面大小与两级分页方式的）逻辑地址和线性地址的构成及转换成物理地址的方法。

进程调度算法实验报告doc

进程调度算法实验报告篇一：操作系统进程调度算法模拟实验报告进程调度算法模拟专业：XXXXX 学号：XXXXX 姓名：XXX 实验日期：20XX年XX月XX日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。三、实验方法内容 1. 算法设计思路将每个进程抽象成一个控制块PCB， PCB用一个结构体描述。构建一个进程调度类。将进程调度的各种算法分装在一个类中。类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。还有一个PCB实例。主要保存正在运行的进程。类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。

主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。当程序启动时，用户可以选择不同的调度算法。然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。判断进程容器中是否有新的进程可以加入就绪队列。 2. 算法流程图主程序的框架： ();//先来先服务 ();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息 ();.m_WaitQueue.empty()||.m_ProcessQueue.empt() (); (); 进程调度过程： ; 3. 算法中用到的数据结构 struct fcfs{//先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float

操作系统实验

Linux基本操作与编程（验证性 2学时） 1、实验目的： 1）熟悉Linux操作系统的环境和使用。 2）* 了解LINUX系统的安装过程。（注：＊表示可选择） 3）掌握Linux环境下的命令操作。 2、实验内容：（1）完成LINUX系统的登录，启动终端。进行下列操作并记录结果(要求：结果以屏幕截图表示)。 1）运行pwd命令，确定你当前的工作目录。 2）利用以下命令显示当前工作目录的内容： ls –l 3）运行以下命令： ls –al 4）使用mkdir命令建立一个子目录subdir。 5）使用cd命令，将工作目录改到根目录（/）上。 6）使用ls-l命令列出/dev的内容。 7）使用不带参数的命令cd改变目录，然后用pwd命令确定你当前的工作目录是哪里？ 8）使用命令cd ../..，你将工作目录移到什么地方? （2）在LINUX下查看你的文件。 1）利用cd命令，将工作目录改到你的主目录上。 2）将工作目录改到你的子目录subdir，然后运行命令： date > file1 将当前日期和时间存放到新建文件file1中。 3）使用cat命令查看file1文件的内容。 4）利用man命令显示date命令的用法： man date 5）将date命令的用法附加到文件file1的后面：man date >> file1 6）利用cat命令显示文件file1的内容。 7）利用ls -l file1命令列出文件file1的较详细的信息。运行ls -l/bin命令显示目录的内容。 8）利用ls -l/bin|more命令行分屏显示/bin目录的内容。 9）利用cp file1 fa命令生成文件file1的副本。然后利用ls -l命令查看工作目录的内容。 10）用cd命令返回你的主目录，输入命令ls –l后，解释屏幕显示的第一列内容的含义。

操作系统原理实验2+岳青山+0907052247

《操作系统原理》实验报告实验序号：2 实验项目名称： Windows 基本进程管理 1、实验目的通过观察任务管理器，来观察各个进程的动态信息。 2、实验工具（1）一台WindowsXP操作系统的计算机。（2）计算机装有Microsoft Visual Studio C++6.0专业版或企业版。 3、预备知识 ·任务管理器，了解用户计算机上正在运行的程序和进程的相关信息。 ·Windows环境中的编程。相关内容参见本次实验参考资料部分。 4、基本实验 1）观察任务管理器步骤一：进入WindowsXP。步骤二：按Ctrl+Alt+Delete（或按Ctrl+Shift+Esc）键都可以调出任务管理器。步骤三：单击“查看”→“选择列”选项，可以看到一些选项，这里，可以查看每个进程的PID，CPU使用时间，内存的使用情况，当前的进程是系统的还是用户的，每个句柄的数量，每个进程的优先级，等等。步骤四：单击“性能”标签，在所示的“性能”选项卡中可以看到CPU的使用情况、内存的使用情况。 2）通过命令观察进程情况、步骤一：单击“开始”→“运行”选项，输入cmd“命令提示符”下。步骤二：输入tasklist。步骤三：继续输入tasklist/?来寻找帮助，里面有更详细的解释。 3）通过命令来关闭一个进程步骤一：单击“开始”→“运行”选项，输入cmd“命令提示符”下。步骤二：输入tasklist后回车执行。步骤三：继续输入taskkill/PID 208/T 5、实验编程进行一个简单的Windows的图形用户接口（GUI）编程。步骤一：进入WindowsXP。步骤二：进入Microsoft Visual Studio C++6.0。步骤三：在菜单栏中单击“文件”→“新建”→“文件”→C++Source File，选择路径（如D:\1.cpp），并命名为1.cpp。步骤四：将下面的程序源代码输入。步骤五：单击Windows系统的“开始”→“运行”选项，输入cmd。