实验8 Linux的内存管理

内存管理，不用多说，言简意赅。

在内核里分配内存还真不是件容易的事情，根本上是因为内核不能想用户空间那样奢侈的使用内存。

先来说说内存管理。

内核把物理页作为内存管理的基本单位。

尽管处理器的最小可寻址单位通常是字，但是，内存管理单元MMU通常以页为单位进行处理。

因此，从虚拟内存的交代来看，页就是最小单位。

内核用struct page(linux/mm.h)结构表示系统中的每个物理页:?123 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 Structpage {unsignedlongflags;atomic_t count;unsignedintmapcount;unsignedlongprivate;structaddress_space *mapping;pgoff_t index;structlist_headlru;union{structpte_chain;pte_addr_t;}void*virtual;};flag用来存放页的状态，每一位代表一种状态，所以至少可以同时表示出32中不同的状态,这些状态定义在linux/page-flags.h中。

count记录了该页被引用了多少次。

mapping 指向与该页相关的address_space对象。

virtual是页的虚拟地址，它就是页在虚拟内存中的地址。

要理解的一点是page结构与物理页相关，而并非与虚拟页相关。

因此，该结构对页的描述是短暂的。

内核仅仅用这个结构来描述当前时刻在相关的物理页中存放的东西。

这种数据结构的目的在于描述物理内存本身，而不是描述包含在其中的数据。

1 2 3 4 5 6 7 8 9 10 11 12 13 14spinlock_t lock;unsignedlong free_pages;unsignedlong pages_min, pages_low, pages_high;unsignedlong protection[MAX_NR_ZONES];spinlock_t lru_lock;structlist_head active_list;structlist_head inactive_list;unsignedlong nr_scan_active;unsignedlong nr_scan_inactive;unsigned long nr_active;unsigned long nr_inactive;int all_unreclaimable;unsigned long pages_scanned;15 16 17 18 19 20 21 22 23 24 25 26 27structfree_area free_area[MAX_ORDER];wait_queue_head_t * wait_table;unsigned long wait_table_size;unsigned long wait_table_bits;structper_cpu_pageset pageset[NR_CPUS];structpglist_data *zone_pgdat;structpage *zone_mem_map;unsigned long zone_start_pfn;char *name;unsigned long spanned_pages;unsigned long present_pages;}; 其中的lock 域是一个自旋锁，这个域只保护结构，而不是保护驻留在这个区中的所有页。

Linux内存管理实验一、实验内容：1.利用boches 观测linux0.11 下的GDT 表和LDT 表内容。

2.利用bochs 观测linux0.11 下的内存地址映射过程以及分页机制的实现。

3.利用bochs修改虚拟地址所对应的物理内存中存放的数值，观测程序运行情况的变化。

二、Linux内存管理机制分析1. 物理内存使用划分：为了有效使用物理内存，Linux将内存划分为几个功能区域，其中包括：内核模块区，高速缓冲区，主内存区，如下图：2.地址映射：逻辑地址：该地址是指由程序产生并与代码段相关的偏移地址，分段分页机制对于程序员是透明的，程序员仅需和逻辑地址打交道。

线性地址：是指由逻辑地址到物理地址之间变换的中间层地址。

程序代码会产生逻辑地址（即段内偏移地址），加上相应的段基址就产生了一个线性地址。

若启用分页机制，那么线性地址还要经过一系列变换生成物理地址，若没有启用分页机制，则线性地址就是物理地址（在实地址模式下，线性地址就是物理地址，但是线性地址加大了系统的不安全因素）。

物理地址：是指出现在cpu外部地址总线上的寻址物理内存的地址信号，即地址变换的最终结果。

当采用分页机制时，线性地址通过页目录，页表中的项来变换成物理地址，否则线性地址就直接是物理地址。

3. 段描述符和段选择符：段描述符：i386虚模式下的地址是32位，而段寄存器却只有16位，因此处理器要求系统在内存中创建一系列的表来存放每个段的首地址。

这些表中的内容用来描述一个段的信息，因此这些表叫段描述符表，包括（GDT：全局描述符表，LDT：局部描述符表，IDT：中断描述符表）表中的内容就称为段描述符。

而程序的逻辑地址就是用段和段内的偏移地址表示。

在linux中，程序的逻辑地址到线性地址的变换就是使用了cpu的全局描述符表GDT和局部描述符表LDT。

