操作系统实验python

操作系统实验

1、将一组进程分为4类，如图所示，各类进程之间采用优先级调度，各类进程内部采用时间片轮转调度。请设计程序实现P1、P2、P3、P4、P5、P6、P7、P8进程的调度。

具体做法是调度程序每次把CPU分配给当前最高优先级进程使用一个时间片。 当这个时间片结束时，强迫该进程让出处理器，进行下一轮优先级调度，直至就绪队列中所有进程都运行完成为止。

代码:

import time


class PCB:

    def __init__(self, priority, hold_time, come_time, name, status=0):
        """
        :param status: PCB 进程控制块状态：0为等待态， 1为执行态
        :param priority: 优先级别：0， 1， 2， 3， 4， ...
        :param hold_time: 处理机占用时间
        :param come_time: 进入进程队列时间
        """
        self.status = status
        self.priority = priority
        self.hold_time = hold_time
        self.come_time = come_time
        self.progress_name = name

    def __str__(self):
        return str(self.progress_name) + "\t" + str(self.priority) + "\t\t\t" + \
               str(self.come_time) + "\t\t\t" + str(self.hold_time) + "\t\t\t\t" + \
               str('就绪态' if self.status == 0 else '执行态')


class PriorityAlgorithm:

    def __init__(self):
        self.progresses = []
        self.__progresses_in()
        self.max_index = -1

    def __progresses_in(self):
        self.progresses.append(PCB(4, 5, 0, "P1"))
        self.progresses.append(PCB(4, 3, 0, "P2"))
        self.progresses.append(PCB(4, 2, 0, "P3"))
        self.progresses.append(PCB(3, 5, 0, "P4"))
        self.progresses.append(PCB(3, 1, 0, "P5"))
        self.progresses.append(PCB(2, 8, 0, "P6"))
        self.progresses.append(PCB(2, 6, 0, "P7"))
        self.progresses.append(PCB(2, 6, 0, "P8"))

    def print_all_progresses(self):
        print("当前队列中就绪的进程有：")
        print(str('name') + "\t" + str('priority') + "\t" + \
              str('come_time') + "\t" + str('execute_time') + "\t" + \
              str('status'))
        for i in range(len(self.progresses)):
            print(self.progresses[i])

    def execute_progress(self):
        while len(self.progresses) > 0:
            for i in range(len(self.progresses)):
                self.max_index = self.get_max_priority_index()
                self.progresses[self.max_index].hold_time -= 1
                if self.progresses[self.max_index].hold_time <= 0:
                    print("进程", self.progresses[self.max_index].progress_name, "执行完毕")

                    self.progresses.remove(self.progresses[self.max_index])

                self.print_all_progresses()
                time.sleep(1)
            self.__change_priority()
            print("===============================一次时间片轮回后结果：================================")
            self.print_all_progresses()
            time.sleep(1)

    def get_max_priority_index(self):
        max_index = 0
        for i in range(len(self.progresses)):
            if self.progresses[i].priority > self.progresses[max_index].priority:
                max_index = i
        self.progresses[max_index].priority = self.progresses[max_index].priority - 10
        return max_index

    def __change_priority(self):
        for i in range(len(self.progresses)):
            self.progresses[i].priority += 10


if __name__ == "__main__":
    priority = PriorityAlgorithm()
    print("初始化队列进程：===================================")
    priority.print_all_progresses()
    print("===================end============================")
    priority.execute_progress()

截图:

2、在采用页式存储管理的系统中，规定页长为1024字节,某进程页表的一部分如表

页号 块号
… …
24 121
21 63
70 16
34 81
请设计一个页地址转换程序，求出有效地址21996所对应的物理地址。

思路:
根据页面大小可计算出页内地址的位数
页内地址位数结合逻辑地址计算出页内地址（即，块内地址）和页号
页号结合页表，即可得出块号
块号&块内地址即可得出物理地址

代码:

