MIT6.828_HW4_xv6 lazy page allocation

最新推荐文章于 2024-07-17 19:36:02 发布
原创 最新推荐文章于 2024-07-17 19:36:02 发布 · 2.3k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#MIT6.828 #HW4 #lazy page allocation

这篇博客探讨了MIT6.828课程作业HW4中的Xv6操作系统如何实现懒页分配，旨在消除sbrk()的内存分配，并在实际使用前延迟物理内存的分配。内容分为两部分，第一部分讲解了如何修改sbrk()，使其仅增加进程大小而不立即分配内存。第二部分介绍了如何实现懒惰分配，避免对未使用页面的预先分配，从而提高效率。

1. HW4_xv6 lazy page allocation

操作系统可以与页表硬件一起使用的许多巧妙技巧之一是堆内存的惰性分配。Xv6应用程序使用sbrk()系统调用向内核请求堆内存。 在我们给你的内核中，sbrk()分配物理内存并将其映射到进程的虚拟地址空间。 有些程序分配到内存但从不使用它，例如实现大稀疏数组。精妙的内核延迟每页内存的分配，直到应用程序尝试使用该页面 - 如页面错误所示。

1.1. Part One: Eliminate allocation from sbrk()

你的新sbrk(n)应该只用n增加进程的大小(myproc() - > sz）并返回旧的大小。

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

$ echo hi
pid 3 sh: trap 14 err 6 on cpu 0 eip 0x112c addr 0x4004--kill proc

"pid 3 sh：trap …"消息来自trap.c中的陷入内核处理程序; 它捕获了页面错误（陷入14或T_PGFLT），xv6内核不知道如何处理。addr 0x4004表示导致页面错误的虚拟地址为0x4004。

1.2. Part Two: Lazy allocation

根据提示来做就比较明了了。主要需要从vm.c中的allocuvm()偷过程。


                

                
                
        

    



  


        

            

                      
                        最低0.47元/天 解锁文章
                          
                      
            

        


    



                



	

		

			

				
					
MIT6.828 HW4: lazy page allocation

				
			

			

				

					bysui的博客
				

				

					05-24
					
					4266
					
				

			

		

		

			
				
lazy page allocation

			
		

	



                

            
              



	

		

			

				
					
MIT6.828_HW4_ XV6 Lazy Page Allocation

				
			

			

				

					userXKk的博客
				

				

					08-06
					
					1387
					
				

			

		

		

			
				
Homework4: xv6 lazy page allocation
Xv6应用程序使用sbrk（）系统调用向内核请求堆内存,sbrk（）分配物理内存并将其映射到进程的虚拟地址空间。 有些程序分配内存，但从不使用它，例如大型稀疏数组。 复杂的内核会延迟分配内存的每个页面，直到应用程序尝试使用该页面为止（产生缺页中断时),本练习中我们会将此延迟分配功能添加到xv6。
Part One: Eliminate allocation from sbrk()
第一个任务是删除sbrk(n)系统调用中分配内存的核心代

			
		

	



              


  
              

                


	

		

			

				
					
MIT6.828 Homework4: xv6 lazy page allocation

				
			

			

				

					qq_43012789的博客
				

				

					08-03
					
					1648
					
				

			

		

		

			
				
操作系统可以在页表硬件上玩的许多巧妙的把戏之一是堆内存的惰性分配。Xv6应用程序使用sbrk()系统调用向内核请求堆内存。在我们给你的内核中，sbrk()分配物理内存并将其映射到进程的虚拟地址空间。有些程序分配内存，但从不使用它，例如实现大型稀疏数组。复杂的内核会延迟每个内存页面的分配，直到应用程序尝试使用该页面——这是由页面错误发出的信号。在本练习中，您将把这个惰性分配特性添加到xv6中。

Part One: Eliminate allocation from sbrk()

实验内容

修改...

			
		

	





	

		

			

				
					
MIT6.828学习之homework4：xv6 lazy page allocation

				
			

			

				

					a747979985的博客
				

				

					07-17
					
					2816
					
				

			

		

		

			
				
