【操作系统】虚拟存储管理-页面置换算法（FIFO、LRU、CLOCK）

最新推荐文章于 2024-01-02 11:08:13 发布
最新推荐文章于 2024-01-02 11:08:13 发布
阅读量4.7k 收藏 66
点赞数 8
分类专栏： 操作系统 笔记 题解 文章标签： 算法 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52387305/article/details/125185345
版权
题解 同时被 3 个专栏收录
16 篇文章 3 订阅
订阅专栏
笔记
15 篇文章 0 订阅
订阅专栏
操作系统
11 篇文章 1 订阅
订阅专栏

Lab Week 17 实验报告

实验内容：虚拟存储管理

编写一个C程序模拟实现课件 Lecture24 中的请求页面置换算法，包括FIFO、LRU stack implementation 和 Second chance/CLOCK 置换策略。

  • 固定一个页帧 (frame) 数；
  • 输入一批随机页面引用序列，计算各个置换策略的平均缺页数。
  • 当页帧数增加或减少时，观察上述统计结果的变化情况
  • 思考：如何在随机页面引用序列中模拟局部性

I.请求页面置换算法

​ 在操作系统中，通常使用虚拟内存来对内存进行管理，使计算机能够弥补物理内存短缺，暂时将数据从随机存取存储器（RAM）传输到磁盘存储。将内存块映射到磁盘文件使计算机能够将辅助内存视为主内存。虚拟内存使用硬件和软件进行操作。当应用程序正在使用时，来自该程序的数据将使用RAM存储在物理地址中。内存管理单元（MMU）将地址映射到 RAM，并自动转换地址。例如，MMU可以将逻辑地址空间映射到相应的物理地址。

​ 物理地址空间通常被分为多个固定大小的块叫做页框/页帧（frames），逻辑地址空间被分为与页框相同大小的块，称为页（pages），当请求的页不在内存中时，会产生缺页中断（page fault），需要把他们从外部存储设备（硬盘、磁盘等）调入内存，但内存空间不足以存储这些页，这就需要从内存中调出页（page out）

IMG_0508

系统为每个进程在内存中建立一张页表，它记录页面在内存中对应的物理块号，页表项第一部分是页号，可以通过虚拟地址的第一部分来对应，第二部分是物理块号，而虚拟地址的第二部分是在该物理块里的偏移；通常页表还会有一个valid-invalid (present-absent) bit来表示当前对应的页是否在内存中，在内存中为valid，不在内存中为invalid，如果不在内存中，则需要到外部存储设备中找；

IMG_8E24DDA6C46D-1

1.FIFO置换策略

FIFO页面置换算法优先淘汰最早进入内存的页面，即在内存中驻留时间最久的页面；

实现代码：

#include<stdio.h>
#include<stdlib.h>
#define STRING_SIZE 30
int frame_num, ref_num;

//判断引用地址addr是否在内存frame中
int find_exist(int* frame, int n, int addr){
    for(int i = 0; i < n; i++){
        if(frame[i] == addr)
            return i;
    }
    return -1;
}

// 打印页框
void Print_Frame(int* frame, int n)
{
	printf("\t\t");
	for(int i = 0; i < n; i++){
        printf("%d|", frame[i]);
    }
	printf("\n");
}

//更新在滞留在fifo queue中的时间
void update_time(int* time_cnt, int size, int set_zero_idx){
    for(int i=0; i < size; i++){
        time_cnt[i]++;
    }
    if(set_zero_idx != -1){ //如果set_zero_idx不为-1，则将set_zero_idx对应的页框的驻留时间清0
        time_cnt[set_zero_idx] = 0;//用在替换后的页框上
    }

}

void fifo(int *req_str){
    int addr, hit = 0, miss = 0, iter = 0, in_queue_num = 0;
    int* fifo_queue;
    int* time_cnt; //计算滞留在fifo queue中的时间
    fifo_queue = (int*)malloc(sizeof(int)*frame_num);
    time_cnt = (int*)malloc(sizeof(int)*frame_num);

    while(iter < ref_num){
        addr = req_str[iter];
       // printf("\tReferencing address: %d\n", addr);
        iter++;
        if(in_queue_num < frame_num){
            if(find_exist(fifo_queue, in_queue_num, addr) != -1){
                hit++;
                update_time(time_cnt, in_queue_num, -1);
            }
            else{
                miss++;
                fifo_queue[in_queue_num++] = addr;
                update_time(time_cnt, in_queue_num, in_queue_num);
            }
        }
        else{
            if(find_exist(fifo_queue, in_queue_num, addr) != -1){
                hit++;
                update_time(time_cnt, in_queue_num, -1);
            }
            else{
                miss++;
                int max_time = -9999;
                int idx = -1;
                for(int i = 0; i < in_queue_num; i++){//找到驻留时间最长的页框
                    if(time_cnt[i] > max_time){
                        max_time = time_cnt[i];
                        idx = i;
                    }
                }
                fifo_queue[idx] = addr;
                update_time(time_cnt, in_queue_num, idx);
             
            }
        }
       Print_Frame(fifo_queue, in_queue_num);
    }
    printf("\tnumber of [FIFO] page faults %d\n", miss);
}
int main(){
    int ref_str[STRING_SIZE];
    //printf("----Belady's Anomaly Test----\n");
    // printf("Enter frame number:");
    // scanf("%d", &frame_num);
    printf("Enter Reference string size: ");
    scanf("%d", &ref_num);
    printf("Now, Enter Reference string: ");
    for(int i = 0;i < ref_num ;i++){
        scanf("%d", &ref_str[i]);
    }
  
    for(int i=1;i<=15;i++){
        frame_num = i;
        printf("Number of frames: %d\n", frame_num);
        fifo(ref_str);
    }
   // fifo(ref_str);


}

