南通大学计算机学院
操作系统课程设计报告书
设计题目处理器调度算法模拟
专业班级软嵌161
学生姓名候玉权
学号1613072015
指导教师丁红
日期2018.07.05
实验报告正文内容
1、课程设计的目的
在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下处理器调度，帮助学生加深了解处理器调度的工作。
2、课程设计的要求
用C++语言编写程序完成单处理机的进程调度
3、课程设计的环境
在机房完成，运行环境vs2017
4、问题描述
对cpu调度算法进行模拟实现，包含先来先服务，短作业优先，响应比最高优先，时间片轮转等算法。
5、算法分析
数据结构
struct ef
{
char name[10]; //进程名称
int number; //进程编号
float daodatime; //到达时间
float kaishitime; //开始运行时间
float yunxingtime; //运行时间
float jieshutime; //运行结束时间
int shengyutime; // 剩余时间
int fuwutime; //服务时间
int order; //运行次序
int run_flag; //调度标志
int priority; //优先级
struct ef *next;
}
先来先服务算法
int fcfs() //先来先服务
{
float tp = 0;
int i;
int zx;
tp = ef[0].daodatime;
for (i = 0; i { ef[i].kaishitime = tp; ef[i].jieshutime = ef[i].kaishitime + ef[i].yunxingtime; ef[i].run_flag = 1; tp = ef[i].jieshutime; zx = i; ef[zx].order = i + 1; } return 0; } 短作业优先 int sjf() //短作业优先 { float temp_time = 0; int i = 0, j; int zx, tc; float yunxingtime; yunxingtime = ef[i].yunxingtime; j = 1; while ((j { if (ef[j].yunxingtime { yunxingtime = ef[j].yunxingtime; i = j; } j++; } //查找第一个被调度的进程 //对第一个被调度的进程求相应的参数 zx = i; ef[zx].kaishitime = ef[zx].daodatime; ef[zx].jieshutime = ef[zx].kaishitime + ef[zx].yunxingtime; ef[zx].run_flag = 1; temp_time = ef[zx].jieshutime; ef[zx].order = 1; tc = 1; while (tc { for (j = 0; j { if ((ef[j].daodatime <= temp_time) && (!ef[j].run_flag)) { yunxingtime = ef[j].yunxingtime; zx = j; break; } } for (j = 0; j { if ((ef[j].daodatime <= temp_time) && (!ef[j].run_flag)) if (ef[j].yunxingtime { yunxingtime = ef[j].yunxingtime; zx= j; } } //查找下一个被调度的进程 //对找到的下一个被调度的进程求相应的参数 ef[zx].kaishitime = temp_time; ef[zx].jieshutime = ef[zx].kaishitime + ef[zx].yunxingtime; ef[zx].run_flag = 1; temp_time = ef[zx].yunxingtime; tc++; ef[zx].order = tc; }return 0; } 响应比高优先 int hrrf() //响应比高优先 { int j, zx, tc; float temp_time, respond_rate, max_respond_rate; //第一个进程被调度 ef[0].kaishitime = ef[0].daodatime; ef[0].jieshutime = ef[0].kaishitime + ef[0].yunxingtime; temp_time = ef[0].jieshutime; ef[0].run_flag = 1; ef[0].order = 1; tc = 1; //调度其他进程 while (tc { max_respond_rate = 0; for (j = 1; j { if ((ef[j].daodatime <= temp_time) && (!ef[j].run_flag)) { respond_rate = (temp_time - ef[j].daodatime) / ef[j].yunxingtime; if (respond_rate>max_respond_rate) { max_respond_rate = respond_rate; zx = j; } } } //找响应比高的进程 ef[zx].kaishitime = temp_time; ef[zx].jieshutime = ef[zx].kaishitime + ef[zx].yunxingtime; temp_time = ef[zx].jieshutime; ef[zx].run_flag = 1; tc+= 1; ef[zx].order = tc; } return 0; } 时间片轮 struct ef *input() { int N, i; // 定义队首、队尾 struct ef *head, *rear; // p是队尾指针，q是队首指针，t是执行时间 struct ef *p, *q, *t; // 初始化队首和队尾为空 head = rear = NULL; cout <<"请输入进程数目："< cin>> N; for (i = 0; i < N; i++) { // 初始化一个空间给进程 p = (struct ef *)malloc(sizeof(struct ef)); cout <<"请输入第"<< i+1 <<"个进程的名字\n"< cin >> p->name; cout <<"请输入第"<< i + 1 <<"个进程的编号:\n"<< endl; cin >>p->number; cout <<"请输入第"<< i + 1 <<"个进程的到达时间:\n"<< endl; cin >>p->daodatime; cout <<"请输入第"<< i + 1 <<"个进程的服务时间:\n"<< endl; cin >> p->fuwutime; p->shengyutime = p->fuwutime; p->next = NULL; // 当输入结束时，把p的数据放到队首，以便下一步执行 if (rear == NULL) { head = p; p->next = NULL; rear = p; } // 否则执行时间为空，队首变成q else { t = NULL; q = head; // 当q和q的到达时间小于p的到达时间时，把执行时间给q while (q && q->daodatime < p->daodatime) { t = q; q = q->next; } // 当q是队首时，则下一个队首变成p,以便每个进程都能够得到时间片 if (q == head) { p->next = head; head = p; } // 当执行时间片到达队尾时（执行完成），返回给队首p else if (t == rear) { rear->next = p; p->next = NULL; rear = p; } // 否则给队首p占用执行时间，p执行完后到q else { t->next = p; p->next = q; } } } // 返回队首 return head; } void run(struct ef *head) { struct ef *p, *t, *r; int num; // 运行过程 vector cout<<"请输入时间片："< cin>>num; // 当队首不为空时，把p给队首 while (head != NULL) { r = p = head; // 把执行时间给队首 while (p != NULL) { t = head; // p的剩余时间 = 剩余时间 - 时间片 p->shengyutime = p->shengyutime - num; p->jieshutime = p->kaishitime + p->fuwutime; string s = p->name; vec_out.push_back(s); // 当p运行完，即剩余时间小于0时，仍然把它当做0处理 if (p->shengyutime < 0) p->shengyutime = 0; cout<<"进程编号到达时间服务时间剩余时间完成时间\n"< //时间不为空时，输出当前进程的信息，并把时间片交给下一个进程 while (t != NULL) { cout <<" "<< t->name <<" "< t->daodatime <<" "<< t->fuwutime <<" "<< t->shengyutime <<" " < t = t->next; } //当队首的剩余时间为0时，先把队首改成p的下一个，然后释放内存，删除队首节点 if (p->shengyutime == 0) { if (p == head) { head = p->next; free(p); p = head; } //否则返回执行，把队尾的下一个指针变成p的下一个指针，队尾的位置移动到队首 else { r->next = p->next; p = r->next; r = p; } } //否则把队首的位置给队尾，把队首的状态显示为“就绪”状态 else { r = p; p = p->next; } } } cout<<"执行顺序：\n"< cout << vec_out[0].c_str()< for (int i = 1; i { cout << vec_out[i].c_str()< } } void yunxing() { //定义时间片的队首结构体 struct ef *head; // 队首执行的时间 head =input(); run(head); } 7、程序源代码 #include"stdafx.h" #include #include using namespace std; #define MAX 10 int c; //实际进程个数 int fcfs(); //先来先服务 int sjf(); //短作业优先 int hrrf(); //响应比高优先 int yxj(); //优先级调度 int in(); //进程参数输入 int out(); //调度结果输出 struct ef { char name[10]; //进程名称 int number; //进程编号 float daodatime; //到达时间 float kaishitime; //开始运行时间 float yunxingtime; //运行时间 float jieshutime; //运行结束时间 int shengyutime; // 剩余时间 int fuwutime; //服务时间 int order; //运行次序 int run_flag; //调度标志 int priority; //优先级 struct ef *next; }ef[MAX]; int fcfs() //先来先服务 { float tp = 0; int i; int zx; tp = ef[0].daodatime; for (i = 0; i { ef[i].kaishitime = tp; ef[i].jieshutime = ef[i].kaishitime + ef[i].yunxingtime; ef[i].run_flag = 1; tp = ef[i].jieshutime; zx = i; ef[zx].order = i + 1; } return 0; } int yxj() //优先级调度 { float temp_time = 0; int i = 0, j; int zx, tc; int max_priority; max_priority = ef[i].priority; j = 1; while ((j { if (ef[j].priority>ef[i].priority) { max_priority = ef[j].priority; i = j; } j++; } //查找第一个被调度的进程 //对第一个被调度的进程求相应的参数 zx = i; ef[zx].kaishitime = ef[zx].kaishitime; ef[zx].jieshutime = ef[zx].kaishitime + ef[zx].yunxingtime; ef[zx].run_flag = 1; temp_time = ef[zx].jieshutime; ef[zx].order = 1; tc = 1; while (tc { max_priority = 0; for (j = 0; j { if ((ef[j].daodatime <= temp_time) && (!ef[j].run_flag)) if (ef[j].priority>max_priority) { max_priority = ef[j].priority; zx = j; } } //查找下一个被调度的进程// //对找到的下一个被调度的进程求相应的参数 ef[zx].kaishitime = temp_time; ef[zx].jieshutime = ef[zx].kaishitime + ef[zx].yunxingtime; ef[zx].run_flag = 1; temp_time = ef[zx].jieshutime; tc++; ef[zx].order = tc; }return 0; } int sjf() //短作业优先 { float temp_time = 0; int i = 0, j; int zx, tc; float yunxingtime; yunxingtime = ef[i].yunxingtime; j = 1; while ((j { if (ef[j].yunxingtime { yunxingtime = ef[j].yunxingtime; i = j; } j++; } //查找第一个被调度的进程 //对第一个被调度的进程求相应的参数 zx = i; ef[zx].kaishitime = ef[zx].daodatime; ef[zx].jieshutime = ef[zx].kaishitime + ef[zx].yunxingtime; ef[zx].run_flag = 1; temp_time = ef[zx].jieshutime; ef[zx].order = 1; tc = 1; while (tc { for (j = 0; j { if ((ef[j].daodatime <= temp_time) && (!ef[j].run_flag)) { yunxingtime = ef[j].yunxingtime; zx = j; break; } } for (j = 0; j { if ((ef[j].daodatime <= temp_time) && (!ef[j].run_flag)) if (ef[j].yunxingtime { yunxingtime = ef[j].yunxingtime; zx= j; } } //查找下一个被调度的进程 //对找到的下一个被调度的进程求相应的参数 ef[zx].kaishitime = temp_time; ef[zx].jieshutime = ef[zx].kaishitime + ef[zx].yunxingtime; ef[zx].run_flag = 1; temp_time = ef[zx].yunxingtime; tc++; ef[zx].order = tc; }return 0; } int hrrf() //响应比高优先 { int j, zx, tc; float temp_time, respond_rate, max_respond_rate; //第一个进程被调度 ef[0].kaishitime = ef[0].daodatime; ef[0].jieshutime = ef[0].kaishitime + ef[0].yunxingtime; temp_time = ef[0].jieshutime; ef[0].run_flag = 1; ef[0].order = 1; tc = 1; //调度其他进程 while (tc { max_respond_rate = 0; for (j = 1; j { if ((ef[j].daodatime <= temp_time) && (!ef[j].run_flag)) { respond_rate = (temp_time - ef[j].daodatime) / ef[j].yunxingtime; if (respond_rate>max_respond_rate) { max_respond_rate = respond_rate; zx = j; } } } //找响应比高的进程 ef[zx].kaishitime = temp_time; ef[zx].jieshutime = ef[zx].kaishitime + ef[zx].yunxingtime; temp_time = ef[zx].jieshutime; ef[zx].run_flag = 1; tc+= 1; ef[zx].order = tc; } return 0; } int in() //进程参数输入 { int i; cout <<"请输入进程数目:\n"< cin>>c; for (i = 0; i { cout <<"请输入第"<< i+1 <<"个进程的名字\n"< cin>> ef[i].name; cout <<"请输入第"<< i + 1 <<"个进程的编号:\n"<< endl; cin>> ef[i].number; cout <<"请输入第"<< i + 1 <<"个进程的到达时间:\n"<< endl; cin >> ef[i].daodatime; cout <<"请输入第"<< i + 1 <<"个进程的运行时间:\n"<< endl; cin >> ef[i].yunxingtime; ef[i].kaishitime = 0; ef[i].jieshutime = 0; ef[i].order = 0; ef[i].run_flag = 0; } return 0; } int out() /*调度结果输出*/ { int i; float turn_round_time = 0, f1, w = 0; cout<<"进程名编号到达时间运行时间开始时间结束时间平均周转时间平均带权周 转时间\n"< for (i = 0; i { f1 = ef[i].jieshutime - ef[i].daodatime; turn_round_time += f1; w += (f1 / ef[i].yunxingtime); cout <<" "<< ef[i].name <<" "<< ef[i].number <<" "<< ef[i].daodatime <<" "<< ef[i].yunxingtime <<" "<< ef[i].kaishitime <<" "<< ef[i].jieshutime <<" "<< turn_round_time / c<<" "<< w / c < } //cout << "平均周转时间=\n"< //cout << "带权周转时间=\n"<< w / c< return 0; } struct ef *input() { int N, i; // 定义队首、队尾 struct ef *head, *rear; // p是队尾指针，q是队首指针，t是执行时间 struct ef *p, *q, *t; // 初始化队首和队尾为空 head = rear = NULL; cout <<"请输入进程数目："< cin>> N; for (i = 0; i < N; i++) { // 初始化一个空间给进程 p = (struct ef *)malloc(sizeof(struct ef)); cout <<"请输入第"<< i+1 <<"个进程的名字\n"< cin >> p->name; cout <<"请输入第"<< i + 1 <<"个进程的编号:\n"<< endl; cin >>p->number; cout <<"请输入第"<< i + 1 <<"个进程的到达时间:\n"<< endl; cin >>p->daodatime; cout <<"请输入第"<< i + 1 <<"个进程的服务时间:\n"<< endl; cin >> p->fuwutime; p->shengyutime = p->fuwutime; p->next = NULL; // 当输入结束时，把p的数据放到队首，以便下一步执行 if (rear == NULL) { head = p; p->next = NULL; rear = p; } // 否则执行时间为空，队首变成q else { t = NULL; q = head; // 当q和q的到达时间小于p的到达时间时，把执行时间给q while (q && q->daodatime < p->daodatime) { t = q; q = q->next; } // 当q是队首时，则下一个队首变成p,以便每个进程都能够得到时间片if (q == head) { p->next = head; head = p; } // 当执行时间片到达队尾时（执行完成），返回给队首p else if (t == rear) { rear->next = p; p->next = NULL; rear = p; } // 否则给队首p占用执行时间，p执行完后到q else { t->next = p; p->next = q; } } } // 返回队首 return head; } void run(struct ef *head) { struct ef *p, *t, *r; int num; // 运行过程 vector cout<<"请输入时间片："< cin>>num; // 当队首不为空时，把p给队首 while (head != NULL) { r = p = head; // 把执行时间给队首 while (p != NULL) { t = head; // p的剩余时间 = 剩余时间 - 时间片 p->shengyutime = p->shengyutime - num; p->jieshutime = p->kaishitime + p->fuwutime; string s = p->name; vec_out.push_back(s); // 当p运行完，即剩余时间小于0时，仍然把它当做0处理 if (p->shengyutime < 0) p->shengyutime = 0; cout<<"进程编号到达时间服务时间剩余时间完成时间 \n"< //时间不为空时，输出当前进程的信息，并把时间片交给下一个进程 while (t != NULL) { cout <<" "<< t->name <<" "< t->daodatime <<" "<< t->fuwutime <<" "<< t->shengyutime <<" " < t = t->next; } //当队首的剩余时间为0时，先把队首改成p的下一个，然后释放内存，删除队 三、虚拟存储管理器的页面调度 页面调度算法主要有：FIFO，最近最少使用调度算法（LRU），最近最不常用调度算法（LFU），最佳算法（OPT） 1．输入： 页面流文件，其中存储的是一系列页面号（页面号用整数表示，用空格作为分隔符），用来模拟待换入的页面。 下面是一个示意： 1 2 3 4 1 2 5 1 2 3 4 5 2．处理要求： 程序运行时，首先提示“请输入页面流文件的文件名：”，输入一个文件名后，程序将读入该文件中的有关数据。 初始条件：采用三个页框，初始时均为空。 根据第二次机会算法对数据进行处理。 3．输出要求： 每换入一个页面（即：每读入一个页面号），判断是否有页面需要被换出。若有，把被换出的页面号输出到屏幕上； 若没有，则输出一个“*”号。 4．文件名约定 提交的源程序名字：sourceXXX.c或者sourceXXX.cpp（依据所用语言确定） 输入文件名字：可由用户指定 其中：XXX为账号。 5．测试说明：测试教师将事先准备好一组文件（格式为*.txt），从中为每个程序随机指定一至三个作为输入文件 （被测试者需从键盘输入指定文件的文件名），并查看程序输出结果。 6．第二次机会算法：对FIFO算法做如下简单的修改：发生替换时，先检查最老页面的R（访问）位。如果为0， 那么此页面是最早被换入的，而且近期没有被访问，可以立刻被替换掉；如果R位为1，就清除R位，并修改它的装入时间， 使它就像刚被装入的新页面一样，然后继续搜索可替换的最老页面。 我没做出来~~~~ 页面调度算法主要有：FIFO，最近最少使用调度算法（LRU），最近最不常用调度算法（LFU），最佳算法（OPT） 这几种算法的调度都有可能在考试中碰到。 关于这一类型，大家还可以参看书本251页的实验指导。 如2001年考题： 要求： 1。实现三种算法： FIFO，最近最少使用调度算法（LRU），最近最不常用调度算法（LFU） 2。页面序列从指定的文本文件（TXT文件）中取出 处理器调度 选择题 当CPU执行操作系统代码时，则处理机处于( )。 A．执行态 B．目态 C．管态 D．就绪态 ( )是机器指令的扩充，是硬件的首次延伸，是加在硬件上的第一层软件。 A．系统调用 B．操作系统 C．内核 D．特权指令 操作系统提供给程序员的接口是( )。 A．进程 B．系统调用 C．库函数 D．B和C 用户程序向系统提出使用外设的请求方式是( )。 A．作业申请 B．原语 C．系统调用 D．I／O指令 当作业正常完成进入完成状态时，操作系统( )。 A．将输出该作业的结果并删除内存中的作业 B．将收回该作业的所占资源并输出结果 C．将收回该作业的所占资源及输出结果，并删除该作业 D．将收回该作业的所占资源及输出结果，并将它的控制块从当前的队列中删除 下列选项是关于作业和进程关系的描述，其中哪一个是不正确的( )。 A．作业的概念主要用在批处理系统中，而进程的概念则用在几乎所有的OS中。 B．作业是比进程低一级的概念。 C．一个作业至少由一个进程组成。 D．作业是用户向计算机提交任务的实体，而进程是完成用户任务的执行实体以及向系统申请分配资源的基本单位。 作业从后备作业到被调度程序选中的时间称为( )。 周转时间B．响应时间C．等待调度时间D．运行时间 设有三个作业J1，J2，J3，它们同时到达，运行时间分别为T1，T2，T3，且T1≤T2≤T3，若它们在一台处理机上按单道运行，采用短作业优先算法，则平均周转时间为( )。 A．T1+T2+T3 B．1／3(T1+T2+T3) C．T1+2／3T2+1／3T3 D．T1+1／3T2+2／3T3 从作业提交给系统到作业完成的时间间隔称为作业的( )。 A．中断时间 B．等待时间 C．周转时间 D．响应时间 设有四个作业同时到达，每个作业执行时间均为2 h，它们在一台处理机上按单道方式运行，则平均周转时间为( )。 A．1 h B．5 h C．2．5 h D．8 h FCFS调度算法有利于( )。 A．长作业和CPU繁忙型作业 B．长作业和I／O繁忙型作业 C．短作业和CPU繁忙型作业 D．短作业和I／O繁忙型作业 下列哪种说法不是SJ(P)F调度算法的缺点( )。 A．对于长作业(进程)不利 B．未考虑作业(进程)的紧迫程度 C．不能有效降低作业(进程)的平均等待时间 D．由于根据的是用户提供的估计执行时间，因此不一定真正做到短而优先。 选择排队进程中等待时间最长的进程被优先调度，该调度算法是( )。 A．先来先服务调度算法B．短进程优先调度算法 C．优先权调度算法D．高响应比优先调度算法 在采用动态优先权的优先权调度算法中，如果所有进程都具有相同优先权初值，则此时的优先权调度算法实际上和( )相同。 课程设计报告 设计名称：模拟实现一种处理机调度算法 学生姓名： xxx 专业：计算机科学与技术 班别： xxxxxxxx 学号： xxxxxx 指导老师： xxxxx 日期： 2014 年 6 月 20 日 初始条件： 1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。 2．实践准备：掌握一种计算机高级语言的使用。 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求） 1．模拟进程调度，能够处理以下的情形： ⑴能够选择不同的调度算法（要求中给出的调度算法）； ⑵能够输入进程的基本信息，如进程名、优先级、到达 时间和运行时间等； ⑶根据选择的调度算法显示进程调度队列； ⑷根据选择的调度算法计算平均周转时间和平均带权周 转时间。 2．设计报告内容应说明： ⑴需求分析； ⑵功能设计（数据结构及模块说明）； ⑶开发平台及源程序的主要部分； ⑷测试用例，运行结果与运行情况分析； ⑸自我评价与总结： i）你认为你完成的设计哪些地方做得比较好或比较出 色； ii）什么地方做得不太好，以后如何改正； iii）从本设计得到的收获（在编写，调试，执行过程中 的经验和教训）； iv）完成本题是否有其他方法（如果有，简要说明该方 法）； 进程调度模拟设计——先来先服务、优先级法1、背景： 当计算机系统是多道程序设计系统时，通常会有多个进程或线程同时竞争CPU。只要有两个或更多的进程处于就绪状态，这种情形就会发生。如果只有一个CPU可用，那么就必须选择下一个要运行的进程。在操作系统中，完成选择工作的这一部分称为调度程序，该程序使用的算法成为调度算法。 进程调度的核心问题是采用什么样的算法把处理机分配给进程，好的算法将提高资源利用率，减少处理机的空闲时间，避免有些作业长期得不到相应的情况发生等，从而设计出受欢迎的操作系统。较常见的几种进程调度算法有：先来先服务调度算法；短作业优先调度算法；时间片轮转调度算法；优先级调度算法；高响应比优先算法和多级反馈队列调度算法等。 2.1设计目的 无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机 福建农林大学计算机与信息学院 课程设计报告 课程名称：操作系统 实习题目：进程调度算法模拟 姓名： 系：计算机科学与技术系 专业：计算机科学与技术 年级：2012 学号： 指导教师： 职称：副教授 年月日 福建农林大学计算机与信息学院计算机类 课程设计结果评定 目录 1.本选题课程设计的目的 (4) 2.本选题课程设计的要求 (4) 3.本选题课程设计报告内容 (4) 3．1前言 (4) 3．2进程调度算法模拟的环境 (4) 3．3系统技术分析 (4) 3．4系统流程图及各模块 (5) 3．5程序调试情况 (8) 4．总结 (11) 参考文献 (11) 程序代码 (12) 1.设计目的 课程设计将课本上的理论知识和实际有机的结合起来，锻炼学生的分析系统，解决实际问题的能力。提高学生分析系统、实践编程的能力。 2.设计要求 利用学到的操作系统和编程知识，完成具有一定难度的系统分析研究或系统设计题目。其中：专题系统理论研究应包括研究目的、目标，论点和论据以及证明推导等；分析、设计系统应包括编写、调试程序以及最后写出设计报告或系统说明文档文件，系统说明文档包括系统界面、变量说明、系统功能说明、编程算法或思路、流程图和完整程序。具体要求如下： 1、对系统进行功能模块分析、控制模块分析正确； 2、系统设计要实用； 3、编程简练，可用，功能全面； 4、说明书、流程图要清楚。 3.设计方案 3.1前言 本程序包括三种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。 3.2本选题设计的环境 WindowsXP下的Microsoft Visual C++ 6.0 3.3系统技术分析 （1）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：进程标识数ID。 进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 《计算机操作系统》实验报告 实验五：页面调度算法模拟 学校：╳╳╳ 院系：╳╳╳ 班级：╳╳╳ 姓名：╳╳╳ 学号：╳╳╳ 指导教师：╳╳╳ 目录 一、实验题目 (3) 二、实验学时 (4) 三、指导老师 (4) 四、实验日期 (4) 五、实验目的 (4) 六、实验原理 (4) 6.1页面的含义 (4) 6.2 页面置换算法的含义 (4) 6.3 置换算法 (4) 6.3.1最佳置换算法(Optimal) (5) 6.3.2先进先出(FIFO)页面置换算法 (5) 6.3.3 LRU置换算法 (5) 七、实验步骤及结果 (5) 7.1 验证最佳置换算法 (5) 7.1.1 实验截图 (5) 7.1.2 实验分析 (6) 7.2 验证先进先出(FIFO)页面置换算法 (7) 7.2.1 实验截图 (7) 7.2.2 实验分析 (7) 7.3 验证LRU置换算法 (8) 7.3.1 实验截图 (8) 7.3.2 实验分析 (8) 八、报告书写人 (9) 附录一最佳置换算法(Optimal) (9) 附录二先进先出(FIFO)页面置换算法 (15) 附录三LRU置换算法 (20) 实验五：页面调度算法模拟 一、实验题目 页面调度算法模拟 二、实验学时 2学时 三、指导老师 ╳╳╳ 四、实验日期 2018年12月10日星期一 五、实验目的 (1)熟悉操作系统页面调度算法 (2)编写程序模拟先进先出、LRU等页面调度算法，体会页面调度算法原理 六、实验原理 6.1页面的含义 分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。 6.2 页面置换算法的含义 在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。但应将哪个页面调出，须根据一定的算法来确定。通常，把选择换出页面的算法称为页面置换算法(Page_Replacement Algorithms)。 6.3 置换算法 一个好的页面置换算法，应具有较低的页面更换频率。从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。 C语言模拟CPU调度 C语言模拟CPU调度 CPU在处理多个进程时，要根据各种情况对处理的进程进行调度。这其中就包括对各个进程优先级的处理，和调度算法的处理。下面这个C语言程序，是我在大学期间学习《操作系统》课程的CPU调度时编写的，模拟了CPU的两种调度模式和各种模式所对应的多种调度算法。为了模拟得更为形象，采用了图形屏幕输出。 #include<stdlib.h> #include<stdio.h> #include<conio.h> #include<graphics.h> #include<math.h> #include<dos.h> #define NULL 0 /*-----------------------------------------------------------------*/ struct event /*事件结点结构*/ { int evtype; /*1：进程产生。2：进程执行。3：激 活阻塞进程。 4：进程执行完5:进程阻塞* 6:返回事件*/ int pnum; /*执行该事件的进程号*/ int t; /*事件发生的时间*/ int ifblock; /*如果是执行事件标准其有无阻塞，其它事件时无定义*/ struct event *next; }; struct process /*进程结点结构*/ { int pnum; /*进程号*/ int plong; /*进程长度*/ int prior; /*进程优先级*/ int blocknum; /*进程当前的阻塞数*/ int runtime; /*执行次数*/ struct process *next; }; struct headnod /*队列头结点结构*/ { struct process *head; /*队列头*/ int totalpro; /*队列中的进程数*/ 实验报告 学院（系）名称：计算机与通信工程学院 姓名学号专业计算机科学与技术班级2009级3班实验项目实验一：处理机调度算法的实现 课程名称操作系统课程代码0668036 实验时间2011 年11月17日第3、4节 2011 年11月21日第7、8节 2011 年11月24日第3、4节 实验地点软件实验室7-216 批改意见成绩 教师签字： 实验内容： 1．设定系统中有五个进程，每一个进程用一个进程控制块表示。 2．输入每个进程的“优先数”和“要求运行时间”。 3．为了调度方便，将五个进程按给定的优先数从大到小连成就绪队列。用一单元指出队列首进程，用指针指出队列的连接情况。 4．处理机调度总是选队首进程运行。采用动态优先数算法，进程每运行一次优先数就减“1”，同时将运行时间减“1”。 5．若某进程运行时间为零，则将其状态置为“结束”,且退出队列。 6．运行所设计程序，显示或打印逐次被选中进程的进程名，以及进程控制块的动态变化过程。 实验要求： 1．详细描述实验设计思想、程序结构及各模块设计思路； 2．详细描述程序所用数据结构及算法； 3．明确给出测试用例和实验结果； 4．为增加程序可读性，在程序中进行适当注释说明； 5．认真进行实验总结，包括：设计中遇到的问题、解决方法与收获等； 6．实验报告撰写要求结构清晰、描述准确逻辑性强； 7．实验过程中，同学之间可以进行讨论互相提高，但绝对禁止抄袭。 【实验过程记录（源程序、测试用例、测试结果及心得体会等）】 程序运行代码如下： #include 河南中医学院 《linux操作系统》课程设计报告 题目：基于Linux的进程调度模拟程序 所在院系：信息技术学院 专业年级：2011级计算机科学与技术完成学生：2011180021 郭姗 指导教师：阮晓龙 完成日期：201X 年06 月22 日 目录 1. 课程设计题目概述3 2. 研究内容与目的4 3. 研究方法5 4. 研究报告6 5. 测试报告/实验报告7 6. 课题研究结论8 7. 总结9 1、课程设计题目概述 随着Linux系统的逐渐推广，它被越来越多的计算机用户所了解和应用. Linux是一个多任务的操作系统，也就是说，在同一个时间内，可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话，会知道我们大家常用的单CPU计算机实际上在一个时间片断内只能执行一条指令，那么Linux是如何实现多进程同时执行的呢？原来Linux使用了一种称为"进程调度（process scheduling）"的手段，首先，为每个进程指派一定的运行时间，这个时间通常很短，短到以毫秒为单位，然后依照某种规则，从众多进程中挑选一个投入运行，其他的进程暂时等待，当正在运行的那个进程时间耗尽，或执行完毕退出，或因某种原因暂停，Linux就会重新进行调度，挑选下一个进程投入运行。因为每个进程占用的时间片都很短，在我们使用者的角度来看，就好像多个进程同时运行一样了。本文就是对进程调度进行研究、实验的。 本文首先对Linux系统进行了简要的介绍, 然后介绍了进程管理的相关理论知识。其次，又介绍最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）、先来先服务算法的相关知识，并对进程调度进行最高优先数优先的调度算法和先来先服务算法模拟实验，并对比分析两种算法的优缺点，从而加深对进程概念和进程调度过程/算法的理解 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择某一进程占用处理机。使得系统中的进程能够有条不紊的运行，同时提高处理机的利用率以及系统的性能。所以设计模拟进程调度算法（最高优先数优先的调度算法、先来先服务算法），以巩固和加深处理进程的概念，并且分析这两种算法的优缺点。关键词：linux 进程调度调度算法 实验一处理器调度 一、实验容 选择一个调度算法，实现处理器调度。 二、实验目的 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。 三、实验题目 设计一个按时间片轮转法实现处理器调度的程序。 [提示]： (1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。进程控制块的 格式为： 其中，Q1，Q2，Q3，Q4，Q5。 指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。 要求运行时间——假设进程需要运行的单位时间数。 已运行时间——假设进程已经运行的单位时间数，初始值为“0”。 状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。 当一个进程运行结束后，它的状态为“结束”，用“E”表示。 (2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。 (3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如，当前轮到P2执行，则有： 标志单元 K1 K2 K 3 K4 K5 (4)处理器调度总是选择标志单元指示的进程运行。由于本实习是模拟处理器调度的 功能，所以，对被选中的进程并不实际的启动运行，而是执行： 已运行时间+1 来模拟进程的一次运行，表示进程已经运行过一个单位的时间。 请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。在这时省去了这些工作，仅用“已运行时间+1”来表示进程已 经运行满一个时间片。 (5)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一 个轮到运行的进程。同时，应判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间 已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。若该进程的要求运行时间=已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”（E）且退出队列。此时，应把该进程的进程控制块中的指针值送到前 面一个进程的指针位置。 (6)若“就绪”状态的进程队列不为空，则重复上面的（4）和（5）的步骤，直到所有 的进程都成为“结束”状态。 (7)在所设计的程序中应有显示或打印语句，能显示或打印每次选中进程的进程名以及 运行一次后进程队列的变化。 (8)为五个进程任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示 或打印逐次被选中的进程名以及进程控制块的动态变化过程。 四. 所用数据结构及符号说明 typedef struct PNode//PCB { struct PNode *next; //定义指向下一个节点的指针 char name[10]; //定义进程名，并分配空间 int All_time; //定义总运行时间 int Runed_Time; //定义已运行时间 char state; //定义进程状态Ready/End } *Proc; //指向该PCB的指针 int ProcNum; //总进程数 前言操作系统（OperatingSystem，简称OS）是管理和控制计算机硬件与软件资源的计算机程序，是直接运行在“裸机”上的最基本的系统软件，任何其他软件都必须在操作系统的支持下才能运行。 操作系统是用户和计算机的接口，同时也是计算机硬件和其他软件的接口。操作系统的功能包括管理计算机系统的硬件、软件及数据资源，控制程序运行，改善人机界面，为其它应用软件提供支持，让计算机系统所有资源最大限度地发挥作用，提供各种形式的用户界面，使用户有一个好的工作环境，为其它软件的开发提供必要的服务和相应的接口等。实际上，用户是不用接触操作系统的，操作系统管理着计算机硬件资源，同时按照应用程序的资源请求，分配资源，如：划分CPU时间，内存空间的开辟，调用打印机等。 操作系统的主要功能是资源管理，程序控制和人机交互等。计算机系统的资源可分为设备资源和信息资源两大类。设备资源指的是组成计算机的硬件设备，如中央处理器，主存储器，磁盘存储器，打印机，磁带存储器，显示器，键盘输入设备和鼠标等。信息资源指的是存放于计算机内的各种数据，如系统软件和应用软件等。 操作系统位于底层硬件与用户之间，是两者沟通的桥梁。用户可以通过操作系统的用户界面，输入命令。操作系统则对命令进行解释，驱动硬件设备，实现用户要求。 本次课程设计我们将对上学期所学的知识进行系统的应用，而达到巩固知识的作用 目录 1问题概述.................................................................................................... 2需求分析.................................................................................................... 3概要设计.................................................................................................... 3.1主要功能................................................................................................. 3.2模块功能结构 ........................................................................................ 3.3软硬件环境............................................................................................. 3.4数据结构设计 ........................................................................................ 4详细设计.................................................................................................... 4.1“先来先服务（FCFS）调度算法” ....................................................... 4.2“短进程调度算法（SPF）”.................................................................. 4.3“高响应比优先调度算法”................................................................. 4.4“优先级调度（非抢占式）算法”.......................................................... 5系统测试及调试 ....................................................................................... 5.1测试......................................................................................................... 5.2调试过程中遇到的问题 ........................................................................ 6心得体会.................................................................................................... 7参考文献.................................................................................................... 8附录............................................................................................................ 实验报告 院（系）： 专业班级： 学号: 姓名: 实验地点: 实验日期: 课程名称实验项目名称实验学时实验类型计算机操作系统页面调度算法 2 验证型 一、实验目的及要求 通过本实验可以加深理解有关虚拟存储器的工作原理，进一步体会和了解页面替换算法的具体实现方法。 二、实验环境 PC /Windows系统/Visual C++6.0 三、实验内容 ①实现三种算法：先进先出；OPT；LRU ②页面序列从指定的文本文件（TXT文件）中取出 ③输出：第一行：每次淘汰的页面号，第二行：显示缺页的总次数 四、实验步骤 1．先进先出(FIFO)置换算法的思路 该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单，只需把一个进程已调入内存的页面，按照先后次序连接成一个队列，并设置一个替换指针，使它总指向最老的页面。 2．最近久未使用(LRU)置换算法的思路 最近久未使用置换算法的替换规则，是根据页面调入内存后的使用情况来进行决策的。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间，当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。 3.最佳（OPT）置换算法的思路 其所选择的被淘汰的页面，将是以后不使用的，或者是在未来时间内不再被访问的页面，采用最佳算法，通常可保证获得最低的缺页率。 4、流程图如下图所示： 五、调试过程 程序结构分析： 程序共有以下九个部分： int findSpace(void);//查找是否有空闲内存 int findExist(int curpage);//查找内存中是否有该页面 开始 取一条指令 取指令中访问的页号=>L 查 页 表 页标记=1？ 形成绝对地址 是“存”指令？ 置L 页修改标记“1” 输出绝对地址 输出“*页号” 有后继指令？ 取一条指令 结 束 J:=P[k] J 页的修改标记 输出“OUTj ” 输出“INL ” P[k]:=L k:=(k+1) mod m 修改页面 是 否 是 否 否（产生缺页中断） 是 否 第四章处理机调度 4.3 习题 4.3.1 选择最合适的答案 1．某系统采用了银行家算法，则下列叙述正确的是（）。 A.系统处于不安全状态时一定会发生死锁 B.系统处于不安全状态时可能会发生死锁 C.系统处于安全状态时可能会发生死锁 D.系统处于安全状态时一定会发生死锁 2．银行家算法中的数据结构包括有可利用资源向量Available、最大需求矩阵Max、分配矩阵Allocation、需求矩阵Need，下列选项正确的是（）。 A.Max[i,j]=Allocation[i,j]+Need[i,j] B.Need[i,j]= Allocation[i,j]+ Max[i,j] C.Max[i,j]= Available[i,j]+Need[i,j] D.Need[i,j]= Available[i,j]+ Max[i,j] 3．下列进程调度算法中，（）可能会出现进程长期得不到调度的情况。 A.非抢占式静态优先权法 B.抢占式静态优先权法 C.时间片轮转调度算法 D.非抢占式动态优先权法 4．在下列选项中，属于预防死锁的方法是（）。 A.剥夺资源法 B.资源分配图简化法 C.资源随意分配 D.银行家算法 5．在下列选项中，属于检测死锁的方法是（）。 A.银行家算法 B.消进程法 C.资源静态分配法 D.资源分配图简化法 6．在下列选项中，属于解除死锁的方法是（）。 A．剥夺资源法 B.资源分配图简化法 C．银行家算法 D.资源静态分配法 7．为了照顾紧迫型作业，应采用（）。 A.先来服务调度算法 B.短作业优先调度算法 C.时间片轮转调度算法 D.优先权调度算法 8．在采用动态优先权的优先权调度算法中，如果所有进程都具有相同优先权初值，则 一．课程概述 1.1.设计构想 程序能够完成以下操作：创建进程：先输入进程的数目，再一次输入每个进程的进程名、运行总时间和优先级，先到达的先输入；进程调度：进程创建完成后就选择进程调度算法，并单步执行，每次执行的结果都从屏幕上输出来。 1.2.需求分析 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目，要使这多个进程能够并发地执行，这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统必（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。本次实验在VC++6.0环境下实现先来先服务调度算法，短作业优先调度算法，高优先权调度算法，时间片轮转调度算法和多级反馈队列调度算法。 1.3.理论依据 为了描述和管制进程的运行，系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息，系统总是通过PCB对进程进行控制，亦即，系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的，PCB是进程存在的惟一标志。本次课程设计用结构体Process代替PCB的功能。 1.4.课程任务 一、用C语言（或C++）编程实现操作模拟操作系统进程调度子系统的基本功能；运用多 种算法实现对进程的模拟调度。 二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多 级反馈队列调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。 三、实现用户界面的开发 LRU页面调度算法实现 学院计算机科学与技术专业计算机科学与技术学号 学生姓名 指导教师姓名 2014年3月16 日 目录 1.实验要求 (2) 2.实验目的 (2) 3.实验内容 (2) 4.相关知识 (2) 5.实验原理 (3) 6.流程图 (4) 7.源代码 (5) 8.运行结果 (9) 9.实验心得 (10) 10.参考文献 (11) LRU页调度算法实现 一实验要求： 1．不同的功能使用不同的函数实现（模块化），对每个函数的功能和调用接口要注释清 楚。对程序其它部分也进行必要的注释。 2．对系统进行功能模块分析、画出总流程图和各模块流程图。 3．用户界面要求使用方便、简洁明了、美观大方、格式统一。所有功能可以反复使用，最好使用菜单。 4．通过命令行相应选项能直接进入某个相应菜单选项的功能模块。 5．所有程序需调试通过。 二实验目的： 将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。进一步巩固和复习操作系统的基础知识。培养学生结构化程序、模块化程序设计的方法和能力。提高学生调试程序的技巧和软件设计的能力。提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。 三实验内容： 程序应模拟实现LRU 算法思想，对n个页面实现模拟调度。 四相关知识： 1．虚拟存储器的引入： 局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。 2．虚拟存储器的定义： 虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。 3．虚拟存储器的实现方式： 分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。 请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。 五．实验原理： 目前有许多页面调度算法，本实验主要涉及最近最久未使用调度算法。本实验使用页面调度算法时作如下假设，进程在创建时由操作系统为之分配一个固定数目物理页，执行过程中物理页的数目和位置不会改变。也即进程进行页面调度时只能在分到的几个物理页中进行。 LRU基本思想： LRU是Least Recently Used的缩写，即最近最少使用页面置换算法，是为虚拟页式存储管理服务的。 关于操作系统的内存管理，如何节省利用容量不大的内存为最多的进程提供资源，一直是研究的重要方向。而内存的虚拟存储管理，是现在最通用，最成功的方式——在内存有限的情况下，扩展一部分外存作为虚拟内存，真正的内存只存储当前运行时所用得到信息。这无疑极大地扩充了内存的功能，极大地提高了计算机的并发度。虚拟页式存储管理，则是将进程所需空间划分为多个页面，内存中只存放当前所需页面，其余页面放入外存的管理方式。 LRU算法的提出，是基于这样一个事实：在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。这个，就是著名的局部性原理——比内存速度还要快的cache，也是基于同样的原理运行的。因此，我们只需要在每次调换时，找到最近最少使用的那个页面调出内存。这就是LRU算法的全部内容。 实验中是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。数组flag[10]标记页面的访问时间。每当使用页面时，刷新访问时间。发生缺页时，就从物理块中页面标记最小的一页，调出该页，换入所缺的页面。 处理器调度习题 处理器调度 选择题 ?当CPU执行操作系统代码时，则处理机处于( )。 ?A．执行态 B．目态 C．管态 D．就绪态 ?( )是机器指令的扩充，是硬件的首次延伸，是加在硬件上的第一层软件。 ?A．系统调用 B．操作系统 C．内核 D．特权指令 ?操作系统提供给程序员的接口是( )。 ?A．进程 B．系统调用 C．库函数 D．B和C ?用户程序向系统提出使用外设的请求方式是( )。 ?A．作业申请 B．原语 C．系统调用 D．I／O指令 ?当作业正常完成进入完成状态时，操作系统( )。 ?A．将输出该作业的结果并删除内存中的作业 ?B．将收回该作业的所占资源并输出结果 ?C．将收回该作业的所占资源及输出结果，并删除该作业 ?D．将收回该作业的所占资源及输出结果，并将它的控制块从当前的队列中删除 ?下列选项是关于作业和进程关系的描述，其中哪一个是不正确的( )。 ?A．作业的概念主要用在批处理系统中，而进程的概念则用在几乎所有的OS中。 ?B．作业是比进程低一级的概念。 ?C．一个作业至少由一个进程组成。 ?D．作业是用户向计算机提交任务的实体，而进程是完成用户任务的执行实体以及向系统申请分配资源的基本单位。 ?作业从后备作业到被调度程序选中的时间称为( )。 ?周转时间B．响应时间C．等待调度时间D．运行时间 ?设有三个作业J1，J2，J3，它们同时到达，运行时间分别为T1，T2，T3，且T1≤T2≤T3，若它们在一台处理机上按单道运行，采用短作业优先算法，则平均周转时间为( )。 ?A．T1+T2+T3 B．1／3(T1+T2+T3) ?C．T1+2／3T2+1／3T3 D．T1+1／3T2+2／3T3 ?从作业提交给系统到作业完成的时间间隔称为作业的( )。 ?A．中断时间 B．等待时间 C．周转时间 D．响应时间 ?设有四个作业同时到达，每个作业执行时间均为2 h，它们在一台处理机上按单道方式运行，则平均周转时间为( )。 ?A．1 h B．5 h C．2．5 h D．8 h ?FCFS调度算法有利于( )。 ?A．长作业和CPU繁忙型作业 B．长作业和I／O繁忙型作业 ?C．短作业和CPU繁忙型作业 D．短作业和I／O繁忙型作业 ?下列哪种说法不是SJ(P)F调度算法的缺点( )。 ?A．对于长作业(进程)不利 ?B．未考虑作业(进程)的紧迫程度 ?C．不能有效降低作业(进程)的平均等待时间 ?D．由于根据的是用户提供的估计执行时间，因此不一定真正做到短而优先。 ?选择排队进程中等待时间最长的进程被优先调度，该调度算法是( )。 ?A．先来先服务调度算法B．短进程优先调度算法 ?C．优先权调度算法D．高响应比优先调度算法 ?在采用动态优先权的优先权调度算法中，如果所有进程都具有相同优先权初值，则此时的优先权调度算法实际上和( )相同。 ?A．先来先服务调度算法B．短进程优先调度算法 : 操作系统 课程设计报告 @ 学校：广州大学 学院：计算机科学与教育软件学院 班级：计算机127班 课题：处理机调度程序 任课老师：陶文正、陈文彬 姓名：黄俊鹏 { 学号：11 班内序号：27 成绩： 日期：2015年1月6日 一、设计目的 在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择一进程占用处理机。要求学生设计一个模拟处理机调度算法，以巩固和加深处理机调度的概念。 二、设计要求 1）进程调度算法包括：时间片轮转法，短作业优先算法，动态优先级算法。2）可选择进程数量 3）本程序包括三种算法，用C语言实现，执行时在主界面选择算法（可用函数实现）（进程数，运行时间，优先数由随机函数产生）执行，显示结果。 三、设计思路及算法思想 1.· 2.界面菜单选项 一级菜单提供2个选项： ①自动生成进程数量 ②手动输入所需进程数量 一级菜单选择完毕后进入二级菜单： ①重新生成进程 ②时间片轮转法 《 ③短作业优先算法 ④动态优先级算法 ⑤退出程序 3.调度算法 程序所用PCB结构体 ! 需要用到的进程结构体如上图所示 1)时间片轮转法 主要是设置一个当前时间变量，curTime和时间片roundTime。 遍历进程组的时候，每运行一个进程，就把curTime += roundTime。进程已运行时间加roundTime 2)短作业优先算法 遍历进程组，找到未运行完成并且运行时间最短的进程，让它一次运行完成，如此往复，直到所有进程都运行完成为止。 3)— 4)动态优先级算法 做法跟短作业优先算法类似，此处主要是比较进程的优先数，优先级高者，先执行。直到全部执行完毕。当一个进程运行完毕后，适当增减其余进程的优先数，以达到动态调成优先级的效果。 4.程序流程图 课程设计说明书（操作系统） 题目：进程调度 院系：计算机科学与工程学院 专业班级：信息安全13-2 学号：20133029xx 学生姓名：xx 指导教师：xx 2015年12月15日 安徽理工大学课程设计（论文）任务书计算机科学与工程学院 安徽理工大学课程设计（论文）成绩评定表 摘要 现代计算机系统中，进程是资源分配和独立运行的基本单位，是操作系统的核心概念。因而，进程就成为理解操作系统如何实现系统管理的最基本，也是最重要的概念。进程调度是进程管理过程的主要组成部分，是必然要发生的事件。 在现代操作系统中，进程的并发机制在绝大多数时候，会产生不断变化的进程就绪队列和阻塞队列。处于执行态的进程无论是正常或非正常终止、或转换为阻塞状态，都会引发从就绪队列中，由进程调度选择一个进程进占CPU。 进程调度的核心是进程调度的算法．在本课程设计中，用良好清晰的界面向用户展示了进程调度中的时间片轮转调度算法。在最终实现的成果中，用户可指定需要模拟的进程数，CPU时间片和进程的最大执行时间，并且选择需要演示的算法，界面将会动态的显示进程调度过程及各个队列的变化。通过此进程调度模拟系统，用户可以对时间片轮转调度算法有进一步以及直观的了解。 关键词:进程，调度，PCB，时间片轮转 目录 1.设计目的 (6) 2.设计思路 (6) 3.设计过程 (8) 3.1流程图 (8) 3.2算法 (8) 3.3数据结构 (10) 3.4源代码 (10) 4.实验结果及分析 (20) 4.1 使用说明 (20) 4.2程序演示 (20) 5.实验总结 (24) 6.参考文献 (24)虚拟存储管理器的页面调度算法实现
处理器调度习题
模拟一种处理机调度算法讲解
进程调度算法模拟 (操作系统课程设计报告)
实验五-页面调度算法模拟实验报告
C语言模拟CPU调度
操作系统实验一处理机调度算法的实现
2011180021-Linux操作系统-课程设计报告-基于Linux的进程调度模拟程序
处理器调度(设计一个按时间片轮转法实现处理器调度的程序)
操作系统课程设计报告进程调度
实验3-页面调度算法
操作系统原理第四章 处理机调度习题
进程模拟调度算法课程设计
LRU页面调度算法实现
处理器调度习题教学内容
操作系统-课程设计报告-处理机调度程序
操作系统-课程设计
相关主题
文本预览