ucore_lab3 实验报告

最新推荐文章于 2024-07-25 15:50:18 发布
最新推荐文章于 2024-07-25 15:50:18 发布
阅读量484 收藏 4
点赞数
分类专栏： 操作系统 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aikongfu/article/details/125768475
版权

在做完lab1、lab2的实验后接着就是lab3，lab3主要是虚拟内存管理相关的内容，按照lab3的实验指导书的要求，开始做lab3的练习

实验目的

  • 了解虚拟内存的Page Fault异常处理实现
  • 了解页替换算法在操作系统中的实现

实验内容

本次实验是在实验二的基础上，借助于页表机制和实验一中涉及的中断异常处理机制，完成Page Fault异常处理和FIFO页替换算法的实现，结合磁盘提供的缓存空间，从而能够支持虚存管理，提供一个比实际物理内存空间“更大”的虚拟内存空间给系统使用。这个实验与实际操作系统中的实现比较起来要简单，不过需要了解实验一和实验二的具体实现。实际操作系统系统中的虚拟内存管理设计与实现是相当复杂的，涉及到与进程管理系统、文件系统等的交叉访问。如果大家有余力，可以尝试完成扩展练习，实现extended　clock页替换算法。

页面置换算法

局部页面置换算法

置换页面的选择范围仅限于当前进程占用的物理页面内

最佳置换算法（OPT）

Optimal replacement，理想情况下的置换算法，发生缺页时，有些页面在内存中，其中一页将很快被访问，而其他页面可能要到10、100或者1000条指令后才会访问，每个页面都可以用在该页面首次被访问前所要执行的指令数进行标记。

从内存中选择今后不再访问的页面或者在最长一段时间后才需要访问的页面进行淘汰。

先进先出置换算法（FIFO）

先进先出(First In First Out, FIFO)页替换算法：该算法总是淘汰最先进入内存的页，即选择在内存中驻留时间最久的页予以淘汰。只需把一个应用程序在执行过程中已调入内存的页按先后次序链接成一个队列，队列头指向内存中驻留时间最久的页，队列尾指向最近被调入内存的页。这样需要淘汰页时，从队列头很容易查找到需要淘汰的页。FIFO算法只是在应用程序按线性顺序访问地址空间时效果才好，否则效率不高。因为那些常被访问的页，往往在内存中也停留得最久，结果它们因变“老”而不得不被置换出去。FIFO算法的另一个缺点是，它有一种异常现象（Belady现象），即在增加放置页的页帧的情况下，反而使页访问异常次数增多。

最近最少使用（LRU）

Least Recently Used，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰。

时钟置换算法

时钟（Clock）页替换算法：是LRU算法的一种近似实现。时钟页替换算法把各个页面组织成环形链表的形式，类似于一个钟的表面。然后把一个指针（简称当前指针）指向最老的那个页面，即最先进来的那个页面。另外，时钟算法需要在页表项（PTE）中设置了一位访问位来表示此页表项对应的页当前是否被访问过。当该页被访问时，CPU中的MMU硬件将把访问位置“1”。当操作系统需要淘汰页时，对当前指针指向的页所对应的页表项进行查询，如果访问位为“0”，则淘汰该页，如果该页被写过，则还要把它换出到硬盘上；如果访问位为“1”，则将该页表项的此位置“0”，继续访问下一个页。该算法近似地体现了LRU的思想，且易于实现，开销少，需要硬件支持来设置访问位。时钟页替换算法在本质上与FIFO算法是类似的，不同之处是在时钟页替换算法中跳过了访问位为1的页。

改进的时钟页面置换算法（Clock）

改进的时钟（Enhanced Clock）页替换算法：在时钟置换算法中，淘汰一个页面时只考虑了页面是否被访问过，但在实际情况中，还应考虑被淘汰的页面是否被修改过。因为淘汰修改过的页面还需要写回硬盘，使得其置换代价大于未修改过的页面，所以优先淘汰没有修改的页，减少磁盘操作次数。改进的时钟置换算法除了考虑页面的访问情况，还需考虑页面的修改情况。即该算法不但希望淘汰的页面是最近未使用的页，而且还希望被淘汰的页是在主存驻留期间其页面内容未被修改过的。这需要为每一页的对应页表项内容中增加一位引用位和一位修改位。当该页被访问时，CPU中的MMU硬件将把访问位置“1”。当该页被“写”时，CPU中的MMU硬件将把修改位置“1”。这样这两位就存在四种可能的组合情况：（0，0）表示最近未被引用也未被修改，首先选择此页淘汰；（0，1）最近未被使用，但被修改，其次选择；（1，0）最近使用而未修改，再次选择；（1，1）最近使用且修改，最后选择。该算法与时钟算法相比，可进一步减少磁盘的I/O操作次数，但为了查找到一个尽可能适合淘汰的页面，可能需要经过多次扫描，增加了算法本身的执行开销。

全局置换算法

工作集置换算法
缺页率置换算法（PPF）

练习

练习0：填写已有实验

这个简单，直接合代码即可。

练习1：给未被映射的地址映射上物理页（需要编程）

参考实验文档及映射关系图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uwAQGNyR-1657703867129)(https://raw.githubusercontent.com/mingshashan/note-images/doc/image-20220406154748899.png)]

需要关注两个结构体：mm_struct、vma_struct。

mm_struct

// the control struct for a set of vma using the same PDT
struct mm_struct {
    list_entry_t mmap_list;        // vma按照start addr排序的链表 linear list link which sorted by start addr of vma
    struct vma_struct *mmap_cache; // 当前的vma，主要用来提升效率 current accessed vma, used for speed purpose
    pde_t *pgdir;                  // 虚拟页对应的PDT the PDT of these vma 
    int map_count;                 // 虚拟页的数量 the count of these vma
    void *sm_priv;                 // 用于指向swap manager的某个链表,在FIFO算法中，该双向链表用于将可交换的已分配物理页串起来 the private data for swap manager
};

// the virtual continuous memory area(vma), [vm_start, vm_end), 
// addr belong to a vma means  vma.vm_start<= addr <vma.vm_end 
struct vma_struct {
    struct mm_struct *vm_mm; // the set of vma using the same PDT 
    uintptr_t vm_start;      // start addr of vma      
    uintptr_t vm_end;        // end addr of vma, not include the vm_end itself
    uint32_t vm_flags;       // flags of vma
    list_entry_t list_link;  // linear list link which sorted by start addr of vma
};

在trapc.中有对mm_struct的声明：

// 管理虚拟内存页面 
extern struct mm_struct *check_mm_struct;

kern_init->vmm_init->check_vmm->

swap_manager与之前的pmm_manager类似

struct swap_manager
{
     const char *name;
     /* Global initialization for the swap manager */
     int (*init)            (void);
     /* Initialize the priv data inside mm_struct */
     int (*init_mm)         (struct mm_struct *mm);
     /* Called when tick interrupt occured */
     int (*tick_event)      (struct mm_struct *mm);
     /* Called when map a swappable page into the mm_struct */
     int (*map_swappable)   (struct mm_struct *mm, uintptr_t addr, struct Page *page, int swap_in);
     /* When a page is marked as shared, this routine is called to
      * delete the addr entry from the swap manager */
     int (*set_unswappable) (struct mm_struct *mm, uintptr_t addr);
     /* Try to swap out a page, return then victim */
     int (*swap_out_victim) (struct mm_struct *mm, struct Page **ptr_page, int in_tick);
     /* check the page relpacement algorithm */
     int (*check_swap)(void);
};

给未被映射的地址映射上物理页

完成do_pgfault（mm/vmm.c）函数，给未被映射的地址映射上物理页。设置访问权限 的时候需要参考页面所在 VMA 的权限，同时需要注意映射物理页时需要操作内存控制 结构所指定的页表，而不是内核的页表。注意：在

代码如下：

int
do_pgfault(struct mm_struct *mm, uint32_t error_code, uintptr_t addr) {
    // 页访问异常错误码有32位。
    // 位0为1表示对应物理页不存在；
    // 位1为1表示写异常（比如写了只读页；
    // 位2为1表示访问权限异常（比如用户态程序访问内核空间的数据）
    
    // CR2是页故障线性地址寄存器，保存最后一次出现页故障的全32位线性地址。
    // CR2用于发生页异常时报告出错信息。当发生页异常时，处理器把引起页异常的线性地址保存在CR2中。
    // 操作系统中对应的中断服务例程可以检查CR2的内容，从而查出线性地址空间中的哪个页引起本次异常。
    int ret = -E_INVAL;

    // try to find a vma which include addr
    // 根据addr从vma中查找对应的vma_struct
    cprintf("do_pgfault|-------> mm = [%p], error_code = [%x], addr = [%x], ret = [%x]\n", mm, error_code, addr, ret);
    struct vma_struct *vma = find_vma(mm, addr);

    pgfault_num++;
    //If the addr is in the range of a mm's vma?
    cprintf("do_pgfault|-------> mm = [%p], vma = [%p], addr = [%x]\n", mm, vma, addr);
    if (vma == NULL || vma->vm_start > addr) {
        cprintf("not valid addr %x, and  can not find it in vma\n", addr);
        goto failed;
    }
    //check the error_code
    // 与 00000011
    // 
    switch (error_code & 3) {
    default:
            /* error code flag : default is 3 ( W/R=1, P=1): write, present */
    case 2: /* error code flag : (W/R=1, P=0): write, not present */
        if (!(vma->vm_flags & VM_WRITE)) {
            cprintf("do_pgfault failed: error code flag = write AND not present, but the addr's vma cannot write\n");
            goto failed;
        }
        break;
    case 1: /* error code flag : (W/R=0, P=1): read, present */
        cprintf("do_pgfault failed: error code flag = read AND present\n");
        goto failed;
    case 0: /* error code flag : (W/R=0, P=0): read, not present */
        if (!(vma->vm_flags & (VM_READ | VM_EXEC))) {
            cprintf("do_pgfault failed: error code flag = read AND not present, but the addr's vma cannot read or exec\n");
            goto failed;
        }
    }
    /* IF (write an existed addr ) OR
     *    (write an non_existed addr && addr is writable) OR
     *    (read  an non_existed addr && addr is readable)
     * THEN
     *    continue process
     */
    uint32_t perm = PTE_U;
    if (vma->vm_flags & VM_WRITE) {
        perm |= PTE_W;
    }
    addr = ROUNDDOWN(addr, PGSIZE);

    ret = -E_NO_MEM;

    pte_t *ptep=NULL;
    // 根据get_pte来获取pte如果不存在，则分配一个新的
    ptep = get_pte(mm->pgdir, addr, 1);
    if (ptep == NULL) {
        cprintf("get_pte in do_pgfault failed\n");
        goto failed;
    }
    struct Page *p;
    // 如果对应的物理页不存在，分配一个新的页，且把物理地址和逻辑地址映射 
    if (*ptep == 0) {
        p = pgdir_alloc_page(mm->pgdir, addr, perm);
        if (p == NULL) {
            cprintf("alloc_page in do_pgfault failed\n");
            goto failed;
        }
    } else {
        // 如果不全为0，则可能被交换到了swap磁盘中
        if(swap_init_ok) {
            struct Page *page=NULL;
            int swapIn;
            // 从磁盘中换出
            swapIn = swap_in(mm, addr, &page);
            if (swapIn != 0) {
                cprintf("swap_in in do_pgfault failed\n");
                goto failed;
            }

            // build the map of phy addr of an Page with the linear addr la
            page_insert(mm->pgdir, page, addr, perm);
            // if (page_insert(mm->pgdir, page, addr, perm) != 0) {
            //     cprintf("page_insert in do_pgfault failed\n");
            //     goto failed;
            // }

            swap_map_swappable(mm, addr, page, 1);
            page->pra_vaddr = addr;
        } else {
            cprintf("no swap_init_ok, but ptep is %x, failed\n", *ptep);
            goto failed;
        }
    }
   ret = 0;
failed:
    cprintf("ret = [%d]\n", ret);
    return ret;
}

实现过程：

1、根据addr查找对应的vma，然后pgfault_num（全局变量pgfault自增加1）

2、校验error_code，设置perm权限（如果可写，perm |= PTE_W）

3、addr以PAGE_SIZE向下取整

4、调用get_pte，来获取PTE（如果没有，则分配一个新的）

5、如果获取的pte为0（对应的物理页不存在），分配新的页（调用pgdir_alloc_page），且把物理地下和逻辑地址映射

6、如果获取的pte不全为0，则可能当前页被交换到了swap磁盘中，则从磁盘中换出

7、页的物理地址与线性地址映射

8、调用swap_map_swappable，把当前页加入队列（链表）尾部

  • 请描述页目录项（Page Directory Entry）和页表项（Page Table Entry）中组成部分对ucore实现页替换算法的潜在用处。（lab2学习过PDE与PTE的结构区别）

    image-20220307141425215

    从结构上可以看出来，页目录项（Page Directory Entry）和页表项（Page Table Entry）差不多，只是12-31位代表的含义不相同。

    • P 存在位（present）

    • R/W 读/写位（Read/Write）

    • U/S 访问该页需要的特权级

    • PWT write through（为1表示此项采用通写方式，表示该页不仅是普通内存，还是高速缓存）

    • PCD 若为1表示该页启用高速缓存，为0表示禁止将该页缓存

    • A 访问位，若为1表示该页被 CPU 访问过啦，所以该位是由 CPU 设置的。

    • D 脏页位，当 CPU 个页面执行写操作时，就会设置对应页表项的D位为 1，此项仅针对页表项有效，并不会修改页目录项中的位。

    • PAT 页属性位，在页一级的粒度上设置内存属性。

    • G 全局位，与TLB有关，为1表示该页是全局页，该页在高速缓存TLB中一直保存。

    • Avail 可用位，为1表示用户进程可用该页，为0则不可用。对操作系统无效。

    LAB3中，如果PTE都为0，则需要分配页，而如果高20位不为零，则代表页被换到swap磁盘中。

  • 如果ucore的缺页服务例程在执行过程中访问内存，出现了页访问异常，请问硬件要做哪些事情？

    • 将发生page fault的线性地址（linear address）保存到CR2寄存器中
    • 压栈EFLAGS，CS，EIP，ErrorCode、trapno等到栈（内核栈）中
    • 保存上下文
    • 执行新的缺页中断程序（pgfault_handler）处理，分配页（可能发生页置换）
    • 恢复上下文
    • 继续执行上一级的缺页服务例程
练习2：补充完成基于FIFO的页面替换算法（需要编程）

完成vmm.c中的do_pgfault函数，并且在实现FIFO算法的swap_fifo.c中完成map_swappable和swap_out_victim函数。练习2相对比较简单

/*
 * (3)_fifo_map_swappable: According FIFO PRA, we should link the most recent arrival page at the back of pra_list_head qeueue
 */
static int
_fifo_map_swappable(struct mm_struct *mm, uintptr_t addr, struct Page *page, int swap_in)
{
    list_entry_t *head=(list_entry_t*) mm->sm_priv;
    list_entry_t *entry=&(page->pra_page_link);
 
    assert(entry != NULL && head != NULL);
    //record the page access situlation
    /*LAB3 EXERCISE 2: YOUR CODE*/ 
    //(1)link the most recent arrival page at the back of the pra_list_head qeueue.
    list_add(head, entry);
    return 0;
}
/*
 *  (4)_fifo_swap_out_victim: According FIFO PRA, we should unlink the  earliest arrival page in front of pra_list_head qeueue,
 *                            then set the addr of addr of this page to ptr_page.
 */
static int
_fifo_swap_out_victim(struct mm_struct *mm, struct Page ** ptr_page, int in_tick)
{
    list_entry_t *head=(list_entry_t*) mm->sm_priv;
    assert(head != NULL);
    assert(in_tick==0);
    /* Select the victim */
    /*LAB3 EXERCISE 2: YOUR CODE*/ 
    //(1)  unlink the  earliest arrival page in front of pra_list_head qeueue
    //(2)  set the addr of addr of this page to ptr_page
    list_entry_t *le = head->prev;
    assert(le != NULL);
    assert(le != head);

    list_del(le);

    struct Page *p = le2page(le, pra_page_link);
    assert(p != NULL);
    *ptr_page = p;
    
    return 0;
}

请在实验报告中简要说明你的设计实现过程。

_fifo_map_swappable即把page加到链表尾。

_fifo_swap_out_victim即把要置换的页（在链表头）找出给ptr_page，删除在链表中对应的元素

请在实验报告中回答如下问题：

  • 如果要在ucore上实现"extended clock页替换算法"请给你的设计方案，现有的swap_manager框架是否足以支持在ucore中实现此算法？如果是，请给你的设计方案。如果不是，请给出你的新的扩展和基此扩展的设计方案。并需要回答如下问题

    现有框架可以支持

    • 需要被换出的页的特征是什么？

      PTE_P（Present）和PTE_D（Dirty）都为0

    • 在ucore中如何判断具有这样特征的页？

      获取线性地址对应的页表项，再使用位运算判断PTE_P（Present）和PTE_D（Dirty），（addr & PTE_P && addr & PTE_D）

    • 何时进行换入和换出操作？

      缺页时换入（换入到swap磁盘）

      物理页帧满时换出（换出到swap磁盘），不过要注意dirtybit的处理。可以在修改dirtybit的时候写入外存，或者在最终删除该物理页时再写入外存。或者有利于多个写操作的合并，降低缺页代价，但此时的页替换算法退化成普通的clock算法，而不是extended clock算法。

扩展练习 Challenge 1：实现识别dirty bit的 extended clock页替换算法（需要编程）

参考：ucoreOS_lab3 实验报告与操作系统-uCore-Lab-3

在FIFO的基础上，实现swap_out_victim函数即可。

该函数中查找一块可用于换出的物理页，最多只需要遍历三次：

  • 查找!PTE_A&!PTE_D（<0, 0>）同时重置当前的PTE_A，为第二次遍历准备
  • 查找!PTE_A&!PTE_D（<0, 0>）同时重置当前的PTE_D，为第三次遍历准备
  • 查找!PTE_A&!PTE_D（<0, 0>），肯定能找到（因为之前分别重置了PTE_A与PTE_D）

即：

  1. 首先，查找标记为<0,0>的页面；
  2. 如果上一步没有找到，查找标记<0,1>，并将访问过的页面的访问位清零；
  3. 如果上一步没有找到，再次查找标记为<0,0>的页面；
  4. 如果上一步没有找到，再次查找标记为<0,1>的页面；

这里需要注意对于PTE_D的操作，若第一次、第二次遍历都找不到符合要求的物理页，则必须对PTE_D下手，重置该标志位。还有一点需要注意，在每次修改PTE标志位后，都需要重置TLB缓存。

代码如下：

swap_extended_clock.h

#ifndef __KERN_MM_SWAP_EXTEND_CLOCK_H__
#define __KERN_MM_SWAP_EXTEND_CLOCK_H__

#include <swap.h>
extern struct swap_manager swap_manager_extend_clock;

#endif

swap_extended_clock.c

#include <defs.h>
#include <x86.h>
#include <stdio.h>
#include <string.h>
#include <swap.h>
#include <swap_extended_clock.h>
#include <list.h>

static pte_t *_get_list_entry_pte(pte_t *pgdir, list_entry_t *le) {
    struct Page *p = le2page(le, pra_page_link);
    uintptr_t pra_vaddr = p->pra_vaddr;
    pte_t *ptep = get_pte(pgdir, pra_vaddr, 0);
    return ptep;
}

static int _get_dirty_flag(pte_t *pgdir, list_entry_t *le) {
    pte_t *ptep = _get_list_entry_pte(pgdir, le);
    return (*ptep) & PTE_D;
}

static int _get_accessed_flag(pte_t *pgdir, list_entry_t *le) {
    pte_t *ptep = _get_list_entry_pte(pgdir, le);
    return (*ptep) & PTE_A;
}

static _clear_accessed_flag(pte_t *pgdir, list_entry_t *le) {
    do {
        struct Page *p = le2page(le, pra_page_link);
        pte_t *ptep = get_pte(pgdir, p->pra_vaddr, 0);
        *ptep = *ptep & ~PTE_A;
        tlb_invalidate(pgdir, p->pra_vaddr);
    } while (0);
}

static int _extended_clock_init_mm(struct mm_struct *mm)
{   
    mm->sm_priv = NULL;
    return 0;
}
/*
 * (3)_extended_clock_map_swappable: According FIFO PRA, we should link the most recent arrival page at the back of pra_list_head qeueue
 */
static int
_extended_clock_map_swappable(struct mm_struct *mm, uintptr_t addr, struct Page *page, int swap_in)
{
    list_entry_t *head = (list_entry_t *)mm->sm_priv;
    list_entry_t *entry = &(page->pra_page_link);

    assert(entry != NULL);

    if (head == NULL) {
        list_init(entry);
        mm->sm_priv = entry;
    } else {
        list_add_before(head, entry);
    }

    return 0;
}
/*
 *  (4)_extended_clock_swap_out_victim: According FIFO PRA, we should unlink the  earliest arrival page in front of pra_list_head qeueue,
 *                            then set the addr of addr of this page to ptr_page.
 */
static int
_extended_clock_swap_out_victim(struct mm_struct *mm, struct Page ** ptr_page, int in_tick)
{
    list_entry_t *head = (list_entry_t *)mm->sm_priv;
    assert(head != NULL);
    assert(in_tick == 0);

    list_entry_t *selected = NULL, *p = head;

    // search <0, 0>
    do {
        if (_get_accessed_flag(mm->pgdir, p) == 0 && _get_dirty_flag(mm->pgdir, p) == 0) {
            selected = p;
            break;
        }
        p = list_next(p);
    }while (p != head);
    // search <0, 1> and set 'accessed' to 0
    if (selected == NULL) {
        if (_get_accessed_flag(mm->pgdir, p) == 0 && _get_dirty_flag(mm->pgdir, p)) {
            selected = p;
            break;
        }
        _clear_accessed_flag(mm->pgdir, p);
        p = list_next(p);
    }

    // search <0, 0> again
    do {
        if (_get_accessed_flag(mm->pgdir, p) == 0 && _get_dirty_flag(mm->pgdir, p) == 0) {
            selected = p;
            break;
        }
        p = list_next(p);
    }while (p != head);
    // search <0, 1> and set 'accessed' to 0 again
    if (selected == NULL) {
        if (_get_accessed_flag(mm->pgdir, p) == 0 && _get_dirty_flag(mm->pgdir, p)) {
            selected = p;
            break;
        }
        _clear_accessed_flag(mm->pgdir, p);
        p = list_next(p);
    }

    head = selected;
    if (list_empty(head)) {
        mm->sm_priv = NULL;
    } else {
        mm->sm_priv = list_next(head);
        list_del(head);
    }

    *ptr_page = le2page(head, pra_page_link);

    return 0;
}

static int
_extended_clock_check_swap(void) {
    cprintf("write Virt Page c in fifo_check_swap\n");
    *(unsigned char *)0x3000 = 0x0c;
    assert(pgfault_num==4);
    cprintf("write Virt Page a in fifo_check_swap\n");
    *(unsigned char *)0x1000 = 0x0a;
    assert(pgfault_num==4);
    cprintf("write Virt Page d in fifo_check_swap\n");
    *(unsigned char *)0x4000 = 0x0d;
    assert(pgfault_num==4);
    cprintf("write Virt Page b in fifo_check_swap\n");
    *(unsigned char *)0x2000 = 0x0b;
    assert(pgfault_num==4);
    cprintf("write Virt Page e in fifo_check_swap\n");
    *(unsigned char *)0x5000 = 0x0e;
    assert(pgfault_num==5);
    cprintf("write Virt Page b in fifo_check_swap\n");
    *(unsigned char *)0x2000 = 0x0b;
    assert(pgfault_num==5);
    cprintf("write Virt Page a in fifo_check_swap\n");
    *(unsigned char *)0x1000 = 0x0a;
    assert(pgfault_num==6);
    cprintf("write Virt Page b in fifo_check_swap\n");
    *(unsigned char *)0x2000 = 0x0b;
    assert(pgfault_num==6);
    cprintf("write Virt Page c in fifo_check_swap\n");
    *(unsigned char *)0x3000 = 0x0c;
    assert(pgfault_num==7);
    cprintf("write Virt Page d in fifo_check_swap\n");
    *(unsigned char *)0x4000 = 0x0d;
    assert(pgfault_num==8);
    cprintf("write Virt Page e in fifo_check_swap\n");
    *(unsigned char *)0x5000 = 0x0e;
    assert(pgfault_num==9);
    cprintf("write Virt Page a in fifo_check_swap\n");
    assert(*(unsigned char *)0x1000 == 0x0a);
    *(unsigned char *)0x1000 = 0x0a;
    assert(pgfault_num==9);
    cprintf("read Virt Page b in fifo_check_swap\n");
    assert(*(unsigned char *)0x2000 == 0x0b);
    assert(pgfault_num==10);
    cprintf("read Virt Page c in fifo_check_swap\n");
    assert(*(unsigned char *)0x3000 == 0x0c);
    assert(pgfault_num==11);
    cprintf("read Virt Page a in fifo_check_swap\n");
    assert(*(unsigned char *)0x1000 == 0x0a);
    assert(pgfault_num==12);
    cprintf("read Virt Page d in fifo_check_swap\n");
    assert(*(unsigned char *)0x4000 == 0x0d);
    assert(pgfault_num==13);
    cprintf("read Virt Page b in fifo_check_swap\n");
    *(unsigned char *)0x1000 = 0x0a;
    assert(*(unsigned char *)0x3000 == 0x0c);
    assert(*(unsigned char *)0x4000 == 0x0d);
    assert(*(unsigned char *)0x5000 == 0x0e);
    assert(*(unsigned char *)0x2000 == 0x0b);
    assert(pgfault_num==14);
    return 0;
}


static int
_extended_clock_init(void)
{
    return 0;
}

static int
_extended_clock_set_unswappable(struct mm_struct *mm, uintptr_t addr)
{
    return 0;
}

static int
_extended_clock_tick_event(struct mm_struct *mm)
{ return 0; }


struct swap_manager swap_manager_extended_clock =
{
     .name            = "extended clock swap manager",
     .init            = &_extended_clock_init,
     .init_mm         = &_extended_clock_init_mm,
     .tick_event      = &_extended_clock_tick_event,
     .map_swappable   = &_extended_clock_map_swappable,
     .set_unswappable = &_extended_clock_set_unswappable,
     .swap_out_victim = &_extended_clock_swap_out_victim,
     .check_swap      = &_extended_clock_check_swap,
};
扩展练习 Challenge 2：实现不考虑实现开销和效率的LRU页替换算法（需要编程）

challenge部分不是必做部分，不过在正确最后会酌情加分。需写出有详细的设计、分析和测试的实验报告。完成出色的可获得适当加分。

这个后面再补上

参考：

LRU

页面置换算法

uCore-3

操作系统-uCore-Lab-3

ucoreOS_lab3 实验报告

page-rep3.dvi

Paging - OSDev Wiki

鸣沙山
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ucore lab实验总结（代码+报告）
08-02
ucore lab实验是操作系统课程中常见的一系列实践项目，它主要涵盖了操作系统的核心概念和技术，让学生通过实际编程深入理解操作系统的工作原理。在这个实验中，你可能会接触到以下关键知识点： 1. **进程管理**：...
清华OS实验指导书ucore_os_docs1
08-03
1. 在学堂在线查看OS相关原理和labX的视频 2. 在实验指导书 on gitbook上阅读实验指导书，并参考其内容完成练习和实验报告 3. 在实验环境中完
ucore_lab2实验报告
一斗水的专栏
03-07 1182
lab1的实验完成后开始lab2，lab2主要是实现内存分配 实验目的： 理解基于段页式内存地址的转换机制 理解页表的建立和使用方法 理解物理内存的管理方法 在lab1的时候我们用的是段式管理，涉及到的地址都是物理地址。而lab2需要建立段页式内管管理机制。从应用程序的使用角度看是不关心具体对应的物理内存的，操作系统提供一个可用的连续内存空间（虚拟的）给应用程序使用，这样会更方便应用程序编写。 lab2主要分三部分： 首先要了解的是如何发现系统（硬件）的物理内存 建立对物理内存的初步管理 页
ucore_lab6实验报告
一斗水的专栏
09-19 374
实验目的熟悉ucore的系统调度器框架，以及基于此框架的Round-Robin（RR） 调度算法。然后参考RR调度算法的实现，完成Stride Scheduling调度算法。
ucore_lab4实验报告
一斗水的专栏
07-13 584
实验目的：本次实验将首先接触的是内核线程的管理。内核线程是一种特殊的进程，内核线程与用户进程的区别有两个：进程是资源分配单位，线程是CPU调度单位。本实验依赖实验1/2/3。请把你做的实验1/2/3的代码填入本实验中代码中有“LAB1”,“LAB2”,“LAB3”的注释相应部分。和前面一样，直接合并代码即可alloc_proc函数（位于kern/process/proc.c中）负责分配并返回一个新的struct proc_struct结构，用于存储新建立的内核线程的管理信息。ucore需要对这个结构进行最基
ucore_lab8 实验报告
一斗水的专栏
12-27 310
实验目的通过完成本次实验，希望能达到以下目标某操作系统中建立了一个基于索引节点(index node)结构的文件系统very simple file system, 简称vsfs。vsfs的用户操作包括(以函数形式表示):mkdir(“str”) - 创建一个新目录,目录名称为”str”creat(“str”) - 创建一个空文件,空文件名称为“str”
ucore_lab5实验报告
一斗水的专栏
08-23 586
让用户进程在用户态执行，且在需要ucore支持时，可通过系统调用来让ucore提供服务。为此需要构造出第一个用户进程，并通过系统调用sys_fork/sys_exec/sys_exit/sys_wait来支持运行不同的应用程序，完成对用户进程的执行过程的基本管理。
操作系统实验ucore_lab8实验报告
JustinAustin的博客
03-11 1162
lab8 练习0：填写已有实验 proc.c default_pmm.c pmm.c swap_fifo.c vmm.c trap.c sche.c monitor. check_sync.c 练习1: 完成读文件操作的实现（需要编码） 首先了解打开文件的处理流程，然后参考本实验后续的文件读写操作的过程分析，编写在sfs_inode.c中sfs_io_nolock读文件中数据的实现代码。 请在实验报告中给出设计实现”UNIX的PIPE机制“的概要设方案，鼓励给出详细设计方案 当进行文件读取/写入操作时
ucore_lab7实验报告
一斗水的专栏
10-20 352
管程是由局部于自己的若干公共变量及其说明和所有访问这些公共变量的过程所组成的软件模块。
清华操作系统实验ucore_lab2
JustinAustin的博客
12-12 2754
lab2 实验目的 理解基于段页式内存地址的转换机制 理解页表的建立和使用方法 理解物理内存的管理方法 练习0： 需要更改的文件为kdebug.c和trap.c，具体更改的代码如下： kdebug.c: uint32_t t_ebp = read_ebp(); uint32_t t_eip = read_eip(); int i,j; for(i = 0;i< STACKFRAME_DEPTH && t_ebp!=0;i++) { cprintf("ebp=%08x,e
操作系统实验ucore_lab5实验报告
JustinAustin的博客
03-11 918
ucore_lab5 练习0： 修改proc.c ， default_pmm.c ， pmm.c ， swap_fifo.c ， vmm.c ， trap.c文件中的代码即可。 练习1： 加载应用程序并执行（需要编码） 题目概述： ​ do_execv函数调用load_icode（位于kern/process/proc.c中）来加载并解析一个处于内存中的ELF执行文件格式的应用程序，建立相应的用户内存空间来放置应用程序的代码段、数据段等，且要设置好proc_struct结构中的成员变量trapframe
HNU 操作系统 8次ucorelab实验 满分代码
07-21
这里包含了每次实验的满分代码，因为博主自己做实验时，及时参考网上的其他大佬的实验报告和代码，直接放进去都不一定对，就每个lab的实验0自己做有可能有错，即使把答案直接搬进去，也不一定对，当时可气死我了。...
nachos实验报告 2 lab2
09-13
北大 操作系统 nachos实验报告 实验2 非常认真完成的报告
操作系统ucore实验lab1~lab6答案版
06-08
在这个"操作系统ucore实验lab1~lab6答案版"的压缩包中，包含了完整的实验解决方案，对于正在学习ucore或操作系统的学生来说，这是一个宝贵的参考资料。 首先，我们要了解ucore是一个开源的操作系统内核，它是专门为...
Windows 下的sqlserver数据拷贝到linux
cyw8998的专栏
07-25 277
2.在 >1 提示符下，输入以下 RESTORE DATABASE 命令，并在每行后按 Enter（无法同时复制和粘贴整个多行命令）。将出现的所有 gpdb 替换为数据库的名称。1.启动 sqlcmd。下面的示例以 SA 用户身份连接到本地 SQL Server。出现提示时输入密码，或使用 -P 参数指定密码。SSH打开linux终端。
Linux：进程信号（二.信号的保存与处理、递达、volatile关键字、SIGCHLD信号）
qq_74415153的博客
07-25 1192
1.信号保存 1.1递达、未决、阻塞等概念 1.2再次理解信号产生与保存 1.3信号集操作函数 sigset_t类型 sigprocmask系统调用 sigpending系统调用 2.信号的处理/递达 2.1信号处理时机与过程 2.2用户态和内核态 2.3再看进程地址空间 谁来运行OS 2.4信号的捕捉-sigaction()函数 3.补充知识 3.1可重入函数 3.2volatile关键字 3.3 SIGCHLD信号
【Linux】通过分配虚拟内存的方式来解决因内存不够而导致部署的项目自动挂掉
smile_sundays的博客
07-24 782
（6）这样配置，每次服务器重启，就没了，所以设置开机自动挂载 Swap 分区，编辑文件 /etc/fstab，在下面加入：/var/swap　　swap　　swap　　default　　0 0。第一种方法：进行JVM调优可以改善这种情况，但是项目太多，我们的个人服务器配置实在太低，仍然无法解决此问题，这里不做讨论了。（5）启动完项目后，执行： ps aux | grep java 查看所有服务，看看是否还会再挂，一般就不会了。（2）划分虚拟内存分区（大小为2G），执行命令会卡一小会无响应。
Linux初学基本命令
最新发布
yuan20010401的博客
07-25 620
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
实验3：ucore_lab物理内存管理与页表操作
实验3是针对操作系统中的物理内存管理进行的实践，其目标在于帮助学生深入理解基于段页式的内存地址转换机制、页表的建立和使用，以及物理内存的基本管理方法。实验中涉及的主要知识点包括： 1. **页目录项（Page ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值