代码说明：

实现FIFO调度主要在于记录页框在内存中驻留的时间，每当需要置换页面的时候，首选驻留时间最长的页面，在代码中定义了void update_time(int* time_cnt, int size, int set_zero_idx)函数，用于更新页框在内存中驻留的时间，相关的操作可见注释；

实验结果：

页框数 ：3

Reference string: 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1

image-20220603214535284 image-20220603214633379

缺页数为15；

现在使用随机数，在固定页帧数的情况下，对缺页数进行测试：

固定帧数 = 3

image-20220607091933251

从结果可以看到，在固定页帧数为3的前提下，缺页数随着引用序列长度的增加，缺页数随之变化，引用序列长度为6时，缺页数为5，引用序列长度为7时，缺页数为4，但总的趋势是缺页数越来越多；

固定帧数 = 4

image-20220607092059195

在固定页帧数为4的前提下，也有相同的现象，总的趋势是缺页数越来越多；

测试Belady’s Anomaly

在相同的引用序列的前提下，使用不同的页框数，观察Belady’s Anomaly现象：

Reference string: 1 2 3 4 1 2 5 1 2 3 4 5

页框数从1～15：

image-20220603215727135

可以发现，在页框数为3和4的时候出现了Belady’s Anomaly现象，在页框数为4的时候的缺页数为10，页框数为3时缺页数为9，这里的缺页数不降反升；

2.LRU stack implementation 置换策略

在LRU算法的实现中，采用了双向链表来存储引用页号，哈希表来存储链表索引，实现基本的思想是，对于每个引用页号，如果当前链表结点个数未满（未到限定的页帧数），则向链表头部插入该页号的结点，若引用页号已在链表中（通过哈希表查找），则将该页号的结点移动到链表头部，如果链表已满，则分成两种情况，如果引用页号在链表中，则将该页号的结点移动到链表头部，反之，则将链表尾部结点删除，将该页号的结点插入到链表头部。

实现代码：

#include<stdio.h>
#include<stdlib.h>
#include <time.h>
#define STRING_SIZE 30
int frame_num, ref_num;
struct node
{
    int key;
    int value;
    struct node* prev;
    struct node* next;
};

typedef struct DLinkList
{
   struct node* head;
   struct node* tail;
   int size;
}DLinkList;

typedef struct HashMap
{
   struct node** map;
   int size;

}HashMap;

// 创建链表结点
struct node* createnode(int value){
    struct node* newnode = (struct node*)malloc(sizeof(struct node));
    newnode->value = value;
    newnode->next = NULL;
    newnode->prev = NULL;
    return newnode;
}

//创建双向链表
void createDlinkList(DLinkList *L){
    L->head = createnode(-1);
    L->tail = createnode(-1);
    L->head->next = L->tail;
    L->tail->prev = L->head;
    L->size = 0;
}

//根据页框号addr获取哈希值
struct node* getMapval(struct HashMap* HashMap, int addr){
    struct node* res = NULL;
    for(int i = 0; i < HashMap->size; i++){
        if(HashMap->map[i] == NULL) continue;
        if(HashMap->map[i]->value == addr){
            res = HashMap->map[i];
            break;
        }
    }
    return res;
}

//将链表结点插入哈希表
void putHashval(struct HashMap* HashMap, struct node* newnode){
    for(int i = 0; i < frame_num; i++){
        if(HashMap->map[i] == NULL){
            HashMap->map[i] = newnode;
            break;
        }
    }
    HashMap->size++;
}

//移除哈希表中的结点
void removeHashval(struct HashMap* HashMap, struct node* node){
    for(int i = 0; i < HashMap->size; i++){
        if(HashMap->map[i] == node){
            HashMap->map[i] = NULL;
            break;
        }
    }
    HashMap->size--;
}

//双向链表头插法
void insert_head(DLinkList *L, struct node* newnode){
    newnode->next = L->head->next;
    L->head->next->prev = newnode;
    L->head->next = newnode;
    newnode->prev = L->head;
    L->size++;

}

