操作系统课设进程调度模拟程序

目 录 进程调度模拟程序 ....................................... 1 一．设计目的及要求 ..................................... 1 二．概要设计 ........................................... 1 三．算法流程图 ......................................... 2 四．源程序及注释 ....................................... 6 五．运行结果及分析 .................................... 16 六．课程设计总结 ...................................... 19 七．参考文献 .......................................... 19 沈阳理工大学 沈阳理工大学课程设计专用纸 No1

进程调度模拟程序 一．设计目的及要求 编写一个进程调度程序，允许多个进程并行执行。本次设计将采用三种算法实现进程 的并行执行，分别是最高优先数优先的调度算法（即把处理机分配给优先数最高的进程） 、先来先服务算法、按时间片轮转调度算法。 二．概要设计 ① 每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、 优先数、到达时间、需要运行时间、已用CPU时间、进程状态。 ② 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程 的到达时间为输入进程的时间。进程的运行时间以时间片为单位进行计算。 ③ 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状 态之一。 ④ 建立一个pcbobj[]的数组来存放进程队列。 建立一个类pcbobj存放进程的各种信息并对这些信息的操作。 建立一个类wait_manager 来对就绪进程进行管理。 建立一个类cpu_manager 来对运行的进程进行管理。 沈阳理工大学 沈阳理工大学课程设计专用纸 No2

三．算法流程图

开始 初始化进程信息 N FCFS算法 N RR算法 N HPF算法 Y 调用HPF算法 Y 调用RR算法 Y 调用FCFS算法 结束 图1－1 主程序流程图

沈阳理工大学

沈阳理工大学课程设计专用纸 No3

start 更新进程信息 信息初始化 N 进程调度完毕 打印进程状态 N 就绪队列不为空&&cpu空闲 Y 输出该时刻的进程状态表 Y 将就绪队列的第一个进程给cpu End N Cpu为busy态 Y 更新运行的进程信息 Y 运行进程运行完毕 Cpu.remove() 时间记录加一

图1－2 FCFS算法流程图

沈阳理工大学

沈阳理工大学课程设计专用纸 No4

start 更新进程信息 信息初始化 N 进程调度完毕 打印进程状态 就绪队列不为空&&cpu空闲 N Y 输出该时刻的进程状态表 Y 将就绪队列的第一个进程给cpu End N Cpu为busy态 Y 更新运行的进程信息 进程时间加一 Y 运行进程运行完毕 N 是否超时 Cpu.remove() 进程时间清零 Y 进程加到就绪队列 进程时间清零 N 时间记录加一 图1－3 RR算法流程图

沈阳理工大学

沈阳理工大学课程设计专用纸 No5

start 更新进程信息 信息初始化 N 进程调度完毕 打印进程状态 就绪队列不为空&&cpu空闲 N Y 输出该时刻的进程状态表 Y 将就绪队列的第一个进程给cpu End N Cpu为busy态 Y 更新运行的进程信息 N 运行进程运行完毕 进程加到就绪队列 Y 记录进程临时信息 Cpu.remove() 时间记录加一 图1－4 HPF算法流程图

沈阳理工大学

沈阳理工大学课程设计专用纸 No6

四．源程序及注释

----------------------------------------------pcbobj.h --------------------------------------------- #include using namespace std; #ifndef PCBOBJ_H_ #define PCBOBJ_H_

enum pStatus{Wait,Run,Finish,UNGO};//定义进程的四种状态 class PCBobj { public: PCBobj(); PCBobj(string name,int id,int reach,int execute); virtual ~PCBobj();

int getExecTime() const; int getHasExecTime() const; int getId() const;

int getReachTime() const; string getName() const; pStatus getStatus() const;

void setHasExecTime(int hasExecTime); void setId(int pId);

void setStatus(pStatus status); void setExecTime(int execTime); void setName(string pName);

void setReachTime(int reachTime); bool isFinish();//进程是否运行完毕

bool last_statu;//判断进程上一个cpu是否是运行态 private:

string pName; //进程名 int pId; //进程优先数

int reachTime; //进程到达时间

int execTime; //进程需要运行的时间

int hasExecTime; //进程已经运行 的 时间 pStatus status; };

typedef PCBobj *pcbobj; #endif /* PCBOBJ_H_ */

-------------------------------------------pcbobj.cpp代码------------------------------------------------ #include \"PCBobj.h\" PCBobj::PCBobj() { hasExecTime=0; status=UNGO;

沈阳理工大学

沈阳理工大学课程设计专用纸 No7

last_statu=false; }

