操作系统内存管理_MBT_LRU

from So_nb_xuhu20183898 import MBT,LRU

class main():
    def __init__(self):
        self.printf_all()
    def menu(self):
        print("\t\tMENU\t\t")
        print("0 ByeBye!My baby!")
        print("1 运用可变式分区分配思想建立存储分块表MBT，使用首次匹配为新作业寻找可用空间")
        print("2 采用最近最少使用页面先淘汰（LRU）的算法")

    def printf_all(self):
        while 1:
            self.menu()
            opt=int(input("请输入你的选择："))
            if opt==0:break
            elif opt==1:MBT.main()
            elif opt==2:LRU.main()

if __name__=="__main__":
    main()

class page:
    def __init__(self,num,time):
        # 记录页面号
        self.num = num
        # 记录调入内存时间
        self.time = time

class main:
    # 初始化内存单元，缓冲区
    def __init__(self):
        self.M=3
        self.N=0
        # self.M = 4
        # self.N = len("70120304230321201701*".replace('*', ''))
        # 初始化内存单元
        self.b = [page(-1,self.M-i-1) for i in range(0,self.M)]
        # 初始化内存当前状态，缓冲区
        self.c = [[-1 for i in range(0,self.N)] for j in range(0,self.M)]
        # 记录调入队列
        self.queue = []
        self.k = -1
        self.flag =-1
        # self.process()
        self.tmp=[] #test
        self.queue_=[]
        # self.a=[int(s) for s in "70120304230321201701*".replace('*', '')]
        # print(self.a)
        self.a=None
        self.printf_all()

    def print_string(self):
        print("|---"*self.N)

    # 取得在内存中停留最久的页面，默认状态下为最早点入的页面
    def get_max(self,b):
        max = -1
        flag = 0
        for i in range(0,self.M):
            if b[i].time >max:
                max = b[i].time
                flag = i
        return flag

    # 判断页面是否已在内存中
    def equation(self,fold,b):
        for i in range(0,self.M):
            if fold == b[i].num:
                return i
        return -1

    # LRU 算法
    def lru(self, fold, b):
        val = self.equation(fold, b)
        if val >= 0:
            b[val].time = 0
            for i in range(0, self.M):
                if i != val:
                    b[i].time += 1
            self.queue.append("*")
            self.queue_.append('*')
        else:
            self.queue.append(fold)
            self.k += 1
            val = self.get_max(b)
            self.queue_.append(b[val].num)
            b[val].num = fold

            b[val].time = 0
            for i in range(0, self.M):
                if (i != val):
                    b[i].time += 1

    # 主程序
    def load_data(self,s):
        self.a = [int(ch) for ch in s.replace('*', '')]
        self.N=len(self.a)
        self.b = [page(-1, self.M - i - 1) for i in range(0, self.M)]
        # 初始化内存当前状态，缓冲区
        self.c = [[-1 for i in range(0, len(self.a))] for j in range(0, self.M)]
        return self.a

    def process(self):
        if self.M==0:
            print("Not the page_frame the process!")
            return
        else:
            self.queue = []
            self.queue_ = []
            self.k = -1
            print("\t|_____|\t" * self.M, "\t加入的元素\t  \t被替换的元素\t")
            for i in range(0, self.N):
                self.lru(self.a[i], self.b)
                self.c[0][i] = self.a[i]
                for k in range(len(self.b)):
                    print(f'\t{self.b[k].num}<{self.b[k].time + 1}>\t', end=" ")
                print(f'\t     {self.queue[i]}\t\t         {self.queue_[i]}\t')  # test
                # 记录当前的内存单元中的页面
                for j in range(0, self.M):
                    self.c[j][i] = self.b[j].num
            # 结果输出
            print("lru算法内存状态为：")
            print("调入队列为")
            print(self.queue)
            print("\t缺页次数为：%d\t\n\t缺页率：%f\t" % (self.k + 1, (float)(self.k + 1) / self.N))



    def menu(self):
        print("\tMENU\t")
        print("0 FINISH")
        print("1 LOAD DATA")
        print("2 INPUT PAGE_FRAME")
        print("3 LRU")

    def printf_all(self):
        s="123"   #默认字符串 test
        while (1):
            self.menu()
            opt = int(input("please input your choice:"))
            if opt == 0:
                break
            elif opt == 1:
                s=input("please input a visit-string(*=end):")
                self.load_data(s)         #    70120304230321201701* 输入要求的字符串
            elif opt == 2:
                self.M=(int(input("please input how many page_frames the process cooupied:")))
            elif opt==3:
                self.load_data(s)
                self.process()
            print("*-*" * self.M)
            print("================" * self.M)