//双向链表中移除结点
void remove_node(struct node* node){
    node->prev->next = node->next;
    node->next->prev = node->prev;

}

//双向链表中将结点移动到头部
void move_to_head(DLinkList *L, struct node* node){
    remove_node(node);
    L->size--;
    insert_head(L, node);

}

//打印出双向链表中结点的值
void print(DLinkList *L){
    struct node* cur = L->head->next;
    for(int i=0;i<L->size;i++){
        printf("%d|", cur->value);
        cur = cur->next;
    }
    printf("\n");
}

//移除链表最后一个结点（tail前一个结点）
void removetail(DLinkList *L){
    if(L->head->next == L->tail)return;
    struct node* temp = L->tail->prev;
    remove_node(temp);
    free(temp);
    L->size--;
    
}

// LRU Algoritum Stack Implementation
void lru(int *ref_str){
  
  	//初始化
    int i, addr, miss = 0;
    struct HashMap* HashMap = malloc(sizeof(HashMap));
    struct DLinkList *L = malloc(sizeof(DLinkList));
    L->head = createnode(-1); //通过两个dummy结点：head和tail来管理双向链表
    L->tail = createnode(-1);
    L->head->next = L->tail;
    L->tail->prev = L->head;
    L->size = 0;

    HashMap->map = (struct node**)malloc(sizeof(struct node*) * frame_num);
    HashMap->size = 0;
    
  	//循环获取页面引用序列
    for(i = 0; i < ref_num; i++){
        addr = ref_str[i];
        printf("Referencing addr: %d\n", addr);
        struct node* curnode = getMapval(HashMap, addr); //从哈希表中取得addr对应的结点
        if(curnode){ //如果结点在链表中，将该结点移动到头部
            printf("addr: %d is in list\n", curnode->value);
            move_to_head(L, curnode);
        }
        else{ //如果结点不在链表中，考虑插入该结点
            miss++;
            struct node* newnode = createnode(addr);
            if(L->size < frame_num){
                insert_head(L, newnode);
                putHashval(HashMap, newnode);

            }
            else{  //如果结点不在链表且空间不足，移除链表尾部的结点，将新结点插入到头部
                remove_node(L->tail);
                removeHashval(HashMap, L->tail);
                insert_head(L, newnode);
                putHashval(HashMap, newnode);
            }
        }
        print(L);
    }
		
    //释放哈希表和链表结点
    free(HashMap->map);
    for(i = 0; i < L->size; i++){
        struct node* cur = L->head->next;
        free(L->head);
        L->head = cur;
        cur = cur->next;
    }
    printf("\tnumber of [LRU] page faults %d\n", miss);


}

int main(){
    int ref_str[STRING_SIZE];
    printf("Enter frame number:");
    scanf("%d", &frame_num);
    printf("Enter Reference string size: ");
    scanf("%d", &ref_num);
    printf("Now, Enter Reference string: ");
    for(int i = 0;i < ref_num ;i++){
        scanf("%d", &ref_str[i]);
    }
    lru(ref_str);
  	
}

代码说明：

在LRU的实现中，分别为存储链表结点的哈希表和双向链表本身的插入和删除功能定义了函数，双向链表通过两个dummy结点：head和tail来管理，此外，最近使用过的页帧的结点需要移动到链表的头部，为此也定义了函数move_to_head()来实现，移除尾部结点（最近最少使用的页帧，tail的前一个结点）需要对结点进行free，因此它也另外封装了函数；

实验结果：

Reference string: 4 7 0 7 1 0 1 2 1 2 7 1 2

Reference string size: 13

页框数：5

image-20220605160153204

现在使用随机数，在固定页帧数的情况下，对缺页数进行测试：

固定帧数 = 5

引用序列：

1 2 1
2 2 8 6
2 7 1 9 1
7 8 0 1 5 1
9 8 1 2 6 2 9
8 7 2 1 6 2 8 9
image-20220606163432706

随着随机页面引用序列的个数增大，在固定页帧数的情况下，缺页数随之上升；

固定帧数 = 4

image-20220607171836789

减少固定帧数后，同样随着随机页面引用序列的个数增加，缺页数增加；

固定帧数 = 6

image-20220607172001865

增加固定帧数后，同样随着随机页面引用序列的个数增加，缺页数增加；

3.Second chance/CLOCK置换策略

在CLOCK算法中，每帧都关联一个附加位，称为使用位，当某页首次装入主存时，该帧的使用位被设置为1，当改页随后再次被访问到时，其使用位也被置为1，对于置换算法，用于替换的候选帧集合可以视为一个循环缓冲区，并有一个指针与其相关联，当需要进行页帧替换时，通过在循环缓冲区上扫描，当遇到一个使用位为0的帧时就替换改帧，并将使用位置为1，如果遇到使用位为1的帧，则将该位置为0（如果缓冲区中所有帧都为1，那么最后则会选择第一个帧进行替换），替换后指针指向替换帧的下一个位置。

image-20220608125641320

