CLOCK页面置换算法

页面置换算法

1 时钟置换算法 CLOCK

1.1 代码实现

原谅我的无聊，偏要写一下代码实现以下

• 给定驻留集大小
• 访问串
  计算每次内存中页面，并最终计算缺页率

BLOCKS = 3  # 驻留集大小
PAGE_ACCESS = [3, 4, 2, 6, 4, 3, 7, 4, 3, 6, 3, 4, 8, 4, 6]  # 输入串


class Clock(object):
    def __init__(self, BLOCKS, PAGE_ACCESS):
        self.BLOCKS = BLOCKS
        self.PAGE_ACCESS = PAGE_ACCESS
        self.CList = [None for i in range(self.BLOCKS)]  # 循环链表
        self.index = 0  # 指针
        self.access = [0 for i in range(self.BLOCKS)]  # 访问位

    def fix_index(self):
        if self.index >= self.BLOCKS:
            self.index = 0

    def run(self):
        counter = 0
        for outer_index, page in enumerate(self.PAGE_ACCESS):
            have_page = None
            have_page_index = None
            for _index, exist_page in enumerate(self.CList):
                if exist_page == page:
                    have_page = exist_page
                    have_page_index = _index

            # 如果不缺页
            if have_page:
                # 指针不变
                # 对应页的访问位置为 1
                self.access[have_page_index] = 1
            else:  # 缺页的情况
                print(outer_index)
                counter += 1
                # # 如果内存中的页表修改为全为 1，则需要全部置为 0，指针指向第一个页面
                # 这个做法是错误的，当内存中两个页面为 1，一个页面为 0 时，若此时进来的页面不导致缺页，
                # 把 0 的位置进行了换页，那么指针的位置不一定会指向第一个页面
                # if all(self.access):
                #     self.access = [0 for i in range(self.BLOCKS)]
                #     self.index = 0

                # 问题在于，如果 self.index 为 2的时候，只跑一遍，可以设置一个值，每一轮必须找到一个页面
                flag = 0

                for inner_index in range(self.index, len(self.CList)):
                    # 经过的访问位为 1 则修改为 0
                    if self.access[inner_index] == 1:
                        self.access[inner_index] = 0
                        self.index = inner_index + 1
                        self.fix_index()
                    else:  # 经过的访问位为 0 则进行换页
                        self.CList[inner_index] = page
                        self.access[inner_index] = 1
                        self.index = inner_index + 1  # 指针指向下一个
                        self.fix_index()  # 修正指针的值
                        flag = 1
                        break

                if not flag:
                    for inner_index in range(self.index, 3):
                    # 经过的访问位为 1 则修改为 0
                        if self.access[inner_index] == 1:
                            self.access[inner_index] = 0
                            self.index = inner_index + 1
                            self.fix_index()
                        else:  # 经过的访问位为 0 则进行换页
                            self.CList[inner_index] = page
                            self.access[inner_index] = 1
                            self.index = inner_index + 1  # 指针指向下一个
                            self.fix_index()  # 修正指针的值
                            break
            print(self.CList)
        print(f"缺页率 -> {counter/len(self.PAGE_ACCESS)}")


class ClockPlus(object):
    def __init__(self, BLOCKS, PAGE_ACCESS):
        self.PAGE_ACCESS = PAGE_ACCESS
        self.BLOCKS = BLOCKS
        # (访问位, 修改位)
        self.site = [(0, 0) for i in range(self.BLOCKS)]
        

    def run(self):
        # 四次遍历 --> 写成两次
        for index in range(len(self.data)):
            tup = self.data[index]
            if tup[0] == 0 and tup[1] == 0:
                pass    


if __name__ == '__main__':
    clock = Clock(BLOCKS, PAGE_ACCESS)
    clock.run()

2 改进型时钟置换算法