由GDT映射的地址空间称为全局地址空间，由LDT 映射的地址空间称为局部地址空间，其中LDT是GDT的二级表，即GDT 中存储了LDT的地址。

第三章存储管理存储管理子系统时操作系统中最重要的组成部分之一。

在早期计算时代，由于人们所需要的内存数目远远大于物理内存，人们设计出了各种各样的策略来解决此问题，其中最成功的是虚拟内存技术。

它使得系统中为有限物理内存竞争的进程所需内存空间得到满足。

虚拟内存技术不仅仅可让我们可以使用更多的内存，它还提供了以下功能：巨大的寻址空间操作系统让系统看上去有比实际内存大得多的内存空间。

虚拟内存可以是系统中实际物理空间的许多倍。

每个进程运行在其独立的虚拟地址空间中。

这些虚拟空间相互之间都完全隔离开来，所以进程间不会互相影响。

同时，硬件虚拟内存机构可以将内存的某些区域设置成不可写。

这样可以保护代码与数据不会受恶意程序的干扰。

内存映射内存映射技术可以将映象文件和数据文件直接映射到进程的地址空间。

在内存映射中，文件的内容被直接连接到进程虚拟地址空间上。

公平的物理内存分配内存管理子系统允许系统中每个运行的进程公平地共享系统中的物理内存。

共享虚拟内存尽管虚拟内存允许进程有其独立的虚拟地址空间，但有时也需要在进程之间共享内存。

例如有可能系统中有几个进程同时运行BASH命令外壳程序。

为了避免在每个进程的虚拟内存空间内都存在BASH程序的拷贝，较好的解决办法是系统物理内存中只存在一份BASH的拷贝并在多个进程间共享。

动态库则是另外一种进程间共享执行代码的方式。

共享内存可用来作为进程间通讯(IPC)的手段，多个进程通过共享内存来交换信息。

Linux支持SYSTEM V的共享内存IPC机制。

3.1 虚拟内存的抽象模型图3.1 虚拟地址到物理地址映射的抽象模型在讨论Linux是如何具体实现对虚拟内存的支持前，有必要看一下更简单的抽象模型。

在处理器执行程序时需要将其从内存中读出再进行指令解码。

在指令解码之前它必须向内存中某个位置取出或者存入某个值。

然后执行此指令并指向程序中下一条指令。

在此过程中处理器必须频繁访问内存，要么取指取数，要么存储数据。

Linux内存管理实验一、实验目的1. 通过在Linux环境下对内存管理的基本操作，感性认识Linux如何对内存进行管理。

2. 利用readelf和objdump观测linux下的内存地址映射过程以及进程的虚拟地址空间。

二、实验内容与要求(1)按照实验内容完成实验操作步骤，学习内存管理中的一些常用命令(2)理解linux中逻辑地址、线性地址的概念。

三、实验步骤与测试实验一free命令显示显示内存的使用情况(使用的和空闲的)，包括物理内存、交换区内存、内核缓冲区内存。

不包括共享内存。

free命令默认选项为-k语法:free [-bkmotV] [-s <间隔秒数>]选项介绍:-b: 以Byte为单位显示内存使用情况;-k: 以KB为单位显示内存使用情况;-m: 以MB为单位显示内存使用情况;-o: 不显示缓冲区调节列;-s<间隔秒数>: 每间隔指定时间执行一次free命令;-t: 显示内存总和列;-V: 显示版本信息;（1）free -k: 以KB为单位显示内存使用情况;解释：total: 内存总量: 3355508(k)used: 已经使用的内存量: 490664(k)free: 空闲的内存量: 2864844(k)shared: 当前已经废弃不用，总量是0(k)buffers: 25164（k)Buffer Cache内存量: 263480(k)cached: Page Cache内存量: 21436(k)（2）free –m -s 5:以M为单位，5秒显示以下内存信息解释：以上为每隔5秒显示内存信息，由以上图可知：两次内存使用情况没有变化。

（3）free -o: 不显示缓冲区调节列;解释：由以上可知Buffer Cache这一列没有显示出来。

（4）free -t: 显示内存总和列;解释：如上所示，内存总和是3355508(k)，内存已使用为491408(k)，内存空闲为2864100(k)。

Linux内存管理分析与研究随着计算机技术的不断发展，操作系统在计算机系统中扮演着越来越重要的角色。

作为开源操作系统领域的佼佼者，Linux被广泛用于各种应用场景，包括服务器、桌面、嵌入式系统等。