PCBobj::PCBobj(string name,int id,int reach,int execute){ pName=name; pId=id; reachTime=reach; execTime=execute; hasExecTime=0; status=UNGO; }

PCBobj::~PCBobj() {}

int PCBobj::getExecTime() const{ return execTime; }

int PCBobj::getHasExecTime() const{ return hasExecTime; }

int PCBobj::getId() const{ return pId; }

string PCBobj::getName() const{ return pName; }

int PCBobj::getReachTime() const{ return reachTime; }

pStatus PCBobj::getStatus() const{ return status; }

void PCBobj::setHasExecTime(int hasExecTime){ this->hasExecTime = hasExecTime; }

void PCBobj::setId(int pId){ this->pId = pId; }

void PCBobj::setStatus(pStatus status){ this->status = status; }

void PCBobj::setExecTime(int execTime){ this->execTime = execTime; }

void PCBobj::setName(string pName){ this->pName = pName;

沈阳理工大学

沈阳理工大学课程设计专用纸 No8

}

void PCBobj::setReachTime(int reachTime){ this->reachTime = reachTime; }

bool PCBobj::isFinish(){ bool Flag=false; if(execTime == hasExecTime){ status=Finish; Flag=true; } return Flag; }

-----------------------------------------------waitmanager.h------------------------------ #include #include

#include\"PCBobj.h\"

#ifndef WAITMANAGER_H_ #define WAITMANAGER_H_ class WaitManager { public: WaitManager(); virtual ~WaitManager(); void add(pcbobj new_obj); void insert(pcbobj new_name); void remove(string name); void remove(); bool empty(); pcbobj get(); pcbobj last(); private: list wait_PCB_list; };

#endif /* WAITMANAGER_H_ */

-------------------------------------------waitmanager.cpp----------------------------------- #include \"WaitManager.h\"

WaitManager::WaitManager() {} WaitManager::~WaitManager() {}

void WaitManager::add(pcbobj new_obj){ wait_PCB_list.push_back(new_obj); new_obj->setStatus(Wait); }

bool WaitManager::empty(){ return wait_PCB_list.empty();

沈阳理工大学

沈阳理工大学课程设计专用纸 No9

}