class LogicAddress:
    address_dict = {24: 121, 21: 63, 70: 16, 34: 81}

    def __init__(self, address):
        self.a = bin(address)
        self.W = self.a[-10:]  # 页内地址
        self.P = int(self.a[self.a.index('b') + 1:-10], 2)  # 页号
        self.B = 0  # 块号
        self.physic_address = 0

    def to_physic(self):
        self.B = self.address_dict[self.P]
        self.physic_address = bin(self.B) + self.W
        return int(self.physic_address, 2)


if __name__ == '__main__':

    l = LogicAddress(21996)

    print(l.to_physic())

截图:

3、已知某进程用分段存储管理，段表如下。段号为3，段内位移量为149。请设计程序首先判断段是否越界，没有越界求出这两个逻辑地址对应的物理地址。

段号 段长 基址
0 1079 4631
1 321 1057
2 102 86
3 176 725
4 232 254

思路:
逻辑地址----- >段号、段内页号、业内地址
段表寄存器— >段表始址
段号+段表始址---- >页表始址
页表始址+段内页号----->存储块号
块号+页内地址------>物理地址

代码:

class SegmentTable:
    table = [[0, 1079, 4631], [1, 321, 1057], [2, 102, 86], [3, 176, 725], [4, 232, 254]]

    def __init__(self, id, address):
        self.id = id
        self.address = address
        for i in self.table:
            if i[0] == id:
                if i[1] <= address:
                    print("段越界")
                else:
                    self.address = i[2] + address

    def physic_address(self):
        return self.address


if __name__ == '__main__':
    s = SegmentTable(3, 149)

    print(s.physic_address())

截图:

4、在一个请求页式存储管理系统中，一个程序的页面走向依次为2，3，2，6，7，3，5，4，1。设分配给该程序的主存物理块为4块。请设计程序求出FIFO先来先服务算法在访问过程中页面置换及缺页情况。

思路:
最简单的页面置换算法是先入先出(FIFO)法。这种算法的实质是，总是选择在主存中停留时间最长(即最老)的一页置换，即先进入内存的页，先退出内存。理由是:最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。建立一个FIFO队列，收容所有在内存中的页。被置换页面总是在队列头上进行。当一个页面被放入内存时，就把它插在队尾上。

代码:

class Queue:
    def __init__(self):
        self.list = []
        self.miss = 0

    def enqueue(self, item):
        print("页表添加", item)
        self.list.insert(0, item)

    def dequeue(self):
        item = self.list.pop()
        print(" 页表移除", item, end="")
        return item

    def number(self):
        return len(self.list)

    def is_in_queue(self, item):
        for i in self.list:
            if i == item:
                return True
        self.miss += 1
        print("发生缺页中断 ", end="")
        return False

    def read(self, item):
        print("访问", item)


if __name__ == '__main__':
    pages = [2, 3, 2, 6, 7, 3, 5, 4, 1]

    q = Queue()

    for i in pages:
        if q.is_in_queue(i):
            q.read(i)
        elif q.number() < 4:
            q.enqueue(i)
            q.read(i)
        else:
            q.dequeue()
            q.enqueue(i)
            q.read(i)
    print("缺页中断共发生", q.miss, "次")

截屏:

5、有一组磁道访问请求，需要访问的磁道号为：12、177、49、131、67，94，211、187、27，初始状态为磁头停留在67磁道处，请设计程序根据最短寻道时间优先（SSTF），列出磁道的访问序列。

思路:
SSTF:最短寻道时间算法，算法本质是贪心，已知磁头的初始位置，则最先被处理就是距离磁头位置最近的进程，处理完成后再处理距离当前磁道最近的进程，直到所有的进程被处理。

代码:

class SSTF:

    def __init__(self, init):
        self.address = init

    def read(self, item):
        print("访问: ", item)
        self.address = item


if __name__ == '__main__':
    s = SSTF(67)

    read_list = [12, 177, 49, 131, 67, 94, 211, 187, 27]

    while read_list:
        temp = 1000
        for i in range(len(read_list)):
            if abs(read_list[i] - s.address) < temp:
                temp = read_list[i]
        s.read(temp)
        read_list.remove(temp)

截图: