頁面置換算法LRU(python語言實現)

頁面置換算法LRU(python語言實現)

class Page(object):
    def __init__(self, pagenum):
        self.page_num = pagenum
        self.page_t = 0


page_list = list()       # 待訪問頁面號列表
page_set = set()         # 頁面號集合
temp_set = set()
page_flaglist = list()   # 頁面號時間標記集合
memory_list = list()     # 內存中頁面列表
swap_interrupt_list = list()  # 中斷置換頁面列表
flag = 0                 # 標記當前內存塊頁表數
lost_num = 0             # 缺頁中斷次數
lost_rate = 0            # 缺頁率
set_size = 0             # 頁面號標記集合大小
memory_size = 0          # 內存塊頁表大小


def page_input():
    print("Please input page seq:")
    data = input()
    print("please input memory size:")
    mem_size = input()
    mem_size = int(mem_size)
    return data, mem_size


def deal_input(data):
    """輸入處理"""
    data.strip('\n')
    for num in data.split(' '):
        num = int(num)
        page_list.append(num)
        if num not in temp_set:
            page_set.add(Page(num))
        temp_set.add(num)


def clear_time(xx):
    """時間標記清0"""
    for j in range(set_size):
        if page_flaglist[j].page_num is xx:
            page_flaglist[j].page_t = 0


def find_oldest():
    """找出內存塊中頁表號時間標記最大的"""
    page_flaglist.sort(key=lambda a: a.page_t, reverse=True)

    for j in range(set_size):
        if page_flaglist[j].page_num in memory_list:
            max_num = page_flaglist[j].page_num
            return max_num


def page_swap(oldx, newx):
    """頁表置換"""
    for j in range(memory_size):
        if memory_list[j] is oldx:
            memory_list[j] = newx


def time_add():
    """內存塊已存在的頁面號時間標記全部+1"""
    for k in range(set_size):
        if page_flaglist[k].page_num in memory_list:
            page_flaglist[k].page_t += 1


if __name__ == '__main__':
    datam, memory_size = page_input()
    deal_input(datam)
    page_flaglist = list(page_set)
    set_size = len(page_flaglist)
    print("memory_list: ")
    for x in page_list:
        time_add()                           # 內存塊已存在的頁面號,時間標記全部+1
        if flag < memory_size:               # 如果內存塊頁表數 < 最大
            if x not in memory_list:         # 如果內存塊中,不存在當前需要訪問的頁面號
                memory_list.append(x)        # 當前需要訪問的頁面號加入內存塊
            else:                            # 如果內存塊中,存在當前需要訪問的頁面號
                clear_time(x)                # 訪問時間標記清零
            flag += 1
        else:                                # 如果內存塊頁表數 >= 最大
            if x not in memory_list:         # 如果內存塊中,不存在當前需要訪問的頁面號
                old_num = find_oldest()      # 找出內存塊中頁表號,時間標記最大的
                swap_interrupt_list.append(old_num)  # 存儲置換出的頁號
                page_swap(old_num, x)        # 當前頁表號置換內存塊時間標記最大的頁表號
                lost_num += 1                # 缺頁中斷次數增加
            clear_time(x)                    # 訪問時間標記清零
        print(memory_list)
    print("\ninterrupt swap page sequence:")
    print(swap_interrupt_list)                    # 打印置換出的頁號
    interrupt_time = lost_num + memory_size
    print("\n\nlost page interrupt nums: {}".format(interrupt_time))
    print("lost page rate: {:.2f}%".format(float(interrupt_time / len(page_list) * 100)))

# Test data
# 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
# 3

# 運行結果
Please input page seq:
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
please input memory size:
3
memory_list: 
[7]
[7, 0]
[7, 0, 1]
[2, 0, 1]
[2, 0, 1]
[2, 0, 3]
[2, 0, 3]
[4, 0, 3]
[4, 0, 2]
[4, 3, 2]
[0, 3, 2]
[0, 3, 2]
[0, 3, 2]
[1, 3, 2]
[1, 3, 2]
[1, 0, 2]
[1, 0, 2]
[1, 0, 7]
[1, 0, 7]
[1, 0, 7]

interrupt swap page sequence:
[7, 1, 2, 3, 0, 4, 0, 3, 2]


lost page interrupt nums: 12
lost page rate: 60.00%