void WaitManager::insert(pcbobj new_obj){ if(wait_PCB_list.empty()) { add(new_obj); }else{ bool insert_info=false;//查看是否已经插入进去 for(list::iterator it=wait_PCB_list.begin();it!=wait_PCB_list.end();it++){ if(new_obj->getId()>(*it)->getId()){ wait_PCB_list.insert(it,new_obj); new_obj->setStatus(Wait); insert_info=true; break; } } if(!insert_info){ wait_PCB_list.push_back(new_obj); new_obj->setStatus(Wait); } } }

void WaitManager::remove(string name){ if(empty()){ cout<<\"没有进程在就绪队列中\"<::iterator it=wait_PCB_list.begin();it!=wait_PCB_list.end();it++){ if((*it)->getName() == name){ wait_PCB_list.erase(it); remove_info=true; break; } } if(!remove_info){ cout<void WaitManager::remove(){ if(empty()){ cout<<\"没有就绪进程在队列中\"<沈阳理工大学

沈阳理工大学课程设计专用纸 No10

{ wait_PCB_list.pop_front(); } }

pcbobj WaitManager::get(){ return wait_PCB_list.front(); }

pcbobj WaitManager::last(){ return wait_PCB_list.back(); }

------------------------------------------------------cpumanager.h---------------------- #include \"PCBobj.h\"

#ifndef CPU_MANAGER_H_ #define CPU_MANAGER_H_

enum cpu_Status{FREE,BUSY};//cpu的状态 class cpu_Manager { public: cpu_Manager(); virtual ~cpu_Manager(); void remove();

cpu_Status getCpu_info() const; pcbobj getCpu_pcb() const; void add(pcbobj cpu_pcb); void update();

void update(int args); int cpu_timeslice; private: cpu_Status cpu_info; pcbobj cpu_pcb; };

#endif /* CPU_MANAGER_H_ */

---------------------------------------------------cpumanager.cpp-------------------- #include \"cpu_Manager.h\"

cpu_Manager::cpu_Manager() { cpu_pcb=0; cpu_info=FREE; cpu_timeslice=4; }

cpu_Manager::~cpu_Manager() { cpu_pcb=0; }

cpu_Status cpu_Manager::getCpu_info() const{ return cpu_info;

沈阳理工大学

沈阳理工大学课程设计专用纸 No11

}

pcbobj cpu_Manager::getCpu_pcb() const{ return cpu_pcb; }

void cpu_Manager::add(pcbobj cpu_pcb1){ cpu_pcb = cpu_pcb1; cpu_info=BUSY; }

void cpu_Manager::remove(){ this->cpu_pcb=0; cpu_info=FREE; }

void cpu_Manager::update(){ cpu_pcb->setStatus(Run); cpu_pcb->setHasExecTime( cpu_pcb->getHasExecTime()+1); }

void cpu_Manager::update(int args){ update(); cpu_pcb->setId(cpu_pcb->getId()- args); }

---------------------------------------------------- schedul_simulate.h----------------- #include \"WaitManager.h\" #include \"cpu_Manager.h\"

#ifndef SCHEDUL_SIMULATE_H_ #define SCHEDUL_SIMULATE_H_ void choice();

string convert_statu(pStatus statu); void process_init(pcbobj process);

void process_update(pcbobj process,int time_record,WaitManager& wait_manager); void process_update_id(pcbobj process,int time_record,WaitManager& wait_manager); //--------打印进程信息---------------

void process_record(pcbobj process,int time_record); //----------从wait到run------------

void waitTOrun(WaitManager& wait_manager,cpu_Manager& cpu_manager); void runTOwait(WaitManager& wait_manager,cpu_Manager& cpu_manager); void FCFS(pcbobj process); void RR(pcbobj process); void HPF(pcbobj process);

#endif /* SCHEDUL_SIMULATE_H_ */

------------------------------------------- schedul_simulate.cpp------------------------------- #include\"schedul_simulate.h\" void choice(){

沈阳理工大学

沈阳理工大学课程设计专用纸 No12

cout<<\"1:FCFS\"<string convert_statu(pStatus statu) { string value = \"UNGO\"; switch (statu) { case Wait: value = \"Wait\"; break; case Run: value = \"Run\"; break; case Finish: value = \"Finish\"; break; case UNGO: value = \"UNGO\"; } return value; }

void process_init(pcbobj process) { string name; int process_id; int process_reach; int process_execute; cout << \"请按顺序输入进程的唯一标识---进程名 进程的优先级 进程的到达时间 进程的运行时间\" << endl; for (int i = 0; i < 4; i++) { //process里的hasExecTime和status已经被初始化 cout << \"请输入第\" << (i + 1) << \"个进程的信息\" << endl; cin >> name; cin >> process_id; cin >> process_reach; cin >> process_execute; (process + i)->setName(name); (process + i)->setId(process_id); (process + i)->setReachTime(process_reach); (process + i)->setExecTime(process_execute); cout << \"第\" << (i + 1) << \"个进程信息已经初始化\" << endl; } cout << \"所有进程信息已经全部完成\" << endl;

沈阳理工大学

沈阳理工大学课程设计专用纸 No13

}

void process_update(pcbobj process, int time_record, WaitManager& wait_manager) { for (int i = 0; i < 4; i++) { if ((process + i)->getReachTime() == time_record) { wait_manager.add((process + i));//直接加到末尾 } } }

void process_update_id(pcbobj process, int time_record, WaitManager& wait_manager) { for (int i = 0; i < 4; i++) { if ((process + i)->getReachTime() == time_record) { wait_manager.insert((process + i)); } } }

void process_record(pcbobj process,int time_record) { cout << \"时刻:\" << time_record << endl; cout << \"进程名\优先数\到达时间\运行时间\已经运行时间\状态\" << endl; cout << \"----------------------------------------------------------\" << endl; for (int i = 0; i < 4; i++) { cout << (process + i)->getName() << \"\\" << (process + i)->getId() <<\"\\" << (process + i)->getReachTime() << \"\\" << (process + i)->getExecTime() << \"\\" << (process + i)->getHasExecTime() << \"\\\"; if((process+i)->last_statu) cout<< convert_statu(Run) << endl; else cout<getStatus())<last_statu=false; } cout << \"----------------------------------------------------------\" << endl; }

void waitTOrun(WaitManager& wait_manager, cpu_Manager& cpu_manager) { cpu_manager.add(wait_manager.get()); wait_manager.remove(); }

void runTOwait(WaitManager& wait_manager, cpu_Manager& cpu_manager) { pcbobj temp=cpu_manager.getCpu_pcb();

沈阳理工大学

沈阳理工大学课程设计专用纸 No14

temp->last_statu=true; wait_manager.add(temp); }

void FCFS(pcbobj process) { int time_record = 0; PCBobj *process_last = process + 3; WaitManager wait_manager; cpu_Manager cpumanager; while (process_last->getStatus() != Finish) { process_update(process,time_record,wait_manager); process_record(process,time_record); if (!wait_manager.empty() && cpumanager.getCpu_info() == FREE){ waitTOrun(wait_manager, cpumanager); } if (cpumanager.getCpu_info() == BUSY){ cpumanager.update(); if(cpumanager.getCpu_pcb()->isFinish()) cpumanager.remove(); } time_record++; if (process_last->getStatus() != UNGO && !wait_manager.empty())//已经到达{ process_last = wait_manager.last(); } } process_record(process,time_record); }

void RR(pcbobj process) { int time_record = 0; PCBobj *process_last = process + 3; WaitManager wait_manager; cpu_Manager cpumanager; int k=0;//记录时间片 满则为零 while (process_last->getStatus() != Finish) { process_update(process,time_record,wait_manager); process_record(process,time_record); if (!wait_manager.empty() && cpumanager.getCpu_info() == FREE){ waitTOrun(wait_manager, cpumanager); } if (cpumanager.getCpu_info() == BUSY){ cpumanager.update(); k++; if (cpumanager.getCpu_pcb()->isFinish()){ cpumanager.remove();

沈阳理工大学

沈阳理工大学课程设计专用纸 No15

k=0; }else if(k>=cpumanager.cpu_timeslice){ runTOwait(wait_manager,cpumanager); cpumanager.remove(); k=0; } } time_record++; if (process_last->getStatus() != UNGO && !wait_manager.empty())//已经到达{ process_last = wait_manager.last(); } } process_record(process,time_record); }

void HPF(pcbobj process) { int time_record = 0; PCBobj *process_last = process + 3; WaitManager wait_manager; cpu_Manager cpumanager; pcbobj temp; while (process_last->getStatus() != Finish) { process_update_id(process,time_record,wait_manager); process_record(process,time_record); if (!wait_manager.empty() && cpumanager.getCpu_info() == FREE){ waitTOrun(wait_manager, cpumanager); } if (cpumanager.getCpu_info() == BUSY){ cpumanager.update(1); if (!cpumanager.getCpu_pcb()->isFinish()) { temp=cpumanager.getCpu_pcb(); temp->last_statu=true; wait_manager.insert(temp); } cpumanager.remove(); } time_record++; if (process_last->getStatus() != UNGO && !wait_manager.empty())//已经到达{ process_last = wait_manager.last(); } } process_record(process,time_record); }

------------------------------------------------------main.cpp------------------------------------

沈阳理工大学

沈阳理工大学课程设计专用纸 No16

#include\"schedul_simulate.h\" int main() { int you_choice; PCBobj obj[4]; process_init(&obj[0]); choice(); bool start_app=true; while(start_app){ cin>>you_choice; switch(you_choice) { case 1: FCFS(&obj[0]); break; case 2: RR(&obj[0]); break; case 3: HPF(&obj[0]); break; case 4: start_app=false; } } return 0; }

五．运行结果及分析

图1－5 进程信息初始化

沈阳理工大学

沈阳理工大学课程设计专用纸 No17

图1－6 选择时间片算法调度

图1－7 开始只有a进程进入就绪队列，运行a进程

图1－8 a运行完毕，b,c都已经到达，此时运行b进程

沈阳理工大学

沈阳理工大学课程设计专用纸 No18

图1－9 b运行完毕时，此时c,d都已经完成，运行c进程

沈阳理工大学

沈阳理工大学课程设计专用纸 No19

图1－10 c的时间片已经完成，将c放入到就绪队列，d进程开始运行

图1－11 d运行完毕 继续运行c进程,直到运行完毕

六．课程设计总结

通过这次操作系统的课程设计，我研究了进程调度的相关知识。课程设计和平时的实验课比较起来有很大的差距，实验课只是将这一章的一部分内容练习操作一遍，而课程设计需要的是他们综合起来的东西，这要更难一些。

总体来说我认为操作系统这门学科在计算机科学当是中非常重要的。这次操作系统的课程设计收获颇丰，复习了许多东西，也从新学会了许多东西。我想这也许就是课程设计的最终目的吧。

七．参考文献

[1]刘振安、刘燕君著.《C++程序设计课程设计》.北京: 机械工业出版社，2004

[2][美]Abraham Silberschatz, Peter Baer Galvin, Greg Gagne 著. 郑扣根 译. 操作系统概念（第六版）. 北京： 高等教育出版社，2004

[3]陈向群，向勇 等. Windows操作系统原理（第二版）. 北京：机械工业出版社，2004.

沈阳理工大学