页面调度算法的实验步骤

#include stdafx.h

#include conio.h

#include iostream.h

#include fstream.h

//-------------------------------Menu----------------------#define KEY_EXIT '-'

typedef struct{

char ch

char *label

void (*pfunc)()

}MenuItemDef

Void clearscr() {cout<<\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n}

int waitakey(){return getch()}

class MenuDef

{public:

int nCount

MenuItemDef menu[24]

public:

MenuDef(){nCount=0}

public:

void display()

{ for(int i=0i<nCounti++)

cout<< <<menu.ch<<.<<menu.label<<endl

cout<< <<KEY_EXIT<<.<<EXIT<<endl}

void run()

{int ch

do{clearscr()

display()

ch=waitakey()

for(int i=0i<nCounti++)

if(menu.ch==ch)

menu.pfunc()

}while(ch!=KEY_EXIT)}

void add (char ch0,char *plabel,void(*func)())

{ menu[nCount].ch=ch0

menu[nCount].label=plabel

menu[nCount].pfunc=func

nCount++}}

//--------------------------------------page-----------------------

class Page{

public:

Page(){SetNull()}

public:

enum{kLFU=0,kFCFS,kLRU}

int nCurPage

int nAlgID

int nCountPage

int pages[128]

int nCountFrame

int nEmpty

int frames[32]

int counters[32]

int nCount1

int nCount2

public:

void Input()

void Run()

int IsFinish(){return nCurPage>=nCountPage}

void SetAlgorithm(int kAlgId){nAlgID=kAlgId}

void SetNull()

{nCurPage=nCountPage=nCountFrame=nCount1=nCount2=nEmpty=0 nAlgID=kLRU}

double IPercent(){return nCount1*1.0/nCurPage}//缺页中断率

double EPercent(){return nCount2*1.0/nCurPage}//缺页转换率

//functions should be implemented......

void FCFS() {} //先来先服务调度算法

void LRU() {} //LRU调度算法

void LFU() {} //LFU调度算法

void Display() {} //系统状态

void DisplayAlg() {} //算法执行状态

public:

friend istream&operator>>(istream&stream,Page&p)

{return stream}

friend ostream&operator>>(ostream&stream,Page&p)

{return stream} }

void Page::Input()

{ cout<<Count of page-frames:

cin>>nCountFrame

nEmpty=nCountFrame

cout<<Count of page:

cin>>nCountPage

for (int i=0i<nCountPagei++)

cin>>pages

nCurPage=0

}

void Page::Run()

{ while(!IsFinish()){

waitakey()//wait for a key pressed

if(nAlgID==kLFU)

LFU()

else if(nAlgID==kFCFS)

FCFS()

else

LRU()

DisplayAlg()

nCurPage++}}

//------------global variables-----------------

MenuDef menu

Page page

//------------call-back functions for menu-------

void input()

{ clearscr()

page.SetNull()

page.Display()}

void display()

{ clearscr()

page.Display()}

void setalg1()

{ page.SetAlgorithm(Page::kLFU)}

void setalg2()

{ page.SetAlgorithm(Page::kFCFS)}

void setalg3()

{ page.SetAlgorithm(Page::kLRU)}

void run()

{ clearscr()

page.Run()}

void load()

{ char fname[128]

cout<<\nLoad From file:

cin>>fname

ifstream inFile

inFile.open(fname)

page.SetNull()

inFile>>page}

void save()

{ char fname[128]

cout<<\nSave to file:

cin>>fname

ofstream outFile

outFile.open(fname)

outFile>>page}

void main(int args,char *argv[])

{ menu.add('1',Input from keyboard, input)

menu.add('3',Set Algorithm1:LFU,setalg1)

menu.add('4',Set Algorithm2:FCFS, setalg2)

menu.add('5',Set Algorithm3:LRU, setalg3)

menu.add('6',Display, display)

menu.add('7',Run, run)

menu.add('8',Load from file, load)

menu.add('9',Save to file, save)

menu.run()}

c语言实现的页面调度算法,用三种算法实现调度1.先进先出2.OPT3.LRU 2.页面序列从指定的文本文件（TXT文件）中取出3.输出：第一行：每次淘汰的页面号 第二行：显示缺页的总次数(上机已经运行通过!!)-pages scheduling algorithm, a three-Scheduling Algorithm 1. FIFO 2.OPT3.LRU 2. Pages from the designated sequence of text files (TXT) out of three. Output : the first line : each of the pages out of the second line : show na the total number of pages (on the plane had run through! !)

例题：有以下的进程需要调度执行(见表2-5)：

表2-5　进程调度

进程名 到达时间 运行时间

P1 0.0 9

P2 0.4 4