实现代码：

#include<stdio.h>
#include<stdlib.h>
#include <time.h>
#include<string.h>
#define STRING_SIZE 30
#define MAX_REF
int frame_num, ref_num;
struct node
{
    int key;
    int value;
    struct node* prev;
    struct node* next;
};

typedef struct DLinkList
{
   struct node* head;
   struct node* tail;
   int size;
}DLinkList;

typedef struct HashMap
{
   struct node** map;
   int size;

}HashMap;

struct clock_node{
    int used;
    int page;
};
typedef struct c_clock
{
    struct clock_node* clock_list;
    int ptr;
    int size;
}c_clock;



int random_code(unsigned int code_len)
{
    int code_val;
    long int modulus = 1;
    
    for (int i = 0; i < code_len; i++) {
        modulus = modulus * 10;
    }
    
    srand(time(NULL));
    while (1) {
        code_val = rand() % modulus;
        if(code_val > modulus / 10 - 1) {
            break;
        }
    }
    
    return code_val;
}

int find_exist(struct clock_node* clock_node, int n, int addr){
    for(int i = 0; i < n; i++){
        if(clock_node[i].page == addr)
            return i;
    }
    return -1;
}
//struct clock_node* clock_list
void second_chance(int *ref_str){
    int i, addr, cur, miss = 0;
    struct c_clock* c_clock = (struct c_clock*)malloc(sizeof(c_clock));
    c_clock->clock_list = (struct clock_node*)malloc(sizeof(struct clock_node)*frame_num);
   
    for(i = 0; i < frame_num; i++) c_clock->clock_list[i].page = -1;
    c_clock->size = 0;
    c_clock->ptr = 0;
    for(i = 0; i<ref_num; i++){
        int flag = 0;
        addr = ref_str[i];
        printf("Referencing %d\n", addr);
        if(c_clock->size < frame_num){
            if(find_exist(c_clock->clock_list, c_clock->size, addr) == -1){
                c_clock->clock_list[c_clock->ptr].page = addr;
                c_clock->clock_list[c_clock->ptr].used = 1;
                //printf("PRE: %d\n",c_clock->ptr);
                c_clock->ptr = (c_clock->ptr + 1) % frame_num;
                //printf("AFTER: %d\n",c_clock->ptr);
                c_clock->size++;
            }
        }
        else{
            for(cur = c_clock->ptr;(cur + 1) % frame_num != c_clock->ptr; cur = (cur + 1) % frame_num){
                if(c_clock->clock_list[cur].page == addr){
                    c_clock->clock_list[cur].used = 1;
                    flag = 1;
                    break;
                }
            }
            if(!flag){ //CLOCK中没有该addr
                miss++;
                for(cur = c_clock->ptr;;cur = (cur + 1) % frame_num){
                    if(!c_clock->clock_list[cur].used){
                        c_clock->clock_list[cur].page = addr;
                        c_clock->clock_list[cur].used = 1;
                        c_clock->ptr = (cur + 1) % frame_num;
                        break;
                    }
                    else{
                        c_clock->clock_list[cur].used = 0;
                    }
                }
                
            }
           
        }
    
        for(int k = 0; k < c_clock->size; k++){
            printf("%d|", c_clock->clock_list[k].page);
        }
        printf("\n");
    }
    printf("\tnumber of [CLOCK] page faults %d\n", miss);
}




int main(){
    int ref_str[STRING_SIZE];
    //printf("----Belady's Anomaly Test----\n");
     printf("Enter frame number:");
     scanf("%d", &frame_num);
    printf("Enter Reference string size: ");
    scanf("%d", &ref_num);
    printf("Now, Enter Reference string: ");
    for(int i = 0;i < ref_num ;i++){
        scanf("%d", &ref_str[i]);
    }

  //随机数测试
    // for(int i = 3; i<=20; i++){
    //     ref_num = i;
    //     printf("Reference string size: %d\n", ref_num);
    //     printf("Random generated reference string: ");
    //     int code = random_code(ref_num);
    //     for(int j=0;j<ref_num;j++){
    //         ref_str[j] = code % 10;
    //         code /= 10;
    //     }
    //     for(int j=0;j<ref_num;j++){
    //        printf("%d", ref_str[j]);
    //     }
    //     printf("\n");

    //      second_chance(ref_str);
    // }


        second_chance(ref_str);


}

实验结果：

Reference string: 2 3 2 1 5 2 4 5 3 2 5 2

image-20220606114335837

现在使用随机数，在固定页帧数的情况下，对缺页数进行测试：

固定帧数 = 3

image-20220606114706542

可以看到，随着引用序列长度的增加，缺页数随着增大；

固定帧数 = 4

image-20220608125506846

同样的，随着引用序列长度的增加，缺页数随着增大；

现在采用同一页面引用序列，对以上三种不同的页面置换算法的缺页数进行测试：

页框数 ：3

Reference string: 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1

【FIFO】

image-20220608130505799

