操作系统实验一：处理器管理

 

 

 

 

 

 

操作系统实验一：处理器管理

实验报告

一、实验目的

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

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

 

二、实验要求：

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

并完成实验报告。

  

三、实验内容：

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

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

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

四、实验过程与结果

1. 算法思想与设计
2. 算法实现代码
3. 运行结果

 

调度算法：

1.RR:

1.1 算法思想：

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

1.2 算法设计：

Ø进程排序

Ø队列不为空时循环：

Ø判断是否到达

Ø剩余服务时间>时间片

Ø运行时间

Ø剩余服务时间

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

Ø运行时间

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

Ø保存

Ø从队列删除进程

 

1.3 算法实现代码

代码：

import psutil

import os

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

processA=Process('A',0,4)

processC=Process('C',2,2)

processB=Process('B',4,6)

processB.serve_time

process_list=[]

process_list.append(processA)

process_list.append(processB)

process_list.append(processC)

process_list

for p in process_list:

    print(p.name,p.arrive_time,p.serve_time)

process_list.sort(key=lambda x:x.arrive_time)

for p in process_list:

        print

 

(p.name,p.arrive_time,p.serve_time,p.left_serve_time,p.finish_time,p.cycling_time,p.w_cycling_time)

q=2

index=int(0)

running_time=int(0)

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,q)

        running_time+=q

        p.left_serve_time-=q

    else:

        print(p.name,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

(p.name,p.arrive_time,p.serve_time,p.left_serve_time,p.finish_time,p.cycling_time,p.w_cycling_time)

        pf.append(p)

        process_list.remove(p)

        index-=1

    index+=1

    if index>=len(process_list):

        index=0

 

       

1.4 运行结果

.. 

 

 

2. FCFS:

 

2.1 算法思想：

• 进程进入队列
• 设计队列并根据进程的到达时间进行输出

 

2.2 算法设计：

Ø队列不为空时循环：

Ø判断各进程的到达时间进行排序，for双循环，需要取进程长度

Ø将排序后的进程放入队列

Ø判断到达时是否上一进程完成，如完成则执行此次到达的进程，否则继续进程上一进程待其完成后才执行此次进程。

Ø输出进程名、进程开始时间、执行时间、剩余服务时间、完成时间、周转时间、加权周转时间

Ø保存

Ø从队列删除进程

 

 

2.3 算法实现代码

 

 

 

 

2.4 运行结果

 

 

 

3.SJF

3.1 算法思想：

• 进程进入队列
• 根据进程的最短剩余时间进行队列排序

 

3.2 算法设计：

Ø队列不为空时循环：

Ø按照到达时间进行排序

Ø先执行第一次到的进程

Ø在第二个进程进入时，判断前一个的剩余服务时间是否大于下第二个进程的剩余服务时间。

   若大于则执行第二个进程，若小于则继续执行第一个进程。之后每个进程的进入都与前面的进程的剩余服务时间比较。

Ø每个进程完成时输出进程名、进程开始时间、执行时间、剩余服务时间、完成时间、周转时间、加权周转时间

Ø保存

Ø从队列删除进程

 

3.3 算法实现代码

 

 

 

3.4 运行结果