【操作系统实验】处理机管理（python）

实验二：处理机管理

设计程序模拟进程的轮转法调度过程。假设初始状态为：有n个进程处于就绪状态，有m个进程处于阻塞状态。采用轮转法进程调度算法、高响应比优先（HRRN）进行调度(调度过程中，假设处于执行状态的进程不会阻塞)，且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。《操作系统》课程实验教学大纲《操作系程序要求如下：《操作系统》课程实验教学大纲《操作系统》课程实验教学大纲课程名称

(1)   输出系统中进程的调度次序；《

(2)   计算CPU利用率。《操作系统》课程实验教学

#!/usr/bin/env python
#  -*- coding: utf-8 -*

'''
设计程序模拟进程的轮转法调度过程。假设初始状态为：
有n个进程处于就绪状态，有m个进程处于阻塞状态。采用轮转法进程调度算法、高响应比优先（HRRN）进行调度
(调度过程中，假设处于执行状态的进程不会阻塞)，且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。
(1)	输出系统中进程的调度次序；
(2)	计算CPU利用率。
'''

import copy
TIME_INTERVAL = 30

class process:

    def __init__(self, name = "", running_time = 0, waiting_time = 0, blocked_time = 0, priority = 0.0):
        self.name = name
        self.running_time = running_time
        self.waiting_time = waiting_time
        self.blocked_time = blocked_time
        if blocked_time > 0:
            self.waiting_time = 0
        self.priority = priority

def RR(process_, interval):
    print('')
    print("######################### RR ###################################")
    process = copy.deepcopy(process_)
    runTime = 0
    freeTime = 0
    waitingQueue = [pro for pro in process if 'blockingTime' not in pro ]
    blockQueue = [pro for pro in process if 'blockingTime' in pro]
    waitingQueue_no = [pro['id'] for pro in waitingQueue]
    blockQueue_no = [pro['id'] for pro in blockQueue]
    print('等待队列为：{}'.format(waitingQueue_no))
    print('阻塞队列为：{}'.format(blockQueue_no))
    #blockQueue.sort(key = lambda p : p['blockingTime'])

    while len(waitingQueue) > 0 or len(blockQueue)> 0:
        for pro in blockQueue.copy():
            if pro['blockingTime'] <= 0:
                print('进程{}从阻塞队列中弹出，进入等待队列'.format(pro['id']))
                blockQueue.remove(pro)
                waitingQueue.append(pro)
        if len(waitingQueue) > 0:
            currentProcess = waitingQueue[0]
        else:
            currentProcess = None

        if currentProcess != None:
            print('----------------------------------------')
            print('当前处理的进程为:')
            print(currentProcess)
            waitingQueue.remove(currentProcess)
            if (currentProcess['runningTime'] - interval) >= 0:
                currentProcess['runningTime'] = currentProcess['runningTime'] - interval
                currentProcess['waitingTime'] = 0
                runTime += interval
                for pro in waitingQueue:
                    pro['waitingTime'] += interval
                for pro in blockQueue:
                    pro['blockingTime'] -= interval
                    if pro['blockingTime'] < 0:
                        pro['waitingTime'] -= pro['blockingTime']
                        pro['blockingTime'] = 0
                print('在时间片内，进程未被处理完，重新加入等待队列')
                waitingQueue.append(currentProcess)
            else:
                print('在时间片内，进程被处理完')
                runTime += currentProcess['runningTime']
                for pro in waitingQueue:
                    pro['waitingTime'] += currentProcess['runningTime']
                for pro in blockQueue:
                    pro['blockingTime'] -= currentProcess['runningTime']
                    if pro['blockingTime'] < 0:
                        pro['waitingTime'] -= pro['blockingTime']
                        pro['blockingTime'] = 0
        else:
            tranfer_first = blockQueue[0]['blockingTime']
            freeTime += tranfer_first
            for pro in blockQueue:
                pro['blockingTime'] -= tranfer_first

    cpu = runTime / (freeTime + runTime)
    print('')
    print('cpu的利用率是：%f'%cpu)

def HRRN(process_):
    #
    print('')
    print("######################### HRRN ###################################")
    process = copy.deepcopy(process_)
    runTime = 0
    freeTime = 0
    readyQueue = [pro for pro in process if 'blockingTime' not in pro ]
    blockQueue = [pro for pro in process if 'blockingTime' in pro]
    blockQueue.sort(key=lambda p: p['blockingTime'])

    while len(readyQueue) > 0 or len(blockQueue):
        for pro in blockQueue.copy():
            if pro['blockingTime'] <= 0:
                blockQueue.remove(pro)
                readyQueue.append(pro)
        if len(readyQueue) > 0:
            for pro in readyQueue:
                pro['priority'] = (pro['waitingTime'] + pro['runningTime'])/pro['runningTime']
            currentProcess = max(readyQueue, key = lambda p : p['priority'])
        else:
            currentProcess = None
        if currentProcess != None:
            print('----------------------------------------')
            print('当前处理的进程为:')
            print(currentProcess)
            readyQueue.remove(currentProcess)

            runTime += currentProcess['runningTime']
            for pro in readyQueue:
                pro['waitingTime'] += currentProcess['runningTime']
            for pro in blockQueue:
                pro['blockingTime'] -= currentProcess['runningTime']
                if pro['blockingTime'] < 0:
                    pro['waitingTime'] -= pro['blockingTime']
                    pro['blockingTime'] = 0
            print('在时间片内，进程未被处理完，重新加入等待队列')
        else:
            print('在时间片内，进程被处理完')
            tranfer_first = blockQueue[0]['blockingTime']
            freeTime += tranfer_first
            for pro in blockQueue:
                pro['blockingTime'] -= tranfer_first

    cpu = runTime / (freeTime + runTime)
    print('')
    print('cpu的利用率是：%f' % cpu)

if __name__ == '__main__':
    process = [
        {'id': 1, 'runningTime':84, 'waitingTime':49},
        {'id': 2, 'runningTime':93, 'waitingTime':72},
        {'id': 3, 'runningTime':22, 'waitingTime':70},
        {'id': 4, 'runningTime':44, 'waitingTime':83},
        {'id': 5, 'runningTime':43, 'waitingTime':10},
        {'id': 6, 'runningTime':52, 'waitingTime':0, 'blockingTime':300},
        {'id': 7, 'runningTime':23, 'waitingTime':0, 'blockingTime':500},
        {'id': 8, 'runningTime':33, 'waitingTime':0, 'blockingTime':300},
        {'id': 9, 'runningTime':48, 'waitingTime':0, 'blockingTime':410},
        {'id': 10, 'runningTime':31, 'waitingTime':0, 'blockingTime':350}
    ]

    #轮转法
    RR(process, 30)

    #高响应比法
    HRRN(process)