【操作系统】MIT 6.s081 LAB5

已于 2022-02-19 11:28:06 修改
阅读量5k 收藏
点赞数
分类专栏： 操作系统 C/C++ 文章标签： mit 操作系统 unix
于 2022-02-02 13:56:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38036381/article/details/122769214
版权

Lab5: xv6 lazy page allocation

原文地址：YSBLOG
参考资料：
https://juejin.cn/post/7034359064121311240
https://blog.miigon.net/posts/s081-lab5-lazy-page-allocation/

实验目的：实现延迟分配用户空间堆内存，在调用sbrk()的时候，不立即分配内存，而是当内存页面真正被访问时才进行实际的物理内存分配。

为了方便总结，这次一起把三个任务同时完成。

首先修改sys_sbrk()让其在调用时不实际分配内存，而是进行记录。

// sysproc.c
uint64
sys_sbrk(void)
{
  int addr;
  int n;

  if(argint(0, &n) < 0)
    return -1;
  addr = myproc()->sz;
  myproc()->sz += n; // 只增加sz的数值大小，不实际分配内存
  if (n < 0) { // n小于0的情况为释放内存，立即执行
    uvmdealloc(myproc()->pagetable, addr, myproc()->sz);
  }
  // if(growproc(n) < 0)
  //   return -1;
  return addr;
}

修改后，运行系统执行echo hi，结果如下：

image-20220129190821528

如图所示，执行echo hi后我们得到了一个page fault，是因为在Shell中执行程序，Shell会先fork一个子进程，子进程会通过exec执行echo，而这个过程中会先sys_sbrk()申请一些内存，但因为我们修改了代码，这个没有实际分配内存，所以出错了。通过错误信息可以看到，此时SCAUSE寄存器的值为15，表面这是一个store page fault，同时pid为3，这时Shell的pid，SPEC中保存进入内核前的pc地址为0x12ac，STVAL寄存器保存出错的虚拟地址0x4008。

第二步，完成惰性内存分配的实现。在vm.c中实现lazyalloc，记得在defs.h中添加声明。在执行惰性内存分配时需要确认当前地址是否是由于惰性内存分配而导致的缺页。

uint64 lazyalloc(struct proc *p, uint64 va) {
  pte_t *pte; // 虚拟地址的页表现
  if (va < p->sz // 虚拟地址小于当前进程逻辑上分配的地址大小
  && PGROUNDDOWN(va) != r_sp() // 虚拟地址不能位于栈底的页面，因为栈底的页面存在一个guard page不能访问，用于检测stack overflow错误
  && ( ((pte = walk(p->pagetable, va, 0)) == 0) || ((*pte & PTE_V) == 0)) // 页表项当前不存在
  ) {
    char* mem = kalloc(); // 分配一页内存
    if (mem == 0) {
      printf("lazy alloc : out of memory\n");
      p->killed = 1;
    } else {
      memset(mem, 0, PGSIZE);
      // 将申请的物理内存与虚拟地址进行映射
      if (mappages(p->pagetable, PGROUNDDOWN(va), PGSIZE,
       (uint64)mem, PTE_W|PTE_X|PTE_R|PTE_U) != 0) {
         // 映射失败
          printf("lazy alloc : failed to map page\n");
          kfree(mem);
         p->killed = 1;
       }
       return (uint64)mem;
    }
  }

  return 0;
}

第三步，需要在实际访问内存时判端，若存在缺页，则调用lazyalloc。

这里的处理方式与lab4差不多，可以通过r_scause()在陷入时判断陷入的原因，若下入的原因为13则为读缺页，若陷入原因为15为写缺页。

// trap.c
void
usertrap(void)
{
  ... ...
  } else if((which_dev = devintr()) != 0){
    // ok
  } else if ((r_scause() == 13 || r_scause() == 15)) {
    // 当读缺页或者写缺页引起中断时，进行惰性内存分配
    if (lazyalloc(p, r_stval()) <= 0) {
      p->killed = 1;
    }
  } else {
    printf("usertrap(): unexpected scause %p pid=%d\n", r_scause(), p->pid);
    printf("            sepc=%p stval=%p\n", r_sepc(), r_stval());
    p->killed = 1;
  }

 ... ...
}


// vm.c
uint64
walkaddr(pagetable_t pagetable, uint64 va)
{
  pte_t *pte;
  uint64 pa;

  if(va >= MAXVA)
    return 0;

  pte = walk(pagetable, va, 0);
  if ((pte == 0) ||((*pte & PTE_V) == 0) ||  ((*pte & PTE_U) == 0)) {
    // 缺页时进行惰性内存分配
    if ((pa = lazyalloc(myproc(), va)) <= 0) {
      // 惰性内存分配失败
      pa = 0;
    }
  } else {
    pa = PTE2PA(*pte);
  }

  return pa;
}

第四步，解决painc。由于原本的xv6中没有惰性分配策略，所以当页面在映射、拷贝以及取消映射时检测到页面权限不正确或者访问失败时会进行painc报错，但在加入惰性分配策略后，页面在未实际读写数据之前可能并不存在，所以我们需要忽略对应的painc（这并不影响拷贝和映射的执行的正确性）。

// vm.c
int
mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm)
{
  uint64 a, last;
  pte_t *pte;

  a = PGROUNDDOWN(va);
  last = PGROUNDDOWN(va + size - 1);
  for(;;){
    if((pte = walk(pagetable, a, 1)) == 0)
      return -1;
    // 忽视页面权限问题，直接进行映射
    // if(*pte & PTE_V) 
      // panic("remap");
    *pte = PA2PTE(pa) | perm | PTE_V;
    if(a == last)
      break;
    a += PGSIZE;
    pa += PGSIZE;
  }
  return 0;
}

// vm.c
void
uvmunmap(pagetable_t pagetable, uint64 va, uint64 npages, int do_free)
{
  uint64 a;
  pte_t *pte;

  if((va % PGSIZE) != 0)
    panic("uvmunmap: not aligned");

  for(a = va; a < va + npages*PGSIZE; a += PGSIZE){
    // 跳过不存在的页面
    if((pte = walk(pagetable, a, 0)) == 0)
      // panic("uvmunmap: walk");
      continue;
    if((*pte & PTE_V) == 0)
      // panic("uvmunmap: not mapped");
      continue;
    if(PTE_FLAGS(*pte) == PTE_V)
      panic("uvmunmap: not a leaf");
    if(do_free){
      uint64 pa = PTE2PA(*pte);
      kfree((void*)pa);
    }
    *pte = 0;
  }
}

// vm.c
int
uvmcopy(pagetable_t old, pagetable_t new, uint64 sz)
{
  pte_t *pte;
  uint64 pa, i;
  uint flags;
  char *mem;

  for(i = 0; i < sz; i += PGSIZE){
    // 跳过不存在的页面
    if((pte = walk(old, i, 0)) == 0)
      continue;
      // panic("uvmcopy: pte should exist");
    if((*pte & PTE_V) == 0)
      continue;
      // panic("uvmcopy: page not present");
    pa = PTE2PA(*pte);
    flags = PTE_FLAGS(*pte);
    if((mem = kalloc()) == 0)
      goto err;
    memmove(mem, (char*)pa, PGSIZE);
    if(mappages(new, i, PGSIZE, (uint64)mem, flags) != 0){
      kfree(mem);
      goto err;
    }
  }
  return 0;

 err:
  uvmunmap(new, 0, i / PGSIZE, 1);
  return -1;
}

使用echo hi，lazytests，usertests进行测试，结果如下：

xv6 kernel is booting