缺页数=15

【LRU】

image-20220608130153386

缺页数=12

【CLOCK】

image-20220608130310029

缺页数=11

可以看到，上面三种页面置换算法，CLOCK在当前引用序列下的缺页数最少，其次是LRU，最多是FIFO；

完整代码：

#include<stdio.h>
#include<stdlib.h>
#include <time.h>
#include<string.h>
#define STRING_SIZE 30
#define MAX_REF
int frame_num, ref_num;
struct node
{
    int key;
    int value;
    struct node* prev;
    struct node* next;
};

typedef struct DLinkList
{
   struct node* head;
   struct node* tail;
   int size;
}DLinkList;

typedef struct HashMap
{
   struct node** map;
   int size;

}HashMap;


struct clock_node{
    int used;
    int page;
};
typedef struct c_clock
{
    struct clock_node* clock_list;
    int ptr;
    int size;
}c_clock;



int random_code(unsigned int code_len)
{
    int code_val;
    long int modulus = 1;
    
    for (int i = 0; i < code_len; i++) {
        modulus = modulus * 10;
    }
    
    srand(time(NULL));
    while (1) {
        code_val = rand() % modulus;
        if(code_val > modulus / 10 - 1) {
            break;
        }
    }
    
    return code_val;
}

int find_exist(int* frame, int n, int addr){
    for(int i = 0; i < n; i++){
        if(frame[i] == addr)
            return i;
    }
    return -1;
}

// 打印页框
void Print_Frame(int* frame, int n)
{
    printf("\t\t");
    for(int i = 0; i < n; i++){
        printf("%d|", frame[i]);
    }
    printf("\n");
}

void update_time(int* time_cnt, int size, int set_zero_idx){
    for(int i=0; i < size; i++){
        time_cnt[i]++;
    }
    if(set_zero_idx != -1){
        time_cnt[set_zero_idx] = 0;
    }

}







void fifo(int *req_str){
    int addr, hit = 0, miss = 0, iter = 0, in_queue_num = 0;
    int* fifo_queue;
    int* time_cnt; //计算滞留在fifo queue中的时间
    fifo_queue = (int*)malloc(sizeof(int)*frame_num);
    time_cnt = (int*)malloc(sizeof(int)*frame_num);

    while(iter < ref_num){
        addr = req_str[iter];
       // printf("\tReferencing address: %d\n", addr);
        iter++;
        if(in_queue_num < frame_num){
            if(find_exist(fifo_queue, in_queue_num, addr) != -1){
                hit++;
               // printf("Hitted addr: %d\n", addr);
                Print_Frame(fifo_queue, in_queue_num);
                update_time(time_cnt, in_queue_num, -1);
            }
            else{
                miss++;
              //  printf("missed and load addr: %d\n", addr);
                fifo_queue[in_queue_num++] = addr;
       //         in_queue_num++;
                Print_Frame(fifo_queue, in_queue_num);
                update_time(time_cnt, in_queue_num, in_queue_num);
                //in_queue_num++;
            }
        }
        else{
            if(find_exist(fifo_queue, in_queue_num, addr) != -1){
                hit++;
              //  printf("Hitted addr: %d\n", addr);
                update_time(time_cnt, in_queue_num, -1);
            }
            else{
                miss++;
                int max_time = -9999;
                int idx = -1;
                for(int i = 0; i < in_queue_num; i++){
                    if(time_cnt[i] > max_time){
                        max_time = time_cnt[i];
                        idx = i;
                    }
                }
             //   printf("Replaced addr %d to %d\n", fifo_queue[idx], addr);
                fifo_queue[idx] = addr;
                update_time(time_cnt, in_queue_num, idx);
                Print_Frame(fifo_queue, in_queue_num);
            }
        }
    }
    printf("\tnumber of [FIFO] page faults %d\n", miss);
    free(time_cnt);
    free(fifo_queue);
   // printf("number of [FIFO] page hit %d\n", hit);
  //  printf("Frames: ");
    // for(int i=0;i<in_queue_num;i++){
    //     printf("%d|", fifo_queue[i]);
    // }
    // printf("\n");
}



struct node* createnode(int value){
    struct node* newnode = (struct node*)malloc(sizeof(struct node));
    newnode->value = value;
    newnode->next = NULL;
    newnode->prev = NULL;
    return newnode;
}

void createDlinkList(DLinkList *L){
    L->head = createnode(-1);
    L->tail = createnode(-1);
    L->head->next = L->tail;
    L->tail->prev = L->head;
    L->size = 0;
}

struct node* getMapval(struct HashMap* HashMap, int addr){
    struct node* res = NULL;
    for(int i = 0; i < frame_num; i++){
        if(HashMap->map[i] == NULL) continue;
        if(HashMap->map[i]->value == addr){
            res = HashMap->map[i];
            break;
        }
    }
    return res;
}