P3 1.0 1

P4 5.5 4

P5 7 2

1)如果用非抢占式短进程优先调度算法，请问这5个进程的平均周转时间是多少

2)如果采用抢占式短进程优先调度算法，请问这5个进程的平均周转时间是多少

A．8.62；6.34

B．8.62；6.8

C．10.62；6.34

D．10.62；6.8

非抢占式：

进程名 到达时间运行时间开始时间结束时间周转时间

P1 0.0 9 0.0 9.0 9

P2 0.4 4 12.016.015.6

P3 1.0 1 9.0 10.09

P4 5.5 4 16.020.014.5

P5 7 2 10.012.05

平均周转时间为(9+15.6+9+14.5+5)/5=10.62

抢占式：

进程名 到达时间 运行时间 开始时间 结束时间 周转时间

Pl 0.0 9 0.0 20.020

P20.4 4 0.4 5.4 5

P31.0 1 1.0 2.0 1

P45.5 4 5.5 11.56

P572 7.0 9.0 2

平均周转时间为(20+5+1+6+2)/5=6.8

因此答案选D

这个优先级可以描述为: 优先级 = (作业已等待时间 + 作业的服务时间) / 作业的服务时间

从上式可以看到，作业的服务时间是固定的， 优先级随着已等待时间的提高而变大 。（我这人很公平的，每执行一轮我都看看下一轮谁最应该被执行）

(1) 应设置多个就绪队列，并为各个队列赋予不同的优先级。第一个队列的优先级最高，第二个队列次之，其余各队列的优先权逐个降低。该算法赋予各个队列中进程执行时间片的大小也各不相同，在优先权愈高的队列中，为每个进程所规定的执行时间片就愈小。例如，第二个队列的时间片要比第一个队列的时间片长一倍，……，第i+1个队列的时间片要比第i个队列的时间片长一倍。

(2) 当一个新进程进入内存后，首先将它放入第一队列的末尾，按FCFS原则排队等待调度。当轮到该进程执行时，如它能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列，……，如此下去，当一个长作业(进程)从第一队列依次降到第n队列后，在第n 队列便采取按时间片轮转的方式运行。

(3) 仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第1～(i-1)队列均空时，才会调度第i队列中的进程运行。如果处理机正在第i队列中为某进程服务时，又有新进程进入优先权较高的队列(第1～(i-1)中的任何一个队列)，则此时新进程将抢占正在运行进程的处理机，即由调度程序把正在运行的进程放回到第i队列的末尾，把处理机分配给新到的高优先权进程。

多级反馈队列调度算法体现了计算思维的调度特点，应用了先来先服务原则、应用时间片等做法使得每个申请者都能及时使用资源，是一种很好的协调整体的解决方案。 （我喜欢你，因此把你的事放在第一队列，但我也有其他的事，不能一直帮你做事。帮你做了一段时间就得把你放到第二队列队尾去。等我把所有第一队列的事都做完了，到了第二队列轮到你了再帮你做，这次要比第一队列做的更长一点。如果这段时间内还是做不完，那就得把你放到第三队列的队尾了，依次类推）

注：在队列中是按照先来先服务的原则

进程间通信主要包括管道, 系统IPC(包括消息队列,信号量,共享存储), SOCKET.

管道包括三种:

1)普通管道PIPE, 通常有种限制,一是半双工,只能单向传输二是只能在父子进程间使用.

2)流管道s_pipe: 去除了第一种限制,可以双向传输.

3)命名管道:name_pipe, 去除了第二种限制,可以在许多并不相关的进程之间进行通讯.

系统IPC的三种方式类同,都是使用了内核里的标识符来识别.

当没有足够的物理内存的时候，系统通过把进程的一部分转移到硬盘上以设法容纳进程，当再次需要进程中被转移到硬盘中的那一部分时，再返回到物理内存中，这个过程就被称为页面调度。 它使得系统在有限的物理内存环境下也能具备多任务处理的能力 。

1 .理想页面置换算法(OPT):

这是一种理想的算法，在实际中不可能实现。

该算法的思想是：发生缺页时，所调出的页应该是以后不再访问的页(永远不会再使用)或最长时间内不再被访问的内存页面(距当前最长时间后再访问的页)予以淘汰。

2.先进先出页面置换算法(FIFO)：

即字面意思很好理解，当发生缺页时，把先进来的先淘汰。

思路：选择最先进入内存的页面予以淘汰。

线程的实现可分为两大类，用户级线程（user-levelthread，ULT）和内核级线程（kernel-levelthread，KLT）。后者又称为内核支持的线程或轻量级进程。

https://blog.csdn.net/weixin_42229896/article/details/80667187?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param

---