hart 1 starting
hart 2 starting
init: starting sh
$ echo hi
hi
$ lazytests
lazytests starting
running test lazy alloc
test lazy alloc: OK
running test lazy unmap
test lazy unmap: OK
running test out of memory
test out of memory: OK
ALL TESTS PASSED
$ usertests
usertests starting
lazy alloc : out of memory
test execout: lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
lazy alloc : out of memory
OK
test copyin: OK
test copyout: OK
test copyinstr1: OK
test copyinstr2: OK
test copyinstr3: OK
test rwsbrk: OK
test truncate1: OK
test truncate2: OK
test truncate3: OK
test reparent2: OK
test pgbug: OK
test sbrkbugs: usertrap(): unexpected scause 0x000000000000000c pid=3305
            sepc=0x0000000000005580 stval=0x0000000000005580
OK
test badarg: OK
test reparent: OK
test twochildren: OK
test forkfork: OK
test forkforkfork: OK
test argptest: OK
test createdelete: OK
test linkunlink: OK
test linktest: OK
test unlinkread: OK
test concreate: OK
test subdir: OK
test fourfiles: OK
test sharedfd: OK
test exectest: OK
test bigargtest: OK
test bigwrite: OK
test bsstest: OK
test sbrkbasic: lazy alloc : out of memory
OK
test sbrkmuch: OK
test kernmem: OK
test sbrkfail: lazy alloc : out of memory
OK
test sbrkarg: OK
test validatetest: OK
test stacktest: OK
test opentest: OK
test writetest: OK
test writebig: OK
test createtest: OK
test openiput: OK
test exitiput: OK
test iput: OK
test mem: lazy alloc : out of memory
OK
test pipe1: OK
test preempt: kill... wait... OK
test exitwait: OK
test rmdot: OK
test fourteen: OK
test bigfile: OK
test dirfile: OK
test iref: OK
test forktest: OK
test bigdir: OK
lazy alloc : out of memory
ALL TESTS PASSED
$
Horizon_ys
关注
专栏目录
MIT6.S081学习总结-lab5:lazy page allocation
laplacebh的博客
06-28 910
lab5 是lazy page allocationi相关,主要解决页面错误问题。O/S可以对页表硬件使用的许多巧妙技巧之一是延迟分配用户空间堆内存。Xv6应用程序使用sbrk()系统调用向内核请求堆内存。在我们给出的内核中，sbrk()分配物理内存并将其映射到进程的虚拟地址空间。内核为一个较大的请求分配和映射内存可能需要很长时间。例如，考虑一个gb由262,144 4096字节的页组成;即使每一种都很便宜，这也是一笔巨大的投资。此外，一些程序分配的内存比实际使用的要多(例如，实现稀疏数组)，或者在使用之前
MIT 6.S081 Lab2
NP_hard的博客
11-13 1326
文章目录System call traceSysinfo System call trace In this assignment you will add a system call tracing feature that may help you when debugging later labs. You’ll create a new trace system call that will control tracing. It should take one argument, an inte
6.S081 lab5: lazy
passenger12234的博客
06-13 556
主要记录下我在写这个lab的时候遇到的问题，具体的代码网上已经有很多了 。 BUG1 理论上来讲，vm.c文件中freewalk的panic是不需要注释掉的，当时写的时候老是报错 panic freewalk: leaf 后来发现问题出在trap函数中： else if((r_scause() == 13 || r_scause() == 15) && r_stval() >= p->heap_start){ uint64 vmaddr = r_stval(); i
MIT6.S081最详解析与归纳——lab5:Lazy allocation
最新发布
qq_45456064的博客
07-26 738
写时复制懒惰分配按需调页按需补零内存映射文件。
6.S081的Lab学习——Lab5: xv6 lazy page allocation
qq_43264167的博客
05-29 1890
一个本硕双非的小菜鸡，备战24年秋招。打算尝试6.S081，将它的Lab逐一实现，并记录期间心酸历程。
操作系统MIT6.S081：Lab5-＞Lazy allocation
InnerPeaceHQ的博客
08-19 2218
本系列文章为MIT6.S081的学习笔记，包含了参考手册、课程、实验三部分的内容，前面的系列文章链接如下 操作系统MIT6.S081：[xv6参考手册第1章]-＞操作系统接口 操作系统MIT6.S081：[xv6参考手册第2章]-＞操作系统组织结构 操作系统MIT6.S081：[xv6参考手册第3章]-＞页表 操作系统MIT6.S081：[xv6参考手册第4章]-＞Trap与系统调用 操作系统MIT6.S081：P1-＞Introduction and examples 操作系统MIT6.S081：P2-＞
【操作系统】MIT 6.s081 LAB1
horizon_ys的博客
11-22 615
原文地址：YSBLOG sleep sleep 延迟times时间（在xv6中 10 times 为 1s） 在user/user.h中定义了sleep函数，只需将参数转为int类型直接传入即可 #include "kernel/types.h" #include "user/user.h" int main(int argc, char* argv[]) { int i; if (argc < 2) { printf("sleep : tick number is not sp
2021 MIT6.S081 LAB1
qq_33894666的博客
11-22 1330
实验一 原实验网址：Lab:Xv6 and Unix utilities sleep(easy) 为xv6实现UNIX下的sleep指令，你的sleep指令应该暂停一定的tick数，该数由用户指定。tick是由xv6定义的时间概念，即定时器芯片两个中断间的经过的时间。你的代码应该放在user/sleep.c文件下 提示 写代码前，阅读vx6 book书中第一章代码 看看其他程序（user/echo.c user/grep.c user/rm.c)是怎样获取命令行参数的 如果用户使用sleep
xv6-labs-2020:MIT 6.S081 2020秋季操作系统
03-30
xv6-riscv-lab MIT 6.S081 / 2020年秋季实验室 进度 Lab1 Lab2 Lab3 Lab4陷阱 Lab5延迟分配 Lab6写时复制 Lab7多线程 Lab8锁 Lab9文件系统 Lab10 mmap Lab11网络驱动程序 文件 Lab1 Lab2 Lab3
2021 MIT6.S081 LAB3
qq_33894666的博客
11-30 2498
实验三 原实验网址：Lab: page tables Speed up system calls 操作系统通过在用户空间和内核之间的共享只读区中的数据来加速某些系统调用。这种做法可以消除用户态到内核态之间切换的消耗。这次实验就使让我们学会将映射插入页表中，我们的第一个任务就是实现对系统调用getpid()的优化。 当一个进程被创建的时候，映射一个只读页到虚拟地址USYSCALL（定义在memlayout.h中）。 在该页的开始存放一个结构体，初始化这个结构体，结构体的只有一个成员，初始化为当前进程的pi
MIT6.S081学习总结-lab8:Lock
laplacebh的博客
07-05 1614
lab8 是关于锁的应用，重新设计内存分配和缓冲区分配，来增加多核并行速度 Memory allocator 物理内存分配，之前的实现里每次分配内存kalloc、释放内存kfree都需要获得全局锁kmem.lock,在多核系统里这会导致很激烈的race condition。改进时，可以考虑为每个CPU一个空闲内存列表，每次分配内存时先分配当前cpu空闲内存列表里的内存，如果不够就从其他空闲列表里‘steal’一个内存快。这样需要每个列表一个锁，可以大量减少锁的竞争。 实现： kmem修改为每个CPU一个fr
MIT6.S081学习总结-lab3:page tables
laplacebh的博客
06-15 3503
lab3 主要是页表相关，难度突然提高了好多，遇到了无数个坑，太难了。 打印页表 第一个进程启动时打印页表内容 实现： kernel/vm.c里添加，递归实现即可 每个进程一张内核页表 目前xv6的实现里，每个进程只有一张独立的用户地址空间页表，共享一张内核页表，这样的话每次内核不能直接使用用户指针，只能先将其通过用户页表转为物理地址。本节及下一节要做的是使内核可以直接解引用用户指针，就是可以直接通过虚拟地址访问。 本节要做的就是为每个进程复制一个内核页表。 实现 省略了 添加函数到defs.h的步骤，这
MIT 6.S081/6.828 OS Lab
dc199706的博客
11-04 1893
MIT 6.S081/6.828 OS Lab一、装环境 这是大名鼎鼎的MIT的研究生操作系统实验。最一开始是因为我导师这学期教本科生《操作系统》这门课，想把这个实验作为提高实验，因此让作为助教的我也摸一下这个实验。接触后发现这个实验其实很有意思，也的确锻炼系统编程能力，十分契合我对自己的规划，因此决定坚持做下去，特此记录过程中遇到的一些问题和启示。 实验内容详情：https://pdos.csa...
MIT6.S081 Lab5: xv6 lazy page allocation
m0_52394388的博客
05-31 188
Eliminate allocation from sbrk() 更改kernel/sysproc.c中的sys_sbrk函数： uint64 sys_sbrk(void) { int addr; int n; if(argint(0, &n) < 0) return -1; addr = myproc()->sz; /* if(growproc(n) < 0) return -1; */ myp
【MIT6.S081】Lab5: xv6 lazy page allocation(详细解答版)
lllllllllljg的博客
04-29 990
实验内容网址：https://xv6.dgs.zone/labs/requirements/lab5.html本实验的代码分支：https://gitee.com/dragonlalala/xv6-labs-2020/tree/lazy3/
MIT-6.s081-OS lab sh : Simple xv6 shell
RedemptionC的博客
06-25 2221
实验说明：https://pdos.csail.mit.edu/6.828/2019/labs/sh.html 离上次做完实验一快有二十多天了 期间不是不想做这个实验 主要是两个困难： 1.不会使用gdb 2. 要从头实现一个shell，并且要处理 grep lion < data.txt | wc > count 这种看起来很复杂的命令，我被吓住了，因为传说中的AST我不会，而有些博客写的用字符串处理的方式因为比较个性化我又看不懂，所以觉得很难，做起来很难受，不过总的来说，这二十
mit6.s081 lab5 lazy allocation
tailuzhecom的博客
10-09 285
Eliminate allocation from sbrk() 这个exercise的主要工作是从目前的sbrk()实现中删除分配内存的部分，只增加process的sz。 具体步骤为在sys_sbrk中删除growproc的调用，但sz增加n uint64 sys_sbrk(void) { int addr; int n; if(argint(0, &n) < 0) return -1; addr = myproc()->sz; // if(growpro
MIT6.S081 LAB6实验记录
m0_51216781的博客
10-21 147
实验记录总结
mit6.s081 lab lock
10-06
mit6.s081 lab lock是麻省理工学院计算机科学与人工智能实验室的一个项目，主要目的是实现一个基本的锁系统。 这个项目的核心是一个用户态的锁库，它提供了一组函数来实现锁的创建、加锁和解锁等操作。用户可以在自己的程序中使用这些函数来确保关键代码段的互斥访问，从而避免并发访问带来的问题。 mit6.s081 lab lock的实现基于操作系统的进程管理与调度机制。在具体实现中，它借助于系统调用来实现进程的阻塞和唤醒，以及对共享资源的保护。 通过实现这个锁系统的项目，学生可以深入理解操作系统中与并发相关的核心概念，如原子操作、互斥和临界区等。同时，学生还可以学习到如何进行系统级编程，理解用户态和内核态之间的交互。 此外，mit6.s081 lab lock还涉及到对锁性能的评估，学生可以通过实验测量和分析锁的性能指标，如吞吐量和延迟等。这样的实践让学生能够更好地理解并发编程中的性能优化与瓶颈分析。 总之，mit6.s081 lab lock是一个对操作系统和并发编程进行深入学习的项目。通过参与这个项目，学生可以加深对锁机制及其原理的理解，并掌握一些实用的并发编程技术。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值