void putHashval(struct HashMap* HashMap, struct node* newnode){
    for(int i = 0; i < frame_num; i++){
        if(HashMap->map[i] == NULL){
            HashMap->map[i] = newnode;
            break;
        }
    }
    HashMap->size++;
}

void removeHashval(struct HashMap* HashMap, struct node* node){
    for(int i = 0; i < frame_num; i++){
        if(HashMap->map[i] == node){
            HashMap->map[i] = NULL;
            break;
        }
    }
    HashMap->size--;
}

void insert_head(DLinkList *L, struct node* newnode){

    newnode->next = L->head->next;
    L->head->next->prev = newnode;
    L->head->next = newnode;
    newnode->prev = L->head;
    L->size++;

}

void remove_node(struct node* node){
    node->prev->next = node->next;
    node->next->prev = node->prev;

}

void move_to_head(DLinkList *L, struct node* node){
    remove_node(node);
    L->size--;
    insert_head(L, node);

}

void print(DLinkList *L){
    struct node* cur = L->head->next;
    for(int i=0;i<L->size;i++){
        printf("%d|", cur->value);
        cur = cur->next;
    }
    printf("\n");
}

void removetail(DLinkList *L){
    if(L->head->next == L->tail)return;
    struct node* temp = L->tail->prev;
    remove_node(temp);
    free(temp);
    L->size--;
    
}

// LRU Algoritum Stack Implementation
void lru(int *ref_str){
    int i, addr, miss = 0;
    struct HashMap* HashMap = malloc(sizeof(HashMap));
    struct DLinkList *L = malloc(sizeof(DLinkList));
    L->head = createnode(-1);
    L->tail = createnode(-1);
    L->head->next = L->tail;
    L->tail->prev = L->head;
    L->size = 0;

    HashMap->map = (struct node**)malloc(sizeof(struct node*) * frame_num);
    HashMap->size = 0;
    
    
    for(i = 0; i < ref_num; i++){
        addr = ref_str[i];
       // printf("Referencing addr: %d\n", addr);
        struct node* curnode = getMapval(HashMap, addr); //从哈希表中取得addr对应的结点
        if(curnode){ //如果结点在链表中，将该结点移动到头部
         //   printf("addr: %d is in list\n", curnode->value);
            move_to_head(L, curnode);
        }
        else{ //如果结点不在链表中，考虑插入该结点
            miss++;
            struct node* newnode = createnode(addr);
            if(L->size < frame_num){
                insert_head(L, newnode);
                putHashval(HashMap, newnode);

            }
            else{  //如果结点不在链表且空间不足
                removeHashval(HashMap, L->tail->prev);
                removetail(L);
                //removetail(L);
                insert_head(L, newnode);
                putHashval(HashMap, newnode);
            }
        }
        print(L);
    }

    free(HashMap->map);
    for(i = 0; i < L->size; i++){
        struct node* cur = L->head->next;
        free(L->head);
        L->head = cur;
        cur = cur->next;
    }
    printf("\tnumber of [LRU] page faults %d\n", miss);


}

int find_clock_exist(struct clock_node* clock_node, int n, int addr){
    for(int i = 0; i < n; i++){
        if(clock_node[i].page == addr)
            return i;
    }
    return -1;
}

void second_chance(int *ref_str){
    int i, addr, cur, miss = 0;
    struct c_clock* c_clock = (struct c_clock*)malloc(sizeof(c_clock));
    c_clock->clock_list = (struct clock_node*)malloc(sizeof(struct clock_node)*frame_num);
   
    for(i = 0; i < frame_num; i++) c_clock->clock_list[i].page = -1;
    c_clock->size = 0;
    c_clock->ptr = 0;
    for(i = 0; i<ref_num; i++){
        int flag = 0;
        addr = ref_str[i];
      //  printf("Referencing %d\n", addr);
        if(c_clock->size < frame_num){
            if(find_clock_exist(c_clock->clock_list, c_clock->size, addr) == -1){
                c_clock->clock_list[c_clock->ptr].page = addr;
                c_clock->clock_list[c_clock->ptr].used = 1;
                //printf("PRE: %d\n",c_clock->ptr);
                c_clock->ptr = (c_clock->ptr + 1) % frame_num;
                //printf("AFTER: %d\n",c_clock->ptr);
                c_clock->size++;
            }
        }
        else{
            for(cur = c_clock->ptr;(cur + 1) % frame_num != c_clock->ptr; cur = (cur + 1) % frame_num){
                if(c_clock->clock_list[cur].page == addr){
                    c_clock->clock_list[cur].used = 1;
                    flag = 1;
                    break;
                }
            }
            if(!flag){ //CLOCK中没有该addr
                miss++;
                for(cur = c_clock->ptr;;cur = (cur + 1) % frame_num){
                    if(!c_clock->clock_list[cur].used){
                        c_clock->clock_list[cur].page = addr;
                        c_clock->clock_list[cur].used = 1;
                        c_clock->ptr = (cur + 1) % frame_num;
                        break;
                    }
                    else{
                        c_clock->clock_list[cur].used = 0;
                    }
                }
                
            }
           
        }
    
        for(int k = 0; k < c_clock->size; k++){
            printf("%d|", c_clock->clock_list[k].page);
        }
        printf("\n");
    }
    printf("\tnumber of [CLOCK] page faults %d\n", miss);
}