内存管理是操作系统核心功能之一，对于系统性能和稳定性具有重要影响。

本文将对Linux内存管理进行深入分析，并探讨其存在的问题与解决方案。

Linux内存管理采用分页和分段技术，将物理内存划分为大小不同的页框或段框，以便更有效地利用和管理内存资源。

Linux通过将内存分为内核空间和用户空间，实现了内存的隔离和保护，同时允许用户进程使用不同的内存空间。

Linux内存管理存在的一个主要问题是内存分配不均。

由于内存分配是基于页框或段框的，当某些进程需要更多内存时，操作系统会从空闲的内存页框中分配内存。

然而，在实际情况中，由于页框大小固定，当需要分配大量内存时，可能会造成内存分配不均的情况。

另一个问题是浪费空间。

Linux为了提高内存利用率，采用了一种称为内存分页的技术。

然而，在某些情况下，当进程不再需要使用内存时，操作系统并不会立即将内存页框回收，而是保留在内存中以备将来使用，这可能会导致内存空间的浪费。

针对内存分配不均的问题，可以采取交换技术。

交换技术是一种将进程使用的内存部分移至磁盘上，以腾出更多内存供其他进程使用的方法。

在Linux中，可以使用瑞士文件系统（Swiss File System，SFS）作为交换设备，将不常用的内存页框交换到磁盘上，以便在需要时重新加载。

为了解决内存浪费问题，可以优化内存分配算法。

Linux中使用的内存分配算法是基于伙伴系统的，该算法会跟踪每个内存块的空闲状态。

当需要分配内存时，伙伴系统会选择一个适当大小的空闲块，并将其划分为所需的内存大小。

为了避免内存浪费，可以采取以下措施：增加空闲内存块的大小，以便更好地适应大内存需求；引入动态内存分配机制，使操作系统能够在需要时分配和回收内存；定期清理不再使用的内存块，以便及时回收内存空间。

HUNAN UNIVERSITY 操作系统实验报告题目：LAB8目录一、实验目的 (3)二、实验内容 (3)三、练习题 (3)练习0 (3)练习1 (4)练习2 (10)四、实验结果 (13)一、实验目的通过完成本次实验，希望能达到以下目标了解基本的文件系统系统调用的实现方法；了解一个基于索引节点组织方式的Simple FS文件系统的设计与实现；了解文件系统抽象层-VFS的设计与实现；二、实验内容实验七完成了在内核中的同步互斥实验。

本次实验涉及的是文件系统，通过分析了解ucore 文件系统的总体架构设计，完善读写文件操作，从新实现基于文件系统的执行程序机制（即改写do_execve），从而可以完成执行存储在磁盘上的文件和实现文件读写等功能三、练习练习0：填写已有实验本实验依赖实验1/2/3/4/5/6/7。

请把你做的实验1/2/3/4/5/6/7的代码填入本实验中代码中有“LAB1”/“LAB2”/“LAB3”/“LAB4”/“LAB5”/“LAB6”/“LAB7”的注释相应部分。

并确保编译通过。

注意：为了能够正确执行lab8的测试应用程序，可能需对已完成的实验1/2/3/4/5/6/7的代码进行进一步改进将其与lab7文件对比，得到缺失文件如下：proc.cdefault_pmm.cpmm.cswap_fifo.cvmm.ctrap.csche.cmonitor.check_sync.c补全后不需要在7的基础上改了练习1: 完成读文件操作的实现（需要编码）首先了解打开文件的处理流程，然后参考本实验后续的文件读写操作的过程分析，编写在sfs_inode.c中sfs_io_nolock读文件中数据的实现代码。

请在实验报告中给出设计实现”UNIX的PIPE机制“的概要设方案，鼓励给出详细设计方案要求是首先了解打开文件的处理流程，然后参考本实验后续的文件读写操作的过程分析，编写在sfs_inode.c中sfs_io_nolock读文件中数据的实现代码。

存储实验指导书深圳市讯方通信技术有限公司二零一四年七月版实验8、存储LUN配置实验一、实验目的熟练掌握S2600存储阵列LUN创建和划分的原则及流程可以熟练规划并创建需要LUN二、实验器材存储设备S2600一套，PC客户端一台。

三、实验内容说明通过现场操练，让学生掌握存储的RAID和LUN配置关系。

四、实验步骤(一)实验前准备1、设备条件S2600已经完成硬件安装，上电无异常，ISM初始化配置完成。

