㈠ 基于反馈排队算法的cpu调度的模拟实现
设计 1 CPU 调度算法的模拟实现 一、 设计目的 1、 深入理解 CPU 调度的四种算法: 先到先服务算法 FCFS、 非抢占最短作业优先算法 SJF
㈡ 操作系统课程设计
设计题目
1设计题目：CPU调度(CPU调度算法的模拟实现)
具体内容：编写算法，实现CPU调度算法FCFS、非抢占SJF、可抢占优先权调度、RR
针对模拟进程，利用CPU调度算法进行调度
进行算法评价，计算平均周转时间和平均等待时间
要求：调度所需的进程参数由输入产生
手工输入
随机数产生
输出调度结果
输出鸡掸惯赶甙非轨石憨将算法评价指标
2设计题目：虚拟内存 (页面置换算法的模拟实现)
具体内容：编写算法，实现页面置换算法FIFO、LRU
针对内存地址引用串，运行页面置换算法进行页面置换
要求：算法所需的引用串参数由输入产生：可由手工输入也可基于随机数产生
输出内存驻留的页面集合
1．进程调度算法模块
[问题描述]
1、进程调度算法：采用动态最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）。
2、每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：
进程名---进程标示数 ID
优先数 PRIORITY 优先数越大优先权越高
到达时间---进程的到达时间为进程输入的时间。、
进程还需要运行时间ALLTIME，进程运行完毕ALLTIME=0，
已用CPU时间----CPUTIME、
进程的阻塞时间STARTBLOCK-表示当进程在运行STARTBLOCK个时间片后，进程将进入阻塞状态
进程的阻塞时间BLOCKTIME--表示当进程阻塞BLOCKTIME个时间片后，进程将进入就绪状态
进程状态—STATE
队列指针NEXT 用来将PCB排成队列。
3、调度原则：
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
进程在就绪队列中待一个时间片，优先数加1
每个进程的状态可以是就绪 R（READY）、运行R（Run）阻塞B(BLOCK)、或完成F（Finish）四种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减3，然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
求课程设计报告和用c语言编写的源代码
㈢ 用c语言实现先到先处理和最短路径优先的cpu调度算法
#include <stdio.h>
#define n 20
struct fcfs
{
int id;
int atime;
int runtime;
int ftime;
}f[n];
zcx(){
int xz;
int amount;
printf("**************分割线*********************\n");
printf("1.先来先服务\n");
printf("2.优先级\n");
printf("请输入你的选择:");
scanf("%d",&xz);
printf("\n\n");
if(xz==1)
{
printf("你的选择是先来先服务\n");
printf("请输入进程数:");
scanf("%d",&amount);
yihao(amount);
}
else
{
printf("你的选择是优先级\n");
printf("请输入进程数:");
scanf("%d",&amount);
erhao(amount);
}
}
yihao(int amount)
{
int i,j,l,k;
struct fcfs f[n];
printf("\n\n");
for(i=0;i<amount;i++)
{
printf("请输入第 %d 个程序的信息\n",i+1);
printf("进程名 :");
scanf("%d",&f[i].id);
printf("到达时间:");
scanf("%d",&f[i].atime);
printf("运行时间:");
scanf("%d",&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)
{
l=f[j].atime;
f[j].atime=f[j+1].atime;
f[j+1].atime=l;
k=f[j].id;
f[j].id=f[j+1].id;
f[j+1].id=k;
}
}
}
printf("进程名 开始时间 运行时间 结束时间 \n");
for(i=0;i<amount;i++)
{
f[i].ftime=f[i].atime+f[i].runtime;
printf("%d %d %d %d\n",f[i].id,f[i].atime,f[i].runtime,f[i].ftime);
f[i+1].atime=f[i].ftime;
}
zcx();
}
erhao(int amount)
{
int i,j,l,k;
struct fcfs f[n];
printf("\n\n");
for(i=0;i<amount;i++)
{
printf("请输入第 %d 个程序的信息\n",i+1);
printf("进程名 :");
scanf("%d",&f[i].id);
printf("优先级 :");
scanf("%d",&f[i].atime);
printf("运行时间:");
scanf("%d",&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)
{
l=f[j].atime;
f[j].atime=f[j+1].atime;
f[j+1].atime=l;
k=f[j].id;
f[j].id=f[j+1].id;
f[j+1].id=k;
}
}
}
printf("进程名 优先级 工作时间 \n");
for(i=0;i<amount;i++)
{
f[i].ftime=f[i].atime+f[i].runtime;
printf("%d %d %d \n",f[i].id,f[i].atime,f[i].runtime);
f[i+1].ftime=f[i].ftime+f[i+1].atime;
}
zcx();
}
void main()
{
zcx();
}
这是操作系统的作业吧
㈣ cpu调度的基本方式
我们知道，程序需要获得CPU的资源才能被调度和执行，那么当一个进程由于某种原因放弃CPU然后进入阻塞状态，下一个获得CPU资源去被调度执行的进程会是谁呢？下图中，进程1因为阻塞放弃CPU资源，此时，进程2刚IO操作结束，可以获得CPU资源去被调度，进程3的时间片轮转结束，也同样可以获得CPU资源去被调度，那么，此时的操作系统应该安排哪个进程去获得CPU资源呢？这就涉及到我们操作系统的CPU调度策略了。
根据生活中的例子，我们很容易想到以下两种策略CPU调度的直观想法：1.FIFO谁先进入，先调度谁，这是一种非常简单有效的方法，就好比我们去饭堂打饭，谁先到就给谁先打饭。但是这种策略会遇到一个问题：如果遇到一个很小的任务，但是它是最后进入的，那么必须得前面一大堆任务结束完后才能执行这个小小的任务，这样就感觉很不划算呀！因为我只是简简单单的一个小任务，但是从打开这个任务到结束这个任务要很久。这显然不符合我们的需求，因而我们会想到第2种策略，就是先调度小任务，后调度大任务。2.Priority很简单，就是任务短的优先执行，但是此时又有问题了，任务虽然短，但是它的执行时间不一定短，就好比在一个银行业务中，客户填写一个表，这是一个非常短的任务吧——就单单填个表，但是这个表很长很长，那么这个短任务它的执行时间就很长了，我们怎么知道这个短的任务将来会执行多长的时间呢？所以，这样的策略还是依然有问题。那么，面对诸多的场景，如何设计调度算法呢？首先，我们要明白我们的算法应该让什么更好呢？面对客户：银行调度算法的设计目标应该是用户满意；而面对进程：CPU调度的目标应该是进程满意。那怎么才能让进程满意呢？那就是时间了。进程希望尽早地结束任务，这就是周转时间(从任务到达到任务结束)要短，而且希望用户的操作能够尽快地被响应，这就是响应时间(从操作发生到响应)要短。而且系统内耗时间要少，吞吐量(任务的完成量)要大，系统需要把更多的时间用在任务的执行上，而不能老是去做无关紧要的事情，例如：频繁切换任务，切换栈，分配资源等事情。同时，系统还要去合理地调配任务。那么，CPU的调度策略如何做到合理呢？首先得明白系统中有以下的几种矛盾。1.吞吐量和响应时间之间有矛盾响应时间小=>切换次数多=>系统内耗大=>吞吐量小由于需要较短的响应时间，那么就得频繁地切换任务，这样系统的很多时间都花在切换任务上面了，系统的内耗大了，吞吐量就小了。2.前台任务和后台任务的关注点不同前台任务关注响应时间，后台任务关注周转时间。前台任务例如我们的word文档，我们打一个字，需要立马显示在文档中，这就是word文档这个任务关注的是响应时间；而后台任务中，例如我们的javac编译java代码，它的周转时间要小，即该任务从进入到结束所花的时间要小，即编译完成的时间要小。http://3.IO约束型任务和CPU约束型任务各有各的特点IO约束型任务就是使用CPU的时间较少，进行IO操作的时间较长，CPU约束型的任务就是使用CPU的时间较长。因此，要做到合理，需要折中、综合考虑以上的几种矛盾。由此，产生了一些CPU的调度算法，在下一节我们将重点讲述这些CPU调度算法。
关注小鲸融创，一起深度学习金融科技！
编辑于 2019-12-11 · 着作权归作者所有
赞同 1
评论
展开全部
㈤ 多核CPU调度有哪几种算法 比如单核的有优先级、先来先服务。那多核的有哪几种呢
一般多核任务调度算法有全局队列调度和局部队列调度。前者是指操作系统维护一个全局的任务等待队列，当系统中有一个CPU核心空闲时，操作系统就从全局任务等待队列中选取就绪任务开始在此核心上执行。这种方法的优点是CPU核心利用率较高。后者是指操作系统为每个CPU内核维护一个局部的任务等待队列，当系统中有一个CPU内核空闲时，便从该核心的任务等待队列中选取恰当的任务执行，这种方法的优点是任务基本上无需在多个CPU核心间切换，有利于提高CPU核心局部Cache命中率。目前多数多核CPU操作系统采用的是基于全局队列的任务调度算法。
㈥ CPU调度有哪些调度策略，并作详细阐述！
所谓调度就是选出待分派的作业或进程。
处理机调度的主要目的就是为了分配处理机。
在不同的操作系统中所采用的调度方式并不完全相同。有的系统中仅采用一级调度，而有的系统采用两级或三级，并且所用的调度算法也完全可能不同。
一般说来，作业从进人系统到最后完成，可能要经历三级调度：高级调度、中级调度和低级调度。
（1）高级调度：又称作业调度。其主要功能是根据一定的算法，从输人的一批作业中选出若干个作业，分配必要的资源，如内存、外设等，为它建立相应的用户作业进程和为其服务的系统进程（如输人、输出进程），最后把它们的程序和数据调人内存，等待进程调度程序对其执行调度，并在作业完成后作善后处理工作。
（2）中级调度：为了使内存中同时存放的进程数目不至于太多，有时就需要把某些进程从内存中移到外存上，以减少多道程序的数目，为此设立了中级调度。特别在采用虚拟存储技术的系统或分时系统中，往往增加中级调度这一级。所以中级调度的功能是在内存使用情况紧张时，将一些暂时不能运行的讲程从内存对换到外存上等待。当以后内存有足够的空闲空间时，再将合适的进程重新换人内存，等待进程调度。引人中级调度的主要目的是为了提高内存的利用率和系统吞吐量。它实际上就是存储器管理中的对换功能。
（3）低级调度：又称进程调度。其主要功能是根据一定的算法将CPU分派给就绪队列中的一个进程。执行低级调度功能的程序称做进程调度程序，由它实现CPU在进程间的切换。进程调度的运行频率很高，在分时系统中往往几十毫秒就要运行一次。进程调度是操作系统中最基本的一种调度。在一般类型的操作系统中都必须有进程调度，而且它的策略的优劣直接影响整个系统的计能。
㈦ cpu调度算法决定了进程执行的顺序.若有n个进程需要调度，有多少种可能的调度顺
前两天做操作系统作业的时候学习了一下几种进程调度算法，在思考和讨论后，有了一些自己的想法，现在就写出来，跟大家讨论下。，或者说只有有限的CPU资源，当系统中有多个进程处于就绪状态，要竞争CPU资源时，操作系统就要负责完成如何分配资源的任务。在操作系统中，由调度程序来完成这一选择分配的工作，调度程序所使用的算法即是调度算法。调度算法需要考虑的指标主要有尽量保证CPU资源分配的公平性；按照一定策略强制执行算法调度；平衡整个计算机系统，尽量保持各个部分都处于忙碌状态。而根据系统各自不同的特点和要求，调度算法又有一些侧重点和目标不同，因此，算法按照系统差异主要分为三大类：批处理系统中的调度算法，代表调度算法有：先来先服务、最短作业优先、最短剩余时间优先。交互式系统中的调度算法，代表调度算法有：轮转调度、优先级调度、多级队列、最短进程优先、保证调度、彩票调度、公平分享调度。实时系统中的调度算法，代表调度算法有：速率单调调度、最早最终时限优先调度。下面就上述提到的调度算法中挑出几个进行重点分析：保证调度保证调度是指利用算法向用户做出明确的性能保证，然后尽力按照此保证实现CPU的资源分配。利用这种算法，就是定一个进程占用CPU的时间的标准，然后按照这个标准去比较实际占用CPU的时间，调度进程每次使离此标准最远的进程得到资源，不断满足离所保证的标准最远的进程，从而平衡资源分配满足这个标准的要求。保证调度算法的优点是：能很好的保证进程公平的CPU份额，当系统的特点是：进程的优先级没有太大悬殊，所制定的保证标准差异不大，各个进程对CPU的要求较为接近时，比如说系统要求n个进程中的每个进程都只占用1/n的CPU资源，利用保证调度可以很容易的实现稳定的CPU分配要求。但缺点是，这种情况太过理想，当系统的各个进程对CPU要求的紧急程度不同，所制定的保证较为复杂的时候，这个算法实现起来比较困难。彩票调度彩票调度这种算法的大意是指向进程提供各种系统资源如CPU资源的彩票，当系统需要做出调度决策时，随机抽出一张彩票，由此彩票的拥有者获得资源。在彩票调度系统中，如果有一个新的进程出现并得到一些彩票，那么在下一次的抽奖中，该进程会有同它持有彩票数量成正比例的机会赢得奖励。进程持有的彩票数量越多，则被抽中的可能性就越大。调度程序可以通过控制进程的彩票持有数量来进行调度。彩票调度有很多优点：首先，它很灵活，系统增加分给某个进程的彩票数量，就会大大增加它占用资源的可能性，可以说，彩票调度的反应是迅速的，而快速响应需求正是交互式系统的一个重要要求。其次，彩票调度算法中，进程可以交换彩票，这个特点可以更好的保证系统的平衡性，使其各个部分都尽可能的处于忙碌状态。而且利用彩票调度还可以解决许多别的算法很难解决的问题，例如可以根据特定的需要大致成比例的划分CPU的使用。速率单调调度速率单调调度算法是一种可适用于可抢占的周期性进程的经典静态实时调度算法。当实时系统中的进程满足：每个周期性进程必须在其周期内完成，且进程之间没有相互依赖的关系，每个进程在一次突发中需要相同的CPU时间量，非周期的进程都没有最终时限四个条件时，并且为了建模方便，我们假设进程抢占即刻发生没有系统开销，可以考虑利用速率单调算法。速率单调调度算法是将进程的速率（按照进程周期所算出的每秒响应的次数）赋为优先级，则保证了优先级与进程速率成线性关系，这即是我们所说的速率单调。调度程序每次运行优先级最高的，只要优先级较高的程序需要运行，则立即抢占优先级低的进程，而优先级较低的进程必须等所有优先级高于它的进程结束后才能运行。速率单调调度算法可以保证系统中最关键的任务总是得到调度，但是缺点是其作为一种静态算法，灵活性不够好，当进程数变多，系统调度变得复杂时，可能不能较好的保证进程在周期内运行。最早最终时限优先调度最早最终时限优先调度算法是一个动态算法，不要求进程是周期性的，只要一个进程需要CPU时间，它就宣布它的到来时间和最终时限。调度程序维持一个可运行的进程列表，按最终时限排序，每次调度一个最终时限最早的进程得到CPU 。当新进程就绪时，系统检查其最终时限是否在当前运行的进程结束之前，如果是，则抢占当前进程。由于是动态算法，最早最终优先调度的优点就是灵活，当进程数不超过负载时，资源分配更优，但也同样由于它的动态属性，进程的优先级都是在不断变化中的，所以也没有哪个进程是一定可以保证满足调度的，当进程数超过负载时，资源分配合理度会急速下降，所以不太稳定。
㈧ 操作系统-cpu调度算法设计
对等动态优先权算法，进程调度过程掌握情况；考查学生的写算法和编程能力等；考查学生的分析问题和解决问题的能力；实验报告的撰写能力等。 设计思路： （1）先对就绪队列，阻塞队列，cpu的进行初始化。 （2）进行进程调度的选择。 1）cpu，就绪...
㈨ CPU进程调度算法
进程调度源程序如下：
jingchendiao.cpp
#include "stdio.h"
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb { /* 定义进程控制块PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct pcb PCB;
sort() /* 建立对进程进行优先级排列函数*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/
{
p->link=ready;
ready=p;
}
else /* 进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/
{ /*插入到当前进程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /* 插入进程优先数最低,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
}
}
input() /* 建立进程控制块函数*/
{
int i,num;
clrscr(); /*清屏*/
printf("\n 请输入进程号?");
scanf("%d",&num);
for(i=0;i<num;i++)
{
printf("\n 进程号No.%d:\n",i);
p=getpch(PCB);
printf("\n 输入进程名:");
scanf("%s",p->name);
printf("\n 输入进程优先数:");
scanf("%d",&p->super);
printf("\n 输入进程运行时间:");
scanf("%d",&p->ntime);
printf("\n");
p->rtime=0;p->state='w';
p->link=NULL;
sort(); /* 调用sort函数*/
}
}
int space()
{
int l=0; PCB* pr=ready;
while(pr!=NULL)
{
l++;
pr=pr->link;
}
return(l);
}
disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/
{
printf("\n qname \t state \t super \t ndtime \t runtime \n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}
check() /* 建立进程查看函数 */
{
PCB* pr;
printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/
disp(p);
pr=ready;
printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
{
printf("\n 进程 [%s] 已完成.\n",p->name);
free(p);
}
running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy(); /* 调用destroy函数*/
else
{
(p->super)--;
p->state='w';
sort(); /*调用sort函数*/
}
}
main() /*主函数*/
{
int len,h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar();
h++;
printf("\n The execute number:%d \n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n 按任一键继续......");
ch=getchar();
}
printf("\n\n 进程已经完成.\n");
ch=getchar();
}