操做系统实验一：处理器调度算法的实现

 

（1）加深对处理机调度的做用和工做原理的理解。

（2）进一步认识并发执行的实质。

 

2、实验要求：

本实验要求用高级语言，模拟在单处理器状况下，采用多个调度算法，对N个进程进行进程调度。语言自选。

并完成实验报告。

  

3、实验内容：

在采用多道程序设计的系统中，每每有若干个进程同时处于就绪状态。

当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

1. 进程及进程队列的表示。
2. 处理器调度算法：FCFS，SJF，RR，HRRN，MLFQ等
3. 跟踪进程状态的转化
4. 输出：系统中进程的调度次序，计算CPU利用率，平均周转时间和平均带权周转时间

4、实验过程与结果

　　1.先来先服务调度算法（FCFS）

　　　　1.1算法思想

　　　　　　该算法采用非剥夺策略，算法按照进程提交或进程变为就绪状态的前后次序，分派 CPU。当前进程占用CPU，直到执行完或阻塞，才出让CPU（非抢占方式）。在进程唤醒后（如I/O 完成），并不当即恢复执行，一般等到当前进程出让CPU。这是最简单的调度算法，比较有利于长进程，而不利于短进程，有利于CPU 繁忙的进程，而不利于I/O 繁忙的进程。

　　　　1.2算法设计

　　　　1.3算法实现代码

class Process: def __init__ (self,name,arrive_time,serve_time): self.name=name self.arrive_time=arrive_time #进入进程顺序
        self.serve_time=serve_time      #服务时间
        self.finish_time=0      #完成时间
        self.cycling_time=0     #周转时间
 self.w_cycling_time=0   #带权周转时间
process_list=[] running_time=0 A = Process('A',5,4) B = Process('B',4,3) C = Process('C',3,4) D = Process('D',1,2) E = Process('E',2,4) process_list.append(A) process_list.append(B) process_list.append(C) process_list.append(D) process_list.append(E) i=int (0) p=process_list[i] y=len(process_list) print("进程进行排序") for j in range(len(process_list)-1): for k in range(len(process_list)-1): if process_list[k].arrive_time>process_list[k+1].arrive_time: text=process_list[k+1] process_list[k+1]=process_list[k] process_list[k]=text print("进程号 到达顺序 服务时间") for p in process_list: print(p.name, "\t" ,p.arrive_time,"\t" ,p.serve_time) for p in process_list: running_time +=p.serve_time p.finish_time=running_time p.cycling_time=p.finish_time-p.arrive_time p.w_cycling_time=p.cycling_time/p.serve_time print("进程号 到达时间 完成时间 周转时间 带权周转时间") for p in process_list: print(p.name ,"\t\t",p.arrive_time,"\t\t\t\t",p.finish_time,"\t\t",p.cycling_time,"\t",p.w_cycling_time)

 

　　　　1.4运行结果

　　2.短做业优先算法（SJF）

　　　　2.1算法思想

　　　　该算法也采用非剥夺策略，对预计执行时间短的进程优先分派处理机。一般后来的短进程不抢先正在执行的进程。相比FCFS 算法，该算法可改善平均周转时间和平均带权周转时间，缩短进程的等待时间，提升系统的吞吐量。缺点是对长进程很是不利，可能长时间得不到执行，且未能依据进程的紧迫程度来划分执行的优先级，以及难以准确估计进程的执行时间，从而影响调度性能。

　　　　2.2算法设计

　　　　2.算法实现代码

class Process: def __init__ (self,name,arrive_time,serve_time): self.name=name self.arrive_time=arrive_time #进入进程顺序
        self.serve_time=serve_time      #服务时间
        self.finish_time=0      #完成时间
        self.cycling_time=0     #周转时间
 self.w_cycling_time=0   #带权周转时间