2、服务器条件EB服务器已经安装ISM客户端并正常运行，EB服务器的地址1和S2600的管理地址在同一网段，且能够正常通讯；EB服务器的地址2和EC616控制台地址在同一网段，且能够正常连接到S2600的端口通讯。

以上前提都正常，才可以进行以下实验操作。

3、服务器配置条件实验管理系统中完成存储设备初始化。

实验管理系统中完成设备组划分、学生组划分、存储实验环境搭建，并初始化完成，实验状态为“正在进行…”。

EB Storage SERVER 服务端启动成功。

4、客户端条件PC 客户端支持以下操作系统：Microsoft Windows XPMicrosoft Windows 2003资源要求：内存为1GB，硬盘空间大于40GB。

PC客户端到服务器网络通信正常。

PC客户端到存储业务口网络通信正常。

学生机完成EB Storage Client安装。

(二)创建LUN知识根据业务的需要，可以在RAID组中创建多个LUN。

将RAID组的存储空间划分为多个逻辑单元后，将存储资源更合理的分配给应用服务器使用。

前提条件系统中已经创建RAID组。

背景信息与LUN相关的概念：•分条深度：指在使用分条数据映射的硬盘阵列中，条带内的块数量。

也指在硬盘阵列的单个成员盘区中，连续编址的虚拟硬盘块映射到连续编址的块的数量。

在不同的应用场景下应选择适当的分条深度大小。

当存储系统应用于存储顺序数据较多的情况下，如存储媒体数据，建议设置较大的分条深度。

