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

 

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

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

 

二、实验要求：

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

并完成实验报告。

  

三、实验内容：

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

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

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

四、实验过程与结果

　　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 运行结果

转载于:https://www.cnblogs.com/lr-c/p/10712941.html