int main(){
    int opt;
    int ref_str[STRING_SIZE];
    //printf("----Belady's Anomaly Test----\n");
    printf("Please choose Page Replacement Algorithm: 1:FIFO, 2:LRU, 3:CLOCK\n");
    scanf("%d", &opt);
    printf("Enter frame number:");
    scanf("%d", &frame_num);
    printf("Enter Reference string size: ");
    scanf("%d", &ref_num);
    printf("Now, Enter Reference string: ");
    for(int i = 0;i < ref_num ;i++){
        scanf("%d", &ref_str[i]);
    }
    switch (opt)
    {
    case 1:
        fifo(ref_str);
        break;
    case 2:
        lru(ref_str);
        break;
    case 3:
        second_chance(ref_str);
    default:
        printf("INVALID OPTION!\n");
        break;
    }

    // for(int i = 3; i<=11; i++){
    //     ref_num = i;
    //     printf("Reference string size: %d\n", ref_num);
    //     printf("Random generated reference string: ");
    //     int code = random_code(ref_num);
    //     for(int j=0;j<ref_num;j++){
    //         ref_str[j] = code % 10;
    //         code /= 10;
    //     }
    //     for(int j=0;j<ref_num;j++){
    //        printf("%d", ref_str[j]);
    //     }
    //     printf("\n");
    //      second_chance(ref_str);
    //     //lru(ref_str);
    // }
  //  }

}

三种算法用switch-case，OPTION整合，运行效果如下：

image-20220608142605126

  • 随机页面引用序列中模拟局部性

在虚拟内存技术中，局部性原理主要表现在两个方面：

1.时间局部性：程序中的某条指令一旦执行，不久后该指令可能再次执行；

2.空间局部性：一旦程序访问了某个存储单元，在不久之后，其附近的存储单元也将被访问；

在页面引用序列中，设定在某段时间间隔内，进程要访问的页面集合，即工作集，基于局部性原理，可以用最近访问过的页面来确定工作集；

image-20220607092059195

如上图中的随机引用序列，在一段时间内不断访问的工作集 = {1, 4, 5, 9}，以此能够反映进程接下来一段时间很有可能回频繁访问的页面集合，需要注意的是，分配给进程的物理页帧数需要大于工作集大小，否则会频繁缺页；