process_list=[] running_time=0 A = Process('A',5,4) B = Process('B',4,3) C = Process('C',3,4) D = Process('D',1,2) E = Process('E',2,4) process_list.append(A) process_list.append(B) process_list.append(C) process_list.append(D) process_list.append(E) i=int (0) p=process_list[i] y=len(process_list) print("进程进行排序") for j in range(len(process_list)-1): for k in range(len(process_list)-1): if process_list[k].serve_time>process_list[k+1].serve_time: text=process_list[k+1] process_list[k+1]=process_list[k] process_list[k]=text print("进程调度顺序 服务时间") for p in process_list: print(p.name, "\t\t" ,p.serve_time) for p in process_list: running_time +=p.serve_time p.finish_time=running_time p.cycling_time=p.finish_time p.w_cycling_time=p.cycling_time/p.serve_time print("进程号 服务时间 周转时间 带权周转时间") for p in process_list: print(p.name ,"\t\t",p.serve_time,"\t\t",p.cycling_time,"\t",p.w_cycling_time)

 

　　　　2.4运行结果

　　3.轮转调度算法（RR）

　　　　3.1 算法思想：

　　　　CPU时间划分为时间片，例如100ms

　　　　时间片调度：调度程序每次把CPU分配给就绪队列首进程使用一个时间片，就绪队列中的每一个进程轮流地运行一个时间片。当这个时间片结束时，强迫一个进程让出处理器，让它排列到就绪队列的尾部，等候下一轮调度

　　　　3.2 算法设计：（采用描述或程序流程图）

　　　　　　Ø进程排序

　　　　　　Ø队列不为空时循环：

　　　　　　　　Ø到达？

　　　　　　　　　　Ø剩余服务时间>时间片

　　　　　　　　　　Ø运行时间

　　　　　　　　　　Ø剩余服务时间

　　　　　　　　Ø剩余服务时间<=时间片

　　　　　　　　　　Ø运行时间

　　　　　　　　　　Ø剩余服务时间、完成时间、周转时间、加权周转时间

　　　　　　　　　　Ø保存

　　　　　　　　　　Ø从队列删除进程

 

　　　　　3.3 算法实现代码

class Process: def __init__ (self,name,arrive_time,serve_time): self.name=name self.arrive_time=arrive_time self.serve_time=serve_time      #服务时间
        self.left_serve_time=serve_time     #剩余服务时间
        self.finish_time=0      #完成时间
        self.cycling_time=0     #周转时间
        self.w_cycling_time=0   #带权周转时间
process_list=[] A = Process('A',0,4) B = Process('B',1,3) C = Process('C',2,4) D = Process('D',3,2) E = Process('E',4,4) process_list.append(A) process_list.append(B) process_list.append(C) process_list.append(D) process_list.append(E) print("进程号 到达时间 服务时间") for p in process_list: print(p.name, "\t" ,p.arrive_time,"\t" ,p.serve_time) index=0 running_time=int (0) q=2 pf=[] #记录完成的进程

while len(process_list) >0: p=process_list[index] if p.arrive_time>running_time: running_time=p.arrive_time if p.left_serve_time>q: print(p.name,p.left_serve_time) running_time+=q p.left_serve_time-=q else: print("进程号 剩余服务时间") print(p.name,"\t",p.left_serve_time) running_time +=p.left_serve_time p.left_serve_time=0 p.finish_time=running_time p.cycling_time=p.finish_time-p.arrive_time p.w_cycling_time=p.cycling_time/p.serve_time print("-进程号 到达时间 服务时间 剩余服务时间") print('-',p.name,"\t",p.arrive_time,"\t",p.serve_time,"\t",p.left_serve_time ) print("\n") pf.append(p) process_list.remove(p) index -=1 index +=1
    if index >=len(process_list): index=0 print("进程号 到达时间 剩余服务时间 完成时间 周转时间 带权周转时间") for p in pf: print(p.name ,"\t",p.arrive_time,"\t\t",p.left_serve_time,"\t",p.finish_time,"\t",p.cycling_time,"\t",p.w_cycling_time)

 

　　　　　3.4 运行结果