Lab5: xv6 lazy page allocation

最新推荐文章于 2024-04-29 12:00:26 发布
最新推荐文章于 2024-04-29 12:00:26 发布
阅读量1.6k 收藏 19
点赞数
分类专栏： MIT 6.S081课程记录 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53111905/article/details/120996494
版权

Lab5: xv6 lazy page allocation

这个实验相对其他实验来说还是较为简单的，再加上老师上课直接演示了一半，所以这里直接放操作了

文章目录

操作系统可以使用页表硬件的技巧之一是延迟分配用户空间堆内存（lazy allocation of user-space heap memory）。Xv6应用程序使用sbrk()系统调用向内核请求堆内存。在我们给出的内核中，sbrk()分配物理内存并将其映射到进程的虚拟地址空间。内核为一个大请求分配和映射内存可能需要很长时间。例如，考虑由262144个4096字节的页组成的千兆字节；即使单独一个页面的分配开销很低，但合起来如此大的分配数量将不可忽视。此外，有些程序申请分配的内存比实际使用的要多（例如，实现稀疏数组），或者为了以后的不时之需而分配内存。为了让sbrk()在这些情况下更快地完成，复杂的内核会延迟分配用户内存。也就是说，sbrk()不分配物理内存，只是记住分配了哪些用户地址，并在用户页表中将这些地址标记为无效。当进程第一次尝试使用延迟分配中给定的页面时，CPU生成一个页面错误（page fault），内核通过分配物理内存、置零并添加映射来处理该错误。您将在这个实验室中向xv6添加这个延迟分配特性。

Eliminate allocation from sbrk() (easy)

你的首项任务是删除sbrk(n)系统调用中的页面分配代码（位于***sysproc.c***中的函数sys_sbrk()）。sbrk(n)系统调用将进程的内存大小增加n个字节，然后返回新分配区域的开始部分（即旧的大小）。新的sbrk(n)应该只将进程的大小（myproc()->sz）增加n，然后返回旧的大小。它不应该分配内存——因此您应该删除对growproc()的调用（但是您仍然需要增加进程的大小！）。

试着猜猜这个修改的结果是什么：将会破坏什么？

进行此修改，启动xv6，并在shell中键入echo hi。你应该看到这样的输出：

init: starting sh
$ echo hi
usertrap(): unexpected scause 0x000000000000000f pid=3
            sepc=0x0000000000001258 stval=0x0000000000004008
va=0x0000000000004000 pte=0x0000000000000000
panic: uvmunmap: not mapped

“usertrap(): …”这条消息来自***trap.c***中的用户陷阱处理程序；它捕获了一个不知道如何处理的异常。请确保您了解发生此页面错误的原因。“stval=0x0..04008”表示导致页面错误的虚拟地址是0x4008。

过于简单，lec8上课演示过
image-20211023180150218

uint64
sys_sbrk(void)
{
  int addr;
  int n;

  if(argint(0, &n) < 0)
    return -1;
  addr = myproc()->sz;
  myproc()->sz += n;
  //if(growproc(n) < 0)
  //  return -1;
  return addr;
}

Lazy allocation (moderate)

YOUR JOB

修改trap.c中的代码以响应来自用户空间的页面错误，方法是新分配一个物理页面并映射到发生错误的地址，然后返回到用户空间，让进程继续执行。您应该在生成“usertrap(): …”消息的printf调用之前添加代码。你可以修改任何其他xv6内核代码，以使echo hi正常工作。

提示：

  • 你可以在usertrap()中查看r_scause()的返回值是否为13或15来判断该错误是否为页面错误
  • stval寄存器中保存了造成页面错误的虚拟地址，你可以通过r_stval()读取
  • 参考***vm.c***中的uvmalloc()中的代码，那是一个sbrk()通过growproc()调用的函数。你将需要对kalloc()和mappages()进行调用
  • 使用PGROUNDDOWN(va)将出错的虚拟地址向下舍入到页面边界
  • 当前uvmunmap()会导致系统panic崩溃；请修改程序保证正常运行
  • 如果内核崩溃，请在***kernel/kernel.asm***中查看sepc
  • 使用pgtbl lab的vmprint函数打印页表的内容
  • 如果您看到错误“incomplete type proc”，请include“spinlock.h”然后是“proc.h”。

如果一切正常，你的lazy allocation应该使echo hi正常运行。您应该至少有一个页面错误（因为延迟分配），也许有两个。

修改usertrap