操作系统实验报告院别：XXXXXX班级：XXXXXX学号：XXXXXX姓名：稻草人一、实验目的1、通过本次试验体会操作系统中内存的分配模式；2、掌握内存分配的方法（FF,BF,WF）；3、学会进程的建立，当一个进程被终止时内存是如何处理被释放块，并当内存不满足进程申请时是如何使用内存紧凑；4、掌握内存回收过程及实现方法；5、学会进行内存的申请释放和管理；二、实验内容附源代码：/*宏定义*/#include<stdio.h>#include<stdlib.h>#include<sys/types.h>#define PROCESS_NAME_LEN 32 /*进程名称的最大长度*/#define MIN_SLICE 10 /*最小碎片的大小*/#define DEFAULT_MEM_SIZE 1024 /*默认内存的大小*/#define DEFAULT_MEM_START 0 /*默认内存的起始位置*//* 内存分配算法 */#define MA_FF 1#define MA_BF 2#define MA_WF 3int mem_size=DEFAULT_MEM_SIZE; /*内存大小*/int ma_algorithm = MA_FF; /*当前分配算法*/int flag = 0; /*设置内存大小标志*/static int pid = 0; /*初始pid*/int algorithm;/*描述每一个空闲块的数据结构*/struct free_block_type{int size;int start_addr;struct free_block_type *next;};/*指向内存中空闲块链表的首指针*/struct free_block_type *free_block;/*每个进程分配到的内存块的描述*/struct allocated_block{int pid;int size;int start_addr;char process_name[PROCESS_NAME_LEN];struct allocated_block *next;};/*进程分配内存块链表的首指针*/struct allocated_block *allocated_block_head = NULL;struct allocated_block *find_process(int id){struct allocated_block *p;p=allocated_block_head;while(p!=NULL){if (p->pid==id)return p;}return NULL;}void swap(int *p,int *q){int temp;temp = *p;*p = *q;*q = temp;return;}void do_exit(){exit(0);}/*初始化空闲块，默认为一块，可以指定大小及起始地址*/ struct free_block_type* init_free_block(int mem_size){ struct free_block_type *fb;fb=(struct free_block_type *)malloc(sizeof(struct free_block_type)); if(fb==NULL){printf("No mem\n");return NULL;}fb->size = mem_size;fb->start_addr = DEFAULT_MEM_START;fb->next = NULL;return fb;}/*显示菜单*/display_menu(){printf("\n");printf("1 - Set memory size (default=%d)\n", DEFAULT_MEM_SIZE);printf("2 - Select memory allocation algorithm\n");printf("3 - New process \n");printf("4 - Terminate a process \n");printf("5 - Display memory usage \n");printf("0 - Exit\n");}/*设置内存的大小*/set_mem_size(){int size;if(flag!=0){ //防止重复设置printf("Cannot set memory size again\n");return 0;}printf("Total memory size =");scanf("%d", &size);if(size>0) {mem_size = size;free_block->size = mem_size;}flag=1; return 1;}/*按FF算法重新整理内存空闲块链表*/rearrange_FF(){struct free_block_type *tmp, *work;printf("Rearrange free blocks for FF \n");tmp = free_block;while(tmp!=NULL){ work = tmp->next;while(work!=NULL){{ /*地址递增*/swap(&work->start_addr, &tmp->start_addr); swap(&work->size, &tmp->size);}work=work->next;}tmp = tmp -> next;}}/*按BF最佳适应算法重新整理内存空闲块链表*/rearrange_BF(){struct free_block_type *tmp, *work;printf("Rearrange free blocks for BF \n");tmp = free_block;while(tmp!=NULL){ work = tmp->next;while(work!=NULL){if ( work->size > tmp->size) { /*地址递增*/swap(&work->start_addr, &tmp->start_addr); swap(&work->size, &tmp->size);}work=work->next;}tmp = tmp -> next;}}/*按WF算法重新整理内存空闲块链表*/rearrange_WF(){struct free_block_type *tmp, *work;printf("Rearrange free blocks for WF \n");tmp = free_block;while(tmp!=NULL){ work = tmp->next;while(work!=NULL){if ( work->size < tmp->size) { /*地址递增*/swap(&work->start_addr, &tmp->start_addr); swap(&work->size, &tmp->size);}else}tmp = tmp -> next;}}/*按指定的算法整理内存空闲块链表*/rearrange(int algorithm){switch(algorithm){case MA_FF: rearrange_FF(); break;case MA_BF: rearrange_BF(); break;case MA_WF: rearrange_WF(); break;}}/* 设置当前的分配算法 */set_algorithm(){printf("\t1 - First Fit\n");printf("\t2 - Best Fit \n");printf("\t3 - Worst Fit \n");scanf("%d", &algorithm);if(algorithm>=1 && algorithm <=3) ma_algorithm=algorithm;//按指定算法重新排列空闲区链表rearrange(ma_algorithm); }/*分配内存模块*/int allocate_mem(struct allocated_block *ab){struct free_block_type *fbt, *pre, *temp,*work;int request_size=ab->size;fbt = free_block;while(fbt!=NULL){if(fbt->size>=request_size){if (fbt->size - request_size >= MIN_SLICE) /*分配后空闲空间足够大，则分割*/{mem_size -= request_size;fbt->size -= request_size;ab->start_addr= fbt->start_addr;fbt->start_addr += request_size;}else if (((fbt->size - request_size) < MIN_SLICE)&&((fbt->size - request_size) > 0))/*分割后空闲区成为小碎片，一起分配*/{mem_size -= fbt->size;pre = fbt->next;fbt->start_addr += fbt->size;free(fbt);}else{temp = free_block;while(temp!=NULL){work = temp->next;if(work!=NULL)/*如果当前空闲区与后面的空闲区相连，则合并*/{if (temp->start_addr+temp->size == work->start_addr) {temp->size += work->size;temp->next = work->next;free(work);continue;}}temp = temp->next;}fbt = free_block;break;}rearrange(algorithm); /*重新按当前的算法排列空闲区*/return 1;}pre = fbt;fbt = fbt->next;}return -1;}/*创建新的进程，主要是获取内存的申请数量*/new_process(){struct allocated_block *ab;int size;int ret;ab=(struct allocated_block *)malloc(sizeof(struct allocated_block));if(!ab) exit(-5);ab->next = NULL;sprintf(ab->process_name, "PROCESS-%02d", pid);ab->pid = pid;printf("Memory for %s:", ab->process_name);scanf("%d", &size);if(size>0) ab->size=size;ret = allocate_mem(ab); /* 从空闲区分配内存，ret==1表示分配ok*//*如果此时allocated_block_head尚未赋值，则赋值*/if((ret==1) &&(allocated_block_head == NULL)){allocated_block_head=ab;return 1;}/*分配成功，将该已分配块的描述插入已分配链表*/else if (ret==1) {ab->next=allocated_block_head;allocated_block_head=ab;return 2;}else if(ret==-1){ /*分配不成功*/printf("Allocation fail\n");free(ab);return -1;}return 3;}/*将ab所表示的已分配区归还，并进行可能的合并*/int free_mem(struct allocated_block *ab){int algorithm = ma_algorithm;struct free_block_type *fbt, *work;fbt=(struct free_block_type*) malloc(sizeof(struct free_block_type)); if(!fbt) return -1;fbt->size = ab->size;fbt->start_addr = ab->start_addr;/*插入到空闲区链表的头部并将空闲区按地址递增的次序排列*/fbt->next = free_block;free_block=fbt;rearrange(MA_FF);fbt=free_block;while(fbt!=NULL){work = fbt->next;if(work!=NULL){/*如果当前空闲区与后面的空闲区相连，则合并*/{fbt->size += work->size;fbt->next = work->next;free(work);continue;}}fbt = fbt->next;}rearrange(algorithm); /*重新按当前的算法排列空闲区*/return 1;}/*释放ab数据结构节点*/int dispose(struct allocated_block *free_ab){struct allocated_block *pre, *ab;if(free_ab == allocated_block_head) { /*如果要释放第一个节点*/allocated_block_head = allocated_block_head->next;free(free_ab);return 1;}pre = allocated_block_head;ab = allocated_block_head->next;while(ab!=free_ab){ pre = ab; ab = ab->next; }pre->next = ab->next;free(ab);return 2;}/* 显示当前内存的使用情况，包括空闲区的情况和已经分配的情况 */display_mem_usage(){struct free_block_type *fbt=free_block;struct allocated_block *ab=allocated_block_head;if(fbt==NULL) return(-1);printf("----------------------------------------------------------\n");/* 显示空闲区 */printf("Free Memory:\n");printf("%20s %20s\n", " start_addr", " size");while(fbt!=NULL){printf("%20d %20d\n", fbt->start_addr, fbt->size);fbt=fbt->next;/* 显示已分配区 */printf("\nUsed Memory:\n");printf("%10s %20s %10s %10s\n", "PID", "ProcessName", "start_addr", " size");while(ab!=NULL){printf("%10d %20s %10d %10d\n", ab->pid, ab->process_name, ab->start_addr, ab->size); ab=ab->next;}printf("----------------------------------------------------------\n");return 0;}/*删除进程，归还分配的存储空间，并删除描述该进程内存分配的节点*/kill_process(){struct allocated_block *ab;int pid;printf("Kill Process, pid=");scanf("%d", &pid);ab=find_process(pid);if(ab!=NULL){free_mem(ab); /*释放ab所表示的分配区*/dispose(ab); /*释放ab数据结构节点*/}}main(){char choice;pid=0;free_block = init_free_block(mem_size); //初始化空闲区for(;;){display_menu(); //显示菜单fflush(stdin);choice=getchar(); //获取用户输入switch(choice){case '1': set_mem_size(); break; //设置内存大小case '2': set_algorithm(); flag=1; break; //设置分配算法case '3': new_process(); flag=1; break; //创建新进程case '4': kill_process(); flag=1; break; //删除进程case '5': display_mem_usage(); flag=1; break //显示内存使用case '0': do_exit(); exit(0); break; //释放链表并退出default: break;}}三、实验结果实验界面：提示输入以后，输入 1，显示如下：紧接着输入： 3，设置内存空间为 256，显示如下：重复一次上一操作。