xv6应用程序使用sbrk()系统调用向内核请求堆内存。在我们给出的内核中，sbrk()分配物理内存并将其映射到进程的虚拟地址空间。有些程序分配内存，但从不使用它，例如实现大型稀疏数组。复杂的内核会延迟对每个内存页的分配，直到应用程序尝试使用该页面——这是由页面错误发出的信号。
就是只修改进程大小值实际上不分配页面(让进程误以为分配了)，等需要使用对应页面再来分配
Part One
修改sbrk(...

			
		

	



		

			
		



	

		

			

				
					
xv6 syscall lab

				
			

			

				

					weixin_41028621的博客
				

				

					04-06
					
					2316
					
				

			

		

		

			
				
做syscall 实验

实验1：System call tracing
  Your first task is to modify the xv6 kernel to print out a line for each system call invocation. It is enough to print the name of the system call and the retur...

			
		

	





	

		

			

				
					
221.Mit6.S081-实验5-xv6-xv6 lazy page allocation

				
			

			

				

					weixin_63779802的博客
				

				

					07-17
					
					1061
					
				

			

		

		

			
				
一、操作系统可以使用页表硬件的技巧之一是sbrk()。在我们给出的内核中，sbrk()。内核为一个大请求分配和映射内存可能需要很长时间。例如，考虑由262144个4096字节的页组成的千兆字节；即使单独一个页面的分配开销很低，但合起来如此大的分配数量将不可忽视。此外，有些程序申请分配的内存比实际使用的要多（例如，实现稀疏数组），或者为了以后的不时之需而分配内存。为了让sbrk()在这些情况下更快地完成，复杂的内核会延迟分配用户内存。也就是说，sbrk()。。您将在这个实验室中向xv6添加这个延迟分配特性。

			
		

	





	

		

			

				
					
2020 MIT6.s081 Lab: xv6 lazy page allocation

				
			

			

				

					sun%moon
				

				

					08-01
					
					1073
					
				

			

		

		

			
				
2020 MIT6.s081 Lab: xv6 lazy page allocation

			
		

	





	

		

			

				
					
xv6 lazy allocation

				
			

			

				

					Holddom的博客
				

				

					09-20
					
					191
					
				

			

		

		

			
				
这部分的 hint其实只是给出遇到问题后去怎么解决 总体思路就是实现lazy allocation。只有lazy allocation 才能去unmap没有分配空间而导致pte无效的情况。这里是是把pte为0的情况 和pte无效的情况变成continue。这是跑测试用例的时候发现的 从别的函数中调用的mappages()我建议就是想到一个得修改的地方 写上 然后调试去找新的错误。这是write 和 read 系统调用的底层函数。注意我们这里的虚拟地址是具体的 一定不要舍入。但要考虑到传入的n是负数的情况。

			
		

	





	

		

			

				
					
xv6源码分析（五）：异常、中断、系统调用机制

				
			

			

				

					博客名被人看见不好
				

				

					01-21
					
					1万+
					
				

			

		

		

			
				
操作系统在开始运行用户进程的时候，内核便开始处于被动状态，只有在出现以下几种情况的时候才会触发硬件机制陷入内核：（1）用户代码由于某种原因引发异常（例如除以0）;（2）硬件产生中断并且没有屏蔽触发中断；（3）用户代码调用相关指令（例如x86体系下的int系统调用指令）主动陷入内核。以上三种情况便是异常、中断、系统调用机制。这三种机制由于需要陷入内核所以在进入内核之前必须先保存现场，然后回到用户环境的

			
		

	





	

		

			

				
					
MIT6.828_HW10_Bigger files for xv6

				
			

			

				

					userXKk的博客
				

				

					08-28
					
					1595
					
				

			

		

		

			
				
Homework: bigger files for xv6
本节中,我们将增加xv6文件的最大尺寸,xv6的i节点包含12个直接索引节点和一个一级索引节点,因此当前的xv6文件大小限制在512/4=128+12=140个扇区即71680个字节,我们要修改xv6文件系统的代码位每个i节点添加一个二级索引节点,二级索引节点指向的索引块包含128个一级索引节点,每个一级索引节点包含128个条目,每个条目指向一个数据块,这样一个文件的大小限制将拓展到11+128+2^14=16523个扇区(约8.5M)。建议阅读

			
		

	





	

		

			

				
					
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

			
		

	





	

		

			

				
					
天津大学操作系统实习xv6代码+报告

				
			

			

				

					11-08
				

			

		

		

			
				
天津大学操作系统实习代码+报告：实习内容为对xv6的对应部分进行更改使之可以完成指定任务。其中包含8个子任务：
1.utilities
2.shell
3.allocator
4.lazy_allocation
5.copy_on_write
6.user-level_threads_and_alarm
7.lock
8.file_system

			
		

	





	

		

			

				
					
MIT-6.s081-OS lab lazy: xv6 lazy page allocation

				
			

			

				

					RedemptionC的博客
				

				

					08-01
					
					3350
					
				

			

		

		

			
				
本实验要实现的是lazy allocation

很多时候，一个进程可能使用sbrk申请了大量的内存，但是其中的大部分并没有使用，造成了浪费

我们要做的是修改sbrk的实现，sbrk不分配物理内存,just remember which addresses are allocated

当进程第一次试图使用任何内存时，产生一个page fault，再让kernel分配内存，清零，映射


...

			
		

	





	

		

			

				
					
6.s081 Lab：xv6 lazy page allocation

				
			

			

				

					pige666的博客
				

				

					09-22
					
					2364
					
				

			

		

		

			
				
Lab：xv6 lazy page allocation
1.实验目的
O/S可以在页表硬件上使用的许多巧妙的技巧之一是延迟分配用户空间堆内存。Xv6应用程序使用sbrk（）系统调用向内核请求堆内存。在我们给您的内核中，sbrk（）分配物理内存并将其映射到进程的虚拟地址空间。但是，有些程序使用sbrk（）来请求大量内存，但从未使用大部分内存，例如实现大型稀疏数组。为了对这种情况进行优化，复杂的内核延迟地分配用户内存。也就是说，sbrk（）不分配物理内存，只是记住分配了哪些地址。当进程第一次尝试使用任何给定的

			
		

	





	

		

			

				
					
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表演的众多小花招之一是用户空间堆内存的懒

			
		

	





	

		

			

				
					
MIT Xv6.828学习

				
			

			

				

					sinat_30002909的博客
				

				

					04-25
					
					409
					
				

			

		

		

			
				
文档
https://github.com/ranxian/xv6-chinese
代码
https://github.com/panks/Xv6
os
https://blog.csdn.net/dlutbrucezhang/article/details/9106517
实验
http://xinqiu.me/2016/10/15/MIT-6.828-1/
https://github.com...

			
		

	





	

		

			

				
					
实验5

				
			

			

				

					lizhifanv的博客
				

				

					05-17
					
					216
					
				

			

		

		

			
				
/*
* 文件名称：数组分离     
* 作    者：李智凡
* 完成日期：2017年3月17日            
* 版 本 号：v1.0            
* 对任务及求解方法的描述部分:           
* 输入描述：   
* 问题描述：       
* 程序输出：
* 问题分析：略           
* 算法设计：  
*/
#include
using na

			
		

	





	

		

			

				
					
【xv6学习之HW1】shell

				
			

			

				

					mick_seu的博客
				

				

					10-23
					
					7371
					
				

			

		

		

			
				
第一次的作业就把我难倒了。在此十分感谢JasonLeaster，没有这一系列的博文，我可能就要放弃了。希望能坚持下去，虽然比较难，但是我肯定能学到很多东西。
传送在此：http://blog.csdn.net/cinmyheart/article/details/45122619
不会的东西比较多，记录的东西也就比较多，比较杂。记下来先，慢慢熟悉。


看了JasonLeaster写的代

			
		

	





	

		

			

				
					
MIT_6.828_2018_xv6_lazy_page_allocation

				
			

			

				

					salvete的博客
				

				

					02-08
					
					755
					
				

			

		

		

			
				
MIT关于虚拟内存映射的课后习题解答

			
		

	





	

		

			

				
					
SELECT
	t.id,
	t.report_name,
	t.source_type,
	t.source_id,
	t.source_dept_id,
	t.source_dept_name,
	t.create_dept_id,
	t.last_level,
	t.remark,
	t.data_count,
	t.update_count,
	t.visit_count,
	t4.*
FROM
	warehouse_report t
	LEFT JOIN warehouse_report_label_ref t3 ON t3.report_id = t.id and t3.is_deleted = 0
	LEFT JOIN warehouse_label_manage t4 ON t4.id = t3.label_id and t4.is_deleted = 0
WHERE
	t.is_deleted = 0 
	AND t.from_type = 1 
	AND t.create_dept_id = &#39;A001&#39;我的warehouse_report 一条数据可能对应两条标签，这样查出来的是两条数据了

					
最新发布

				
			

			

				

					07-18
				

			

		

		

			
				
你的查询会返回重复的报表数据（每条报表数据会重复出现，次数等于其关联的标签数量），这是因为 **多表 JOIN 导致的结果集笛卡尔积**。以下是解决方案和优化建议：

---

### **问题分析**
1. **当前查询的问题**：
   - `LEFT JOIN warehouse_label_manage t4` 会导致每条报表记录根据关联的标签数量重复（例如：1 条报表 + 2 个标签 → 返回 2 条相同报表数据）。
   - 如果前端需要 **报表数据 + 关联标签列表**，这种重复数据会导致冗余传输和解析复杂化。

2. **需求目标**：
   - 返回 **不重复的报表数据**，同时将关联的多个标签合并到一个列表字段中（如 `List<WarehouseLabelManage>`）。

---

### **解决方案**
#### **方案 1：使用 `<resultMap>` + `<collection>`（推荐）**
通过 MyBatis 的嵌套结果映射，将标签列表作为子对象集合映射到报表对象中。

```xml
<!-- 定义结果映射 -->
<resultMap id="reportWithLabelsMap" type="com.yunjin.warehouse.report.pojo.vo.WarehouseReportVO">
    <!-- 报表基础字段 -->
    <id column="id" property="id"/>
    <result column="report_name" property="reportName"/>
    <result column="source_type" property="sourceType"/>
    <!-- 其他字段... -->

    <!-- 关联标签集合 -->
    <collection 
        property="labelEntity" 
        ofType="com.yunjin.warehouse.report.pojo.entity.WarehouseLabelManage"
        resultMap="labelResultMap"/>  <!-- 引用标签的结果映射 -->
</resultMap>

<!-- 标签的结果映射（可选） -->
<resultMap id="labelResultMap" type="com.yunjin.warehouse.report.pojo.entity.WarehouseLabelManage">
    <id column="label_id" property="id"/>
    <result column="label_code" property="labelCode"/>
    <result column="label_name" property="labelName"/>
    <!-- 其他标签字段... -->
</resultMap>

<!-- 查询语句 -->
<select id="selectReportWithLabels" resultMap="reportWithLabelsMap">
    SELECT
        t.id, t.report_name, t.source_type, /* 其他报表字段... */,
        t4.id AS label_id, t4.label_code, t4.label_name /* 其他标签字段... */
    FROM
        warehouse_report t
        LEFT JOIN warehouse_report_label_ref t3 ON t3.report_id = t.id AND t3.is_deleted = 0
        LEFT JOIN warehouse_label_manage t4 ON t4.id = t3.label_id AND t4.is_deleted = 0
    WHERE
        t.is_deleted = 0 
        AND t.from_type = 1 
        AND t.create_dept_id = &#39;A001&#39;
</select>
```

**关键点**：
- 通过 `resultMap` 的 `<collection>` 将多行标签数据合并到报表对象的 `labelEntity` 列表中。
- 使用 `AS` 为标签字段起别名（避免与报表字段冲突）。

---

#### **方案 2：分两次查询 + 内存组装**
如果数据量较小，可以先查报表列表，再批量查询关联标签，最后在代码中组装。

```java
// 1. 查询报表列表（无标签）
List<WarehouseReportVO> reports = mapper.selectReportsByDept("A001");

// 2. 提取报表ID列表
List<Long> reportIds = reports.stream().map(WarehouseReportVO::getId).collect(Collectors.toList());

// 3. 批量查询关联标签
if (!reportIds.isEmpty()) {
    Map<Long, List<WarehouseLabelManage>> labelsMap = mapper.selectLabelsByReportIds(reportIds);
    
    // 4. 组装数据
    reports.forEach(report -> 
        report.setLabelEntity(labelsMap.getOrDefault(report.getId(), Collections.emptyList()))
    );
}
```

```xml
<!-- 批量查询标签 -->
<select id="selectLabelsByReportIds" resultType="com.yunjin.warehouse.report.pojo.entity.WarehouseLabelManage">
    SELECT 
        lm.*
    FROM 
        warehouse_label_manage lm
        JOIN warehouse_report_label_ref ref ON lm.id = ref.label_id
    WHERE 
        ref.report_id IN 
        <foreach collection="list" item="id" open="(" separator="," close=")">
            #{id}
        </foreach>
        AND lm.is_deleted = 0
        AND ref.is_deleted = 0
</select>
```

**优势**：
- 避免复杂 SQL，适合标签数量较多的场景。
- 减少网络传输冗余数据。

---

#### **方案 3：使用 GROUP_CONCAT（MySQL 特有）**
如果数据库是 MySQL，可以通过 `GROUP_CONCAT` 将标签数据合并为字符串，再在代码中解析。

```xml
<select id="selectReportsWithLabels" resultType="com.yunjin.warehouse.report.pojo.vo.WarehouseReportVO">
    SELECT
        t.id, t.report_name, /* 其他报表字段... */,
        GROUP_CONCAT(
            CONCAT(t4.id, &#39;:&#39;, t4.label_code, &#39;:&#39;, t4.label_name) 
            SEPARATOR &#39;||&#39;
        ) AS labelData
    FROM
        warehouse_report t
        LEFT JOIN warehouse_report_label_ref t3 ON t3.report_id = t.id AND t3.is_deleted = 0
        LEFT JOIN warehouse_label_manage t4 ON t4.id = t3.label_id AND t4.is_deleted = 0
    WHERE
        t.is_deleted = 0 
        AND t.from_type = 1 
        AND t.create_dept_id = &#39;A001&#39;
    GROUP BY t.id
</select>
```

```java
// 解析 labelData 字符串
reports.forEach(report -> {
    List<WarehouseLabelManage> labels = Arrays.stream(report.getLabelData().split("\\|\\|"))
        .map(item -> {
            String[] parts = item.split(":");
            WarehouseLabelManage label = new WarehouseLabelManage();
            label.setId(Long.parseLong(parts[0]));
            label.setLabelCode(parts[1]);
            label.setLabelName(parts[2]);
            return label;
        })
        .collect(Collectors.toList());
    report.setLabelEntity(labels);
});
```

**注意**：此方法依赖数据库特性，且字符串解析可能影响性能。

---

### **推荐选择**
| 方案 | 适用场景 | 优点 | 缺点 |
|------|----------|------|------|
| **`<resultMap> + <collection>`** | 通用方案 | 纯 SQL 解决，性能最优 | SQL 较复杂 |
| **分两次查询** | 标签数量多 | 代码清晰，易维护 | 需要两次数据库访问 |
| **GROUP_CONCAT** | MySQL 环境 | 减少查询次数 | 数据库耦合，解析复杂 |

**最佳实践**：优先使用 **方案 1**（`<resultMap>`），它是 MyBatis 官方推荐的处理一对多关联的方式。

---

### **其他优化建议**
1. **分页处理**：  
   如果报表数据量大，需在 SQL 中添加分页（如 `LIMIT #{offset}, #{pageSize}`）。
2. **延迟加载**：  
   对标签集合使用 `fetchType="lazy"`，按需加载标签数据：
   ```xml
   <collection property="labelEntity" fetchType="lazy" ... />
   ```
3. **索引检查**：  
   确保 `warehouse_report_label_ref.report_id` 和 `warehouse_label_manage.id` 有索引。

---

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值