else if (r_scause() == 13 || r_scause() == 15) { // 参考课程的例子,注意判断是否合法(例子没有)
    uint64 va = r_stval();
    uint64 ka = (uint64)kalloc();
    if (ka == 0) {
      p->killed = 1;
    }
    else if(isValid(p, va) == 0) {
      kfree((void*)ka);
      p->killed = 1;
    }
    else {
      memset((void*)ka, 0, PGSIZE);
      va = PGROUNDDOWN(va);
      if (mappages(p->pagetable, va, PGSIZE, ka, PTE_U | PTE_R | PTE_W) != 0) {
        kfree((void*)ka);
        p->killed = 1;
      }
    }
  } 

// 判断va地址是否合法，如果va大于sz或者当虚拟地址比进程的用户栈还小，则不合法。
int isValid(struct proc *p, uint64 va) {
  uint64 stackbase = PGROUNDDOWN(p->trapframe->sp);
  if (va >= p->sz || (va < stackbase)) 
    return 0;
  return 1;
}

修改uvmunmap()

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;
  }

Lazytests and Usertests (moderate)

我们为您提供了lazytests，这是一个xv6用户程序，它测试一些可能会给您的惰性内存分配器带来压力的特定情况。修改内核代码，使所有lazytests和usertests都通过。

  • 处理sbrk()参数为负的情况。
  • 如果某个进程在高于sbrk()分配的任何虚拟内存地址上出现页错误，则终止该进程。
  • 在fork()中正确处理父到子内存拷贝。
  • 处理这种情形：进程从sbrk()向系统调用（如read或write）传递有效地址，但尚未分配该地址的内存。
  • 正确处理内存不足：如果在页面错误处理程序中执行kalloc()失败，则终止当前进程。
  • 处理用户栈下面的无效页面上发生的错误。

如果内核通过lazytests和usertests，那么您的解决方案是可以接受的：

$ lazytests
lazytests starting
running test lazy alloc
test lazy alloc: OK
running test lazy unmap...
usertrap(): ...
test lazy unmap: OK
running test out of memory
usertrap(): ...
test out of memory: OK
ALL TESTS PASSED
$ usertests
...
ALL TESTS PASSED
$

处理sbrk()为负数，减少相应的内存，就是dealloc相应的内存n，注意n不能大于p->sz

uint64
sys_sbrk(void)
{
  int addr;
  int n;
  if(argint(0, &n) < 0)
    return -1;
  struct proc* p = myproc();
  addr = p->sz;
  if (n < 0)
  {
    if (p->sz + n < 0) return -1;
    else uvmdealloc(p->pagetable, p->sz, p->sz + n);
  }
  p->sz += n;
  //if(growproc(n) < 0)
  //  return -1;
  return addr;
}

修改fork()，正确处理父到子内存拷贝

在fork时会调用uvmcopy复制一份父进程的内存，在lazy allocation中可能0->sz中有部分没有真正分配，在uvmcopy中就会导致panic。累次uvmunmap，修改uvmcopy使得在页面不存在时跳过这一页。

for(i = 0; i < sz; i += PGSIZE){
    if((pte = walk(old, i, 0)) == 0)
      //panic("uvmcopy: pte should exist");
      continue;
    if((*pte & PTE_V) == 0)
      //panic("uvmcopy: page not present");
      continue;
    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;

处理第4种情况，即系统调用（比如write）传入的虚拟地址对应的内存并没有被分配。
首先搞清楚函数执行流程，在调用write后系统trap到内核态，执行copyin来把用户程序va处的内容复制到内核空间，此时若va处并未分配内存，walkaddr会返回0导致系统调用失败。因此我们要做的就是在walkaddr中分配内存。

在walkadress里修改即可

#include "spinlock.h" // 引用头文件proc.h  的时候还要引用 spinlock.h
#include "proc.h"


uint64
walkaddr(pagetable_t pagetable, uint64 va)
{
  pte_t *pte;
  uint64 pa;
  
  struct proc *p = myproc();
  if(va >= MAXVA)
    return 0;

  pte = walk(pagetable, va, 0);
  if(pte == 0 || (*pte & PTE_V) == 0) {
    uint64 ka = (uint64)kalloc();
    if (ka == 0) {
      return 0;
    }
    else if (isValid(p, va) == 0) {
      kfree((void*)ka);              //注意这里也要kfree，不然会导致内存泄漏
      return 0;
    }
    else {
      memset((void*)ka, 0, PGSIZE);
      if (mappages(p->pagetable, PGROUNDDOWN(va), PGSIZE, ka, PTE_U | PTE_R | PTE_W) != 0) {
        kfree((void*)ka);
        return 0;
      }
      return ka;
    }
  }
  if((*pte & PTE_U) == 0)
    return 0;
  pa = PTE2PA(*pte);
  return pa;
}

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
...
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: 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
ALL TESTS PASSED

完成！

爱好学习的青年人
关注
专栏目录
6.S081 Xv6 Lab 5: lazy page allocation
clownote
04-03 1496
Lab: xv6 lazy page allocation https://pdos.csail.mit.edu/6.S081/2020/labs/lazy.html 新的 2020 版哦。 $ git fetch $ git checkout lazy $ make clean Eliminate allocation from sbrk() 就是把 sys_sbrk 里的 growproc 调用删了，等用到的时候再去分配内存。如果是空间减小，要取消分配。 uint64 sys_sbrk(void.
MIT-6.s081-OS lab lazy: xv6 lazy page allocation
RedemptionC的博客
08-01 3216
本实验要实现的是lazy allocation 很多时候，一个进程可能使用sbrk申请了大量的内存，但是其中的大部分并没有使用，造成了浪费 我们要做的是修改sbrk的实现，sbrk不分配物理内存,just remember which addresses are allocated 当进程第一次试图使用任何内存时，产生一个page fault，再让kernel分配内存，清零，映射 ...
操作系统实验Mit6.S081笔记 Lab5: Lazy allocation
weixin_46477226的博客
10-02 2932
O/S使用页表硬件可以使用的许多巧妙技巧之一是延迟分配用户空间堆内存。 Xv6应用程序使用sbrk()系统调用向内核请求堆内存。 在我们给出的内核中，sbrk()分配物理内存并将其映射到进程的虚拟地址空间。 内核为大型请求分配和映射内存可能需要很长时间。 例如，考虑一个千兆字节由262,144个4096字节的页组成; 这是一个巨大的分配数量，即使每一个都是便宜的。 此外，一些程序分配的内存比它们实际使用的内存要多(例如，实现稀疏数组)，或者在使用之前分配内存。 为了让sbrk()在这些情况下更快地完成，复杂
MIT 6.S081 Lab5: xv6 lazy page allocation
落队的飞行兵
12-06 2553
这个实验主要是写内存的懒分配（Lazy page allocation）应该是目前为止最简单的了？！实验说明地址在Lab: xv6 lazy page allocation，我的代码在 github。 断断续续的做也没用多长时间，。需要的知识比较简单，可能会比较考验 debug 的能力，不过参考一下网上的经验，还是很容易解决的。
【MIT 6.S081】Lab5: xv6 lazy page allocation
juruo_c的博客
03-31 684
xv6中的用户程序使用sbrk系统调用向内核请求增长堆内存或者缩减堆内存。对于增长内存的情况，用户往往会申请多于实际需要的内存以便使用。于是，对于暂未使用的内存，如果在用户申请时就将其分配给用户，挺浪费的。基于这样一种思想，当用户申请增长内存时，暂时不分配物理内存，而是仅增长用户进程的空间大小。这时如果用户实际使用到了新分配的内存，则会引发page fault（因为进程页表暂未维护该内存的虚拟地址与物理地址的映射）。page fault。
xv6 lazy page allocation
Xiaoli_Coding
06-02 4316
xv6 lazy page allocation
lab: xv6 lazy page allocation
03-16
:xv6 懒惰页面分配是一种内存管理技术，它允许操作系统在需要时才分配物理页面，而不是在进程创建时就分配。这种技术可以减少内存浪费，提高系统性能。在 xv6 操作系统中，懒惰页面分配是通过将虚拟地址映射到一个空...
MIT6.828_HW4_ XV6 Lazy Page Allocation
userXKk的博客
08-06 1266
Homework4: xv6 lazy page allocation Xv6应用程序使用sbrk（）系统调用向内核请求堆内存,sbrk（）分配物理内存并将其映射到进程的虚拟地址空间。 有些程序分配内存，但从不使用它，例如大型稀疏数组。 复杂的内核会延迟分配内存的每个页面，直到应用程序尝试使用该页面为止（产生缺页中断时),本练习中我们会将此延迟分配功能添加到xv6。 Part One: Eliminate allocation from sbrk() 第一个任务是删除sbrk(n)系统调用中分配内存的核心代
MIT6.S081学习总结-lab5:lazy page allocation
laplacebh的博客
06-28 954
lab5 是lazy page allocationi相关,主要解决页面错误问题。O/S可以对页表硬件使用的许多巧妙技巧之一是延迟分配用户空间堆内存。Xv6应用程序使用sbrk()系统调用向内核请求堆内存。在我们给出的内核中，sbrk()分配物理内存并将其映射到进程的虚拟地址空间。内核为一个较大的请求分配和映射内存可能需要很长时间。例如，考虑一个gb由262,144 4096字节的页组成;即使每一种都很便宜，这也是一笔巨大的投资。此外，一些程序分配的内存比实际使用的要多(例如，实现稀疏数组)，或者在使用之前
MIT6.S081 Lab5: xv6 lazy page allocation
m0_52394388的博客
05-31 209
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
xv6-----lazy page allocation
weixin_33878457的博客
11-18 300
本文转载是网络，只叙述方法，，， 第一问：Turn off page allocation in xv6 修改sysproc.c中的sys_sbrk()函数即可： 1 int sys_sbrk(void) 2 { 3 int addr; 4 int n; 5 if(argint(0, &n) < 0) 6 ...
MIT6.S081Lab5：xv6 lazy page allocation
qq_46514141的博客
12-07 901
这个实验总的来说我觉得还是比lab3简单一点，最需要注意的就是最后一个中关于系统调用涉及到lazy allocation不会触发页面错误需要手动编写代码来分配页面。
6.s081 Lab：xv6 lazy page allocation
pige666的博客
09-22 2153
Lab：xv6 lazy page allocation 1.实验目的 O/S可以在页表硬件上使用的许多巧妙的技巧之一是延迟分配用户空间堆内存。Xv6应用程序使用sbrk（）系统调用向内核请求堆内存。在我们给您的内核中，sbrk（）分配物理内存并将其映射到进程的虚拟地址空间。但是，有些程序使用sbrk（）来请求大量内存，但从未使用大部分内存，例如实现大型稀疏数组。为了对这种情况进行优化，复杂的内核延迟地分配用户内存。也就是说，sbrk（）不分配物理内存，只是记住分配了哪些地址。当进程第一次尝试使用任何给定的
MIT6.828 Homework4: xv6 lazy page allocation
qq_43012789的博客
08-03 1259
操作系统可以在页表硬件上玩的许多巧妙的把戏之一是堆内存的惰性分配。Xv6应用程序使用sbrk()系统调用向内核请求堆内存。在我们给你的内核中，sbrk()分配物理内存并将其映射到进程的虚拟地址空间。有些程序分配内存，但从不使用它，例如实现大型稀疏数组。复杂的内核会延迟每个内存页面的分配，直到应用程序尝试使用该页面——这是由页面错误发出的信号。在本练习中，您将把这个惰性分配特性添加到xv6中。 Part One: Eliminate allocation from sbrk() 实验内容 修改...
MIT_6.828_2018_xv6_lazy_page_allocation
salvete的博客
02-08 633
MIT关于虚拟内存映射的课后习题解答
MIT-XV6/JOS hw: lazy page allocation
weixin_30618985的博客
01-06 221
Xv6使用lazy allocation 当进程需要更多的内存的时候，调用malloc申请更多的堆内存，而系统调用sbrk()完成该工作 但是有的进程会一次申请大量的内存，但是又可能根本用不到，比如说sparse array 所以说复杂的内核涉及会将实际的allocation的工作推迟到实际用的时候，发生了page fault了，然后再进行实际的分配 Part1. 将系统调用sbrk的实...
【MIT6.S081】Lab5: xv6 lazy page allocation(详细解答版)
最新发布
lllllllllljg的博客
04-29 1083
实验内容网址：https://xv6.dgs.zone/labs/requirements/lab5.html本实验的代码分支：https://gitee.com/dragonlalala/xv6-labs-2020/tree/lazy3/
6.s081 XV6-延迟分配(Lazy Allocation)的思路分析
m0_68392776的博客
01-13 290
XV6本身并没有为每个进程设置堆区，也没有，笔者在这里提供堆区内存池的实现与延迟分配机制的实现思路，帮助各位读者攻克延迟分配的lab
Mit6.S081-实验5-xv6 lazy page allocation
热门推荐
code a better life~
12-23 33万+
Mit6.S081-实验5-xv6 lazy page allocation一、Eliminate allocation from sbrk()1，实验准备2，实验要求3，具体实现二、Lazy allocation1，实验要求2，具体实现3，执行效果二、Lazytests and Usertests1，实验要求2，具体实现3，执行效果 一、Eliminate allocation from sbrk() 1，实验准备 O/S可以跟page table hardware表演的众多小花招之一是用户空间堆内存的懒
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值