内存管理实验报告西安邮电大学（计算机学院）课内实验报告实验名称：内存管理专业名称：软件工程班级：学生姓名：学号（8位）：指导教师：实验日期：2018年12月04日一.实验目的及实验环境1、实验环境Linux centos7系统gcc编译器 gdb调试2、实验目的(1)掌握内存分配FF，BF，WF策略及实现的思路；(2)掌握内存回收过程及实现思路；(3)参考本程序思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。

二.实验内容(1)掌握内存分配FF，BF，WF策略及实现的思路；(2)掌握内存回收过程及实现思路；(3)参考本程序思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。

三．方案设计----------------------------------------------------------Memory management experiment1 - Set memory size (default=1024)2 - Select memory allocation algorithm3 - New process4 - kill a process5 - Display memory usage0 - Exit----------------------------------------------------------一、首次适应算法（First Fit）：该算法从空闲分区链首开始查找，直至找到一个能满足其大小要求的空闲分区为止。

然后再按照作业的大小，从该分区中划出一块内存分配给请求者，余下的空闲分区仍留在空闲分区链中。

特点：该算法倾向于使用内存中低地址部分的空闲区，在高地址部分的空闲区很少被利用，从而保留了高地址部分的大空闲区。

显然为以后到达的大作业分配大的内存空间创造了条件。

缺点：低地址部分不断被划分，留下许多难以利用、很小的空闲区，而每次查找又都从低地址部分开始，会增加查找的开销。