Maxwell-Wong
关注
  • 8
    点赞
  • 踩
  • 66
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统 C++ 页面置换算法（含实验报告）有opt，LRU，先进先出，时钟算法，改进的时钟算法等所有算法
06-18
本实验使用一下算法 使用rand（）函数随机产生页面号，用数组装入页面号，模拟页面调入内存中发生页面置换的过程。 整个过程，都是使用数组来实现每个算法，模拟队列，模拟堆栈的功能，实现每一个置换算法。 页面置换算法 最佳置换算法（OPT）：选择永不使用或是在最长时间内不再被访问（即距现在最长时间才会被访问）的页面淘汰出内存。用于算法评价参照。 随机置换算法 （S）：产生一个取值范围在0和N-1之间的随机数，该随机数即可表示应被淘汰出内存的页面。 先进先出置换算法（FIFO）：选择最先进入内存即在内存驻留时间最久的页面换出到外存。 最近最久未使用置换算法（LRU）: 以“最近的过去”作为“最近的将来”的近似，选择最近一段时间最长时间未被访问的页面淘汰出内存 Clock置换算法:为进入内存的页面设置一个访问位，当内存中某页被访问，访问位置一，算法在选择一页淘汰时，只需检查访问位，若为0，则直接换出，若为1，置该访问位为0，检测内存中的下一个页面的访问位。 改进型Clock置换算法： ①从查寻指针当前位置起扫描内存分页循环队列，选择A=0且M=0的第一个页面淘汰；若未找到，转② ② 开始第二轮扫描，选择A=0且M=1的第一个页面淘汰，同时将经过的所有页面访问位置0；若不能找到，转①
操作系统实验三虚拟存储器管理之模拟页面置换算法（FIFO&LRU）
轻舟终过万重山
11-09 1万+
用C语言模拟先进先出和最近最久未使用的页面置换算法，理解其执行过程
虚拟内存页面置换算法（操作系统）
落灬枫的博客
04-02 2035
通过这次实验，加深对虚拟内存页面置换概念的理解，进一步掌握先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。
虚拟内存页面置换算法（OPT、FIFO、LRU）模拟与实现
weixin_47700137的博客
07-08 1万+
前言 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标：把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 一、常用的页面置换算法 1）最佳置换算法(OPT)：置换时淘汰“未来不再使用的”或“在离当前最远位置上出现的”页面。 2）先进先出置换算法(FIFO)：置换时淘汰最先进入内存的页面，即选择驻留在内存时间最长的页面被置换。 3）最近最久未用置换算法(LRU)：置换时淘汰最近一段时间最久没有使用的页面，即选择上次使
虚拟内存之页面置换算法
2301_76371717的博客
10-30 199
如果没有可用空闲内存块，淘汰访问位为0的页面，将其换出；如果访问位都是1，将其置为0，暂不换出，开始第二轮扫描时，淘汰访问位为0的页面。增加一个修改位，0-未被修改，1-已被修改。如果没有可用空闲内存块，淘汰页面中t值最大的页面，将其换出。只考虑到页面最近是否被访问，未考虑淘汰页面的状态(是否被修改)进行置换。如果没有可用空闲内存块，往右找最远的页面即是要被淘汰的页面，将其换出。如果有可用空闲内存块，缺页不必进行页面置换，直接调入内存即可。如果有可用空闲内存块，缺页不必进行页面置换，直接调入内存即可。
操作系统课设之虚拟内存页面置换算法
qq_62710910的博客
06-22 1150
hnust操作系统课设
《操作系统》LRU和FIFO页面置换算法模拟实战
Zeeland的博客
12-04 2232
本文将介绍如何使用LRU和FIFO实现页面置换的模拟（Python实现），并使用缺页率进行算法的评价。
页面置换算法最佳，FIFO，LRU，随机，简单CLOCK,改进CLOCK.zip
02-24
页面置换算法是操作系统内存管理的重要组成部分，特别是在虚拟内存系统中，用于决定何时以及哪个页面应该从内存中移出，以便为新的页面腾出空间。本程序涵盖了五种常见的页面置换算法：最佳置换算法（OPT）、先进先...
操作系统虚拟分页存储管理，LRU页面置换
01-11
模拟实现虚拟分页存储管理的基本功能，包括内存的分配、内存的回收、地址变换，在发生缺页时采用LRU页面置换算法。 显示每一次内存分配和回收后内存的使用状况，每一个进程占据的内存（页表），计算给定的逻辑地址...
操作系统课程设计之页面置换算法（流程模拟）
12-22
3. **页面置换算法**：常见的页面置换算法有多种，如FIFO（先进先出）、LRU（最近最少使用）、LFU（最不经常使用）、OPT（最佳页面置换）等。这些算法的目标是在有限的内存资源下，尽可能减少因页面缺失（Page Fault...
虚拟内存页面置换算法
02-27
计算机操作系统实验作业，可供借鉴，互相交流，共同进步
操作系统中虚拟内存中的页面置换算法源代码及课设报告
01-15
能够模拟虚拟内存中的页面置换算法对页面进行置换，该程序具备的基本功能为： （1）能够输入进程的页面访问序列或系统自动生成进程的页面访问能序列和分配的内存块数。 （2）可以选择页面置换算法（先进先出算法、最近最久未使用算法和最佳置换算法）。 （3）能够以图表形式显示页面置换过程
页面置换算法实验报告
12-23
通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
虚拟内存管理（FIFO、LRU、OPT）
05-08
在一个请求分页系统中，假如系统分配给一个作业的物理块数为 3，且此作业的页面走向为： 2，3，2，1，5，2，4，5，3，2，3，1 试分别求出用FIFO，LRU，OPT三种算法在程序访问过程中所发生的缺页次数及缺页率？（假设最初页面都在外存）
虚拟内存——页面置换算法1
08-03
4. **时钟页面置换算法（Clock Page Replacement Algorithm）**：时钟算法是LRU和FIFO的折衷方案，使用访问位跟踪页面访问状态。发生缺页时，从指针开始检查访问位为0的页面进行替换。周期性地清零访问位，降低实现...
操作系统课程设计--存储管理 源代码及完整报告
05-30
本设计的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 (1)通过随机数产生一个指令序列，共320条指令。 (2)将指令序列变换成为页地址流。 (3)...
操作系统——虚拟内存和页面置换算法（一文详解操作系统的虚拟内存和页面置换算法）
xdx_dili的博客
11-14 680
操作系统——虚拟内存和页面置换算法（一文详解操作系统的虚拟内存和页面置换算法）
操作系统实验：页面置换算法——FIFO、LRU 代码实现
zhashuang的博客
11-02 5492
通过FIFO、LRU算法实现操作系统页面置换。
操作系统页面置换算法详解（OPT算法、FIFO算法、LRU算法解释+缺页数计算）
热门推荐
流苏的博客
06-15 1万+
操作系统页面置换算法详解（OPT算法、FIFO算法、LRU算法解释+缺页数计算）
【操作系统】虚拟存储管理-页面置换算法
最新发布
兔子王
01-02 1491
【实验内容】设计一个虚拟存储区和一个内存工作区，并使用先进先出（FIFO）算法来计算命中率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值