if __name__ == "__main__":
    pass
    # main()

# import numpy as np
import copy
import sys
x=[]
class Memory():
    def __init__(self,seq,base,size,state=-1):
        self.seq=seq
        self.base=base
        self.size=size
        self.state=state
    def res(self):
        return self.seq,self.base,self.size,self.state
class main():
    def __init__(self):
        self.length_of_MBT_table=0
        self.memorys=None
        self.printf_all()
        self.main_memory=None
    def init(self):

        for i in range(self.length_of_MBT_table):
            self.memorys.append(Memory(i, 0, 0, -1))
        self.memorys[0] = Memory(0, self.main_memory, self.main_memory, 0)
        return self.memorys

    def printf(self,memorys):
        print(" \t***MBT-table***\t")
        print("\tseq base size state\t")
        for memory in self.memorys:
            print(f'\t{memory.seq}\t{memory.base}\t{memory.size}\t{memory.state}\t')

    def allocate(self,allocate_size):
        # global self.main_memory
        memorys_ = copy.deepcopy(self.memorys)
        for i in range(0, len(self.memorys) - 1):
            if memorys_[i].state == 0 and memorys_[i].size >= allocate_size:
                if memorys_[i + 1].state == -1:
                    del self.memorys[i]
                    p = Memory(i, memorys_[i].base, allocate_size, 1)
                    self.memorys.insert(i, p)
                    self.memorys[i + 1].state = 0
                    self.memorys[i + 1].base = memorys_[i].base + allocate_size
                    self.memorys[i + 1].size = self.main_memory - self.memorys[i].size
                    self.main_memory -= allocate_size
                    break

                elif memorys_[i + 1].state == 1:
                    # memorys[i+1]=memorys_[i+1]
                    self.memorys.pop(i)
                    self.memorys.insert(i, Memory(i, memorys_[i].base, allocate_size, 1))
                    # del memorys[i + 1]
                    self.memorys.insert(i + 1,
                                   Memory(i + 1, self.memorys[i].base + self.memorys[i].size, memorys_[i].size - allocate_size,
                                          0))
                    self.main_memory -= allocate_size
                    self.memorys.pop()
                    break

        for i in range(len(self.memorys)):
            self.memorys[i].seq = i

        return self.memorys[:self.length_of_MBT_table]

    def release(self,r):
        # global main_memory
        tmp = 0
        memorys_ = copy.deepcopy(self.memorys)
        for i in range(r, len(self.memorys) - 1):
            if self.memorys[i + 1].state == 1:
                self.memorys[i].state = 0
                self.main_memory += memorys_[i].size
                break
            else:
                self.main_memory += self.memorys[i].size
                tmp += self.memorys[i].size
                del self.memorys[i]
                self.memorys.insert(i, Memory(i, 0, 0, -1))
        self.memorys[r - 1].size += tmp

        return self.memorys

    def menu(self):
        print("\tMENU\t")
        print("\t0 finish\t")
        print("\t1 allocate space\t")
        print("\t2 release space\t")
        print('\tPlease input your choice:\t')

    def printf_all(self):
        global xx
        print("Please input your main_memory's space:")
        self.main_memory = int(input())
        print("Now input length of your MBT-table:")
        self.length_of_MBT_table = int(input())
        self.memorys = []
        self.init()
        self.printf(self.memorys)
        while (1):

            self.menu()
            opt = int(input())
            if opt == 0:break
            elif opt == 1:
                print("Input size of the space you want to allocate:")
                allocate_size = int(input())
                self.allocate(allocate_size)
                self.printf(self.memorys)
            elif opt == 2:
                print("Input size is that you want to release:")
                r = int(input())
                self.release(r)
                self.printf(self.memorys)
if __name__ == '__main__':
    # pass
    main()