操作系统内存可变分区管理实验报告
操作系统实验-可变分区存储管理
作业一实验一 ：可变分区存储管理（一） 实验题目编写一个C 程序，用char *malloc(unsigned size)函数向系统申请一次内存空间（如size=1000，单位为字节），模拟可变分区内存管理，实现对该内存区的分配和释放管理。
（二） 实验目的1．加深对可变分区的存储管理的理解；2．提高用C 语言编制大型系统程序的能力，特别是掌握C 语言编程的难点：指针和指针作为函数参数；3．掌握用指针实现链表和在链表上的基本操作。
（三）程序代码 #include<malloc.h> #include<stdio.h> #include<string.h>#define new(type) (type *)malloc(sizeof(type))typedef struct _map {unsigned int size; char *address; struct _map *next; struct _map *prev;(a)(b)(c)(d)图2-9释放区与前后空闲区相邻的情况} map;typedef map *pmap;typedef struct _mem{unsigned int totalSize;char* space;pmap head;pmap cMap;} mem;typedef mem *pmem;pmem createMem(unsigned int to_size) //创建内存区域{pmem newMem=new(mem);pmap newHead=new(map);newMem->totalSize=to_size;newHead->size=to_size;newHead->address=newMem->space;newHead->next=newHead;newHead->prev=newHead;newMem->head=newHead;newMem->cMap=newHead;return newMem;}void freeMem(pmem m){pmap map,cMap;pmap head=m->head;free(map->address);for(map=head;map->next!=head;){cMap=map;map=cMap->next;free(cMap);}free(m);}char* lmalloc(pmem cMem,unsigned int size) //分配函数{if(size>1000){printf("内存容量超出范围!\n"); //当需要分配的内存空间已经大于实际空间时出错}else{pmap p=cMem->cMap;char* rAddr;if(size==0)return NULL;while(p->size<size){if(p->next==cMem->cMap)return NULL;p=p->next;}rAddr=p->address;p->size-=size;p->address+=size;if(p->size==0){p->prev->next=p->next;p->next->prev=p->prev;cMem->cMap=p->next;if(cMem->head==p)cMem->head=p->next;if(p->next!=cMem->head)free(p);}else{cMem->cMap=p;}return rAddr;}}void lfree(pmem m,unsigned int size,char* addr) //释放函数{pmap nextMap,prevMap,newMap;if(addr<m->space || addr>=m->space+m->totalSize){fprintf(stderr,"地址越界\n"); //释放空间时，大小输入出错return;}nextMap=m->head;while(nextMap->address<addr){nextMap=nextMap->next;if(nextMap==m->head)break;}prevMap=nextMap->prev;if(nextMap!=m->head && prevMap->address+prevMap->size==addr) //第一种情况{prevMap->size+=size;if(addr+size==nextMap->address) //第二种情况{prevMap->size+=nextMap->size;prevMap->next=nextMap->next;prevMap->next->prev=prevMap;if(nextMap==m->cMap){m->cMap=prevMap;}free(nextMap);nextMap=NULL;}}else{if(addr+size==nextMap->address) //第三种情况{nextMap->address-=size;nextMap->size+=size;}else //第四种情况{newMap=new(map);newMap->address=addr;newMap->size=size;prevMap->next=newMap;newMap->prev=prevMap;newMap->next=nextMap;nextMap->prev=newMap;if(nextMap==m->head)m->head=newMap;}}}void printMem(pmem m) //打印函数{pmap map=m->head;printf("\空闲内存空间:\n\-----------------------\n\大小起始地址\n");do{if(map==m->cMap)printf("-> ");elseprintf(" ");printf("%10u %10u\n",map->size,map->address);map=map->next;}while(map!=m->head);printf("-----------------------\n");}void main() //主函数{printf("--------------------------------------------------------\n");printf("请选择操作：分配内存(m) or 释放内存(f) or 打印内存表(p)\n");printf("--------------------------------------------------------\n");typedef enum{cmdMalloc,cmdFree,cmdPrint,cmdHelp,cmdQuit,cmdInvalid} cmdType; pmem m=createMem(1000);char cmd[20];char *addr;unsigned int size;cmdType type;while(1){scanf("%s",cmd);if(cmd[1]=='\0'){switch(cmd[0]){case 'm':case 'M':type=cmdMalloc;break;case 'f':case 'F':type=cmdFree;break;case 'p':case 'P':type=cmdPrint;break;}}else{if(!strcmp(cmd,"malloc"))type=cmdMalloc;else if(!strcmp(cmd,"free"))type=cmdFree;else if(!strcmp(cmd,"print"))type=cmdPrint;}switch(type){case cmdMalloc:scanf("%u",&size);lmalloc(m,size);printMem(m);break;case cmdFree:scanf("%u %u",&size,&addr);lfree(m,size,addr);printMem(m);break;case cmdPrint:printMem(m);break;return;}}}（四）程序结果。
可变分区管理实验
实验三、可变分区内存管理实验环境：实验环境一：Windows平台实验时间：6小时实验目的：体会可变分区内存管理方案，掌握此方案的内存分配过程、内存回收过程和紧凑算法的实现。
实验目标：编制一个程序模拟实现可变分区内存管理。
实验时，假设系统内存容量为1000KB。
分配时使用malloc(pid, length)函数实现，作业释放内存时使用mfree(handle)函数实现，内存情况输出用mlist()函数实现。
实验步骤：1、编写主界面，界面上有三个选项：分配内存、回收内存、查看内存。
选择分配内存时，要求输入作业的进程号和作业长度，然后使用malloc函数分配内存，并报告内存分配结果。
回收内存时要求输入进程号，使用mfree函数实现回收。
查看内存时，使用mlist函数实现输出内存使用情况和空闲情况。
2、编写malloc(pid, length)函数，实现进程pid申请length KB内存，要求程序判断是否能分配，如果能分配，要把分配内存的首地址handle输出到屏幕上。
不能分配则输出字符串“NULL”。
要考虑不能简单分配时，是否符合紧凑的条件，如符合则采用紧凑技术，然后再分配。
分配时可在最佳适应算法、最差适应算法和首次适应算法中任选其一。
3、编写mfree(handle)函数，释放首地址为handle的内存块。
释放成功返回Success，否则返回Failure。
4、编写mlist()函数，要求输出内存使用情况和空闲情况。
输出的格式为：ID Address Length ProcessID 内存分区号Address 该分区的首地址Length 分区长度Process 如果使用，则为使用的进程号，否则为NULL实验结果：实验步骤2的实现过程是：实验步骤2中紧凑算法是如何实现的？实验步骤3中分别要考虑多少种情况？实验步骤3的实现过程是：实验步骤4的实现过程是：实验步骤4的结果是什么？实验报告：（1）完成实验结果中的问题。
实现内存分配实验报告(3篇)
第1篇一、实验目的1. 理解操作系统内存分配的基本原理和常用算法。
2. 掌握动态分区分配方式中的数据结构和分配算法。
3. 通过编写程序，实现内存分配和回收功能。
二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 开发工具：GCC编译器三、实验原理1. 内存分配的基本原理操作系统内存分配是指操作系统根据程序运行需要，将物理内存分配给程序使用的过程。
内存分配算法主要包括以下几种：（1）首次适应算法（First Fit）：从内存空间首部开始查找，找到第一个满足条件的空闲区域进行分配。
（2）最佳适应算法（Best Fit）：在所有满足条件的空闲区域中，选择最小的空闲区域进行分配。
（3）最坏适应算法（Worst Fit）：在所有满足条件的空闲区域中，选择最大的空闲区域进行分配。
2. 动态分区分配方式动态分区分配方式是指操作系统在程序运行过程中，根据需要动态地分配和回收内存空间。
动态分区分配方式包括以下几种：（1）固定分区分配：将内存划分为若干个固定大小的分区，程序运行时按需分配分区。
（2）可变分区分配：根据程序大小动态分配分区，分区大小可变。
（3）分页分配：将内存划分为若干个固定大小的页，程序运行时按需分配页。
四、实验内容1. 实现首次适应算法（1）创建空闲分区链表，记录空闲分区信息，包括分区起始地址、分区大小等。
（2）编写分配函数，实现首次适应算法，根据程序大小查找空闲分区，分配内存。
（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。
2. 实现最佳适应算法（1）创建空闲分区链表，记录空闲分区信息。
（2）编写分配函数，实现最佳适应算法，根据程序大小查找最佳空闲分区，分配内存。
（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。
3. 实验结果分析（1）通过实验，验证首次适应算法和最佳适应算法的正确性。
（2）对比两种算法在内存分配效率、外部碎片等方面的差异。
五、实验步骤1. 创建一个动态内存分配模拟程序，包括空闲分区链表、分配函数和回收函数。
操作系统存储管理实验报告
操作系统存储管理实验报告一、实验目的操作系统的存储管理是计算机系统中非常重要的组成部分，它直接影响着系统的性能和资源利用率。
本次实验的目的在于深入理解操作系统中存储管理的基本原理和方法，通过实际操作和观察，掌握存储分配、回收、地址转换等关键技术，并对不同存储管理策略的性能进行分析和比较。
二、实验环境本次实验在 Windows 10 操作系统下进行，使用 Visual Studio 2019 作为编程环境，编程语言为 C+＋。
三、实验内容（一）固定分区存储管理1、原理固定分区存储管理将内存空间划分为若干个固定大小的分区，每个分区只能装入一道作业。
分区的大小可以相等，也可以不等。
2、实现创建一个固定大小的内存空间数组，模拟内存分区。
为每个分区设置状态标志（已分配或空闲），并实现作业的分配和回收算法。
3、实验结果与分析通过输入不同大小的作业请求，观察内存的分配和回收情况。
分析固定分区存储管理的优缺点，如内存利用率低、存在内部碎片等。
（二）可变分区存储管理1、原理可变分区存储管理根据作业的实际需求动态地划分内存空间，分区的大小和数量是可变的。
2、实现使用链表或数组来管理内存空间，记录每个分区的起始地址、大小和状态。
实现首次适应、最佳适应和最坏适应等分配算法，以及分区的合并和回收算法。
3、实验结果与分析比较不同分配算法的性能，如分配时间、内存利用率等。
观察内存碎片的产生和处理情况，分析可变分区存储管理的优缺点。
（三）页式存储管理1、原理页式存储管理将内存空间和作业都划分为固定大小的页，通过页表将逻辑地址转换为物理地址。
2、实现设计页表结构，实现逻辑地址到物理地址的转换算法。
模拟页面的调入和调出过程，处理缺页中断。
3、实验结果与分析测量页式存储管理的页面置换算法（如先进先出、最近最少使用等）的命中率，分析其对系统性能的影响。
探讨页大小的选择对存储管理的影响。
（四）段式存储管理1、原理段式存储管理将作业按照逻辑结构划分为若干个段，每个段有自己的名字和长度。
操作系统实验-可变分区存储管理
实验四可变分区存储管理学时：4学时⒈实验内容主存储器空间分配实验。
⒉实验目的通过首次适应算法、最佳适应算法和最坏适应算法实现主存空间的分配，可以使读者可好地理解存储分配算法。
⒊实验题目编写一段程序来模拟可变分区管理方法。
要求能通过文件形式定义空闲区表；能随意输入作业及需要分配的空间；能分别使用首次适应算法、最佳适应算法和最坏适应算法对输入的作业进行空间分配；能显示系统空闲表和已分配空间表。
⒋实验提示⑴可变分区方式是按作业需要的主存空间大小来分区。
当装入一个作业时，首先要查看是否有足够的空闲空间来分配，若有则按指定的分配方式进行分配；否则作业不能装入。
随着作业的装入和撤离主存空间被分为若干个大大小小的不连续的区间，为了表明各区间的状态可以用一个内存分区表如表1所示来表示。
表1 内存分区表这样我们可以定义一个如下的结构表示内存分区信息。
typedef struct node{int start; //起始地址int length; //长度char tag[20]; //标志}job;⑵可变分区的三种算法就是为作业分配主存空间的方法。
●首次适应算法：在空闲区间中查询满足作业需要的空间，并将作业装入第一个满足条件的空间中去。
●最佳适应算法：在空闲区间中查询满足作业需要的空间，并将作业装入满足条件的空闲空间中最小的一个空间中去。
●最坏适应算法：在空闲区间中查询满足作业需要的空间，并将作业装入满足条件的空闲空间中最大的一个空间中去。
从三种算法的说明可以看出，分配空间的过程主要可以分两步：●查询所有满足作业需求的空间块。
●按照指定的算法将作业装入空间块中。
⑶在操作的最初主存空间实际就是一个大的空闲区，不涉及到如何分配的问题。
为直接模拟运行一段时间后主存中出现了多个空闲块的状态，题目要求从一个文件读入空闲区表。
在这里我们可以设计一个空闲区表文件的结构为如表2所示：表2 空闲区表这样也可以方便地将空闲表一次读入程序中，而不必再一个个的输入。
可变分区存储管理实验报告
实验三可变分区存储管理
一、实验目的
通过编写可变分区存储模拟系统，掌握可变分区存储管理的基本原理，分区的分配与回收过程。
二、实验内容与步骤
1.打开程序,所得程序界面窗口如图3-1：
图3-1
2.首先选择算法：是否使用搬家算法，可以通过界面上的按钮或算法菜单栏进行
选择；如果不先选择算法，其他功能将被隐藏；注意：在程序执行过程中，不可以重新选择算法。
3.进行初始化：设置内存大小，可以选择默认值400KB；确定内存大小前，其他
操作将被屏蔽。
4.初始化内存大小以后，就可以进行添加进程操作。
5.添加一个进程后，撤消进程功能被激活，可以撤消一个选定的进程或所有的进
程（图3-2）
图3-2
6．查询功能：可以通过按钮或菜单栏显示内存状态图形、空闲区图表，还可以在内存状态条里闪烁显示某一在空闲区图表选中的空闲区。
7．内存不足但经过搬家算法可以分配内存空间给进程，将有如下（图3-3）提示：
图3-3
8．内存空间不足也有相应提示。
9．重置或退出。
三、实验结果
第一至四组数据测试采用搬家算法，第二至八组数据测试不采用搬家算法。
第一组测试数据：(测试内存错误输入) 选择搬家算法，内存大小：0KB/-50KB/空
第二组测试数据：（测试内存空间不够）选择搬家算法，内存大小：400KB
第三组测试数据：（测试是否采用最佳适应法）选择搬家算法，内存大小：200KB 第四组数据：（测试搬家算法）选择搬家算法，内存大小：400KB
第五组数据至第八组数据：不采用搬家算法，内存大小：分别与第一至第四组数据相同，操作过程：分别与第一至第四组数据相同。
操作系统内存管理实验报告
操作系统内存管理实验报告操作系统内存管理实验报告引言：操作系统是计算机系统中的核心软件，负责管理计算机系统的各种资源，其中内存管理是操作系统的重要功能之一。
内存管理的目标是有效地管理计算机的内存资源，提高计算机系统的性能和可靠性。
本实验旨在通过设计和实现一个简单的内存管理系统，加深对操作系统内存管理原理的理解，并通过实践来加深对操作系统的认识。
一、实验背景计算机内存是计算机系统中的重要组成部分，它用于存储程序和数据。
在操作系统中，内存被划分为多个不同的区域，每个区域有不同的用途和访问权限。
内存管理的主要任务是为进程分配内存空间，并进行合理的管理和调度，以提高系统的性能和资源利用率。
二、实验目的本实验旨在通过设计和实现一个简单的内存管理系统，加深对操作系统内存管理原理的理解，并通过实践来加深对操作系统的认识。
具体目标包括：1. 设计和实现一个简单的内存分配算法，实现内存的动态分配和回收；2. 实现内存的地址映射机制，实现虚拟地址到物理地址的转换；3. 实现内存保护机制，确保进程之间的内存隔离和安全性；4. 实现内存的页面置换算法，提高内存的利用率和性能。
三、实验设计与实现1. 内存分配算法为了实现内存的动态分配和回收，我们设计了一个简单的内存分配算法。
该算法根据进程的内存需求和剩余内存空间的大小，选择合适的内存块进行分配。
当进程结束或释放内存时，将已使用的内存块标记为空闲状态，以便下次分配。
2. 地址映射机制为了实现虚拟地址到物理地址的转换，我们设计了一个地址映射机制。
该机制使用页表来记录虚拟地址与物理地址的映射关系。
当进程访问内存时，操作系统根据页表将虚拟地址转换为物理地址，并进行内存访问。
3. 内存保护机制为了确保进程之间的内存隔离和安全性，我们实现了一个简单的内存保护机制。
该机制通过设置每个进程的访问权限，限制进程对内存的读写操作。
只有获得相应权限的进程才能访问内存，确保进程之间的数据安全和隔离。
操作系统实验之内存管理实验报告
操作系统实验之内存管理实验报告一、实验目的内存管理是操作系统的核心功能之一，本次实验的主要目的是深入理解操作系统中内存管理的基本原理和机制，通过实际编程和模拟操作，掌握内存分配、回收、地址转换等关键技术，提高对操作系统内存管理的认识和实践能力。
二、实验环境本次实验在 Windows 操作系统下进行，使用 Visual Studio 作为编程环境，编程语言为 C+＋。
三、实验原理1、内存分配算法常见的内存分配算法有首次适应算法、最佳适应算法和最坏适应算法等。
首次适应算法从内存的起始位置开始查找，找到第一个满足需求的空闲分区进行分配；最佳适应算法则选择大小最接近需求的空闲分区；最坏适应算法选择最大的空闲分区进行分配。
2、内存回收算法当进程结束释放内存时，需要将其占用的内存区域回收至空闲分区链表。
回收过程中需要考虑相邻空闲分区的合并，以减少内存碎片。
3、地址转换在虚拟内存环境下，需要通过页表将逻辑地址转换为物理地址，以实现进程对内存的正确访问。
四、实验内容1、实现简单的内存分配和回收功能设计一个内存管理模块，能够根据指定的分配算法为进程分配内存，并在进程结束时回收内存。
通过模拟多个进程的内存请求和释放，观察内存的使用情况和变化。
2、实现地址转换功能构建一个简单的页式存储管理模型，模拟页表的建立和地址转换过程。
给定逻辑地址，能够正确计算出对应的物理地址。
五、实验步骤1、内存分配和回收功能实现定义内存分区的数据结构，包括起始地址、大小、使用状态等信息。
实现首次适应算法、最佳适应算法和最坏适应算法的函数。
创建空闲分区链表，初始化为整个内存空间。
模拟进程的内存请求，调用相应的分配算法进行内存分配，并更新空闲分区链表。
模拟进程结束，回收内存，处理相邻空闲分区的合并。
2、地址转换功能实现定义页表的数据结构，包括页号、页框号等信息。
给定页面大小和逻辑地址，计算页号和页内偏移。
通过页表查找页框号，结合页内偏移计算出物理地址。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{
/* ఘ٭2 */
(bp-1)->m_size += bp->m_size;
while (bp->m_size)
{
bp++;
(bp-1)->m_addr = bp->m_addr;
(bp-1)->m_size = bp->m_size;
}
}
}
else
{
if (a+size == bp->m_addr && bp->m_size)
printf("य़ੜ:%4d ࣈ࣎:%p\n",coremap[i].m_size, coremap[i].m_addr); #ifdef AUTO
fprintf(output,"य़ੜ:%4d ࣈ࣎:%p\n",coremap[i].m_size, coremap[i].m_addr); #endif
if (bp>coremap && (bp-1)->m_addr+(bp-1)->m_size == a)
{
/* ఘ٭1,2 */
loopBp = bp-1;
loopBp->m_addr = (bp-1)->m_addr;
(bp-1)->m_size += size;
/* ఘ٭1 */
if (a+size == bp->m_addr)
coremap[i].m_addr = NULL; coremap[i].m_size = 0; } }
/* ᬌڊᤒጱٖ */ void printcoremap(FILE *output) {
/* Function body: ܦcoremapᤒӾݱᶱጱm_sizem_addr */ int i; for (i = 0; i<N; ++i) {
register char *a; register struct map *bp;
for (bp = loopBp; bp->m_size; bp++) {
if(bp->m_size >= size) {
a = bp->m_addr; bp->m_addr += size; if((bp->m_size -= size) == 0)
ݢզಋٚಧᬌڊᕮຎݸݸٚᬌکկӾ҅ਫḵಸޞጱਁٖኧᛔ૩ഩൎ҅ ᚆग़ᚆ̶ */
#include <stdio.h> #include <stdlib.h>
#define AUTO
//ᛔۖ݇හᬌف໒ୗ
//#define MANUAL
//ಋۖ݇හᬌفཛྷୗ
#define N 5
#define INPUT_FILE_PATH "/Users/LXC/Desktop/InPutFile.txt" //կᬌف᪠ஆ
#define OUTPUT_FILE_PATH "/Users/LXC/Desktop/OutPutFile.txt"
/* ᤒጱਧԎ */
struct map
{
unsigned m_size;
ሾḒེᭇଫဩҁṛӞྍ҂ addr = (char *)lmalloc(unsigned size) lfree(unsigned size,char * addr)
ཛྷUNIXਂٖ܄ړݒݢᓕቘ҅ਫሿᧆٖਂ܄ጱړᯈ᯽නᓕቘ̶
2̵ᓒဩమ༷ᥝ
ҁ1҂᭗ᬦහᕟᓕቘٖਂӾᑮᳳ܄ጱ᩸তࣈ࣎ᳩଶ҅ইຎړᯈጱᳩଶᒵԭᑮᳳ܄ጱ ᳩଶᮎԍᧆᑮᳳ܄੪ଫᧆහᕟӾڢᴻ҅ᓕቘᑮᳳ܄ጱහᕟزᔰӞེஃڹᑏۖ҅ইຎ ᯽නጱᑮᳵᑮᳳ܄ፘᮝ੪ᬰᤈݳଚ̶ሾḒེᭇଫᓒဩጱ໐ஞమԅݱӻᑮᳳ܄ ጱړᯈ᷇ሲፘ҅ݶಅզ౯ֵአӞӻᶉாᰒݒᰁֵٌݻහᕟӾᤩړᯈጱݸᶎጱᮎࣘ ᑮᳳ̶܄ ҁ2҂ڠୌԧӞӻአԭᬌ݇فහጱկ,ᧆկӾӞᤈ੪ฎӞԀਠෆጱեեಅᵱ ᥝጱහഝ҅ྲইғIᧆᤈ݇හጱᒫӞӻ݇හԅಗᤈጱ֢҅ᒫԫӻ݇හԅय़ੜ҅ᒫ ӣӻ݇හԅٖਂࣈ̶࣎ྯེሾ᮷ᧆկӾڊݐӞᤈፗکկٖጱහഝق᮱ݐਠ ླ̶ ҁ3҂ڠୌԧӷӻਡਧԎAUTOMANUAL҅ݢզࣁಋۖᬌ݇فහկಢ॒ቘᬌ݇ف හԏᳵᅎၚڔഘ̶
case 'p': printcoremap(); break;
case 'q': exit(0); break;
default: break;
} } while ((command=='m'||command=='f'||command=='p'||command=='q')||printf(" եᬌفᲙѺ᧗᯿ෛᬌ\فn")); #endif
/* ᤒጱਧԎ */ struct map {
unsigned m_size; char *m_addr; }; struct map coremap[N];
//կᬌڊ᪠ஆ
static struct map *loopBp = coremapݻ୮ڹᑮᳳ܄ጱӥӞᑮᳳྯֵ҅܄ӻᑮᳳ܄ጱ ᦢᳯ᷇ሲፘᒵ
4̵զӥԅᑕଧრᎱ
//
// main.c // MemoryManage // // Created by מ౮ on 16/3/13. // Copyright © 2016ଙ מ౮. All rights reserved. // /* ইӧտֵአկᬌف/ᬌ҅ڊԞӧտֵአI/Oݻ؉ᬌفᬌڊᕮຎկ҅
{
/* ఘ٭3 */
bp->m_addr -= size;
bp->m_size += size;
loopBp = bp;
loopBp->m_addr = bp->m_a) {
loopBp = bp; loopBp->m_addr = a; do {
t = bp->m_addr; bp->m_addr = a; a = t; tt = bp->m_size; bp->m_size = size; bp++;
do {
bp++; (bp-1)->m_addr = bp->m_addr; } while((bp-1)->m_size = bp->m_size);
loopBp = bp; if((loopBp+1)->m_size != 0) {
++loopBp; } else {
loopBp = coremap; } return(a); } } return(0); }
3̵݇හ᧔ก
#define AUTO ᛔۖ݇හᬌف໒ୗ
//#define MANUAL #define N 5
//ಋۖ݇හᬌفཛྷୗ //ᑮᳳ܄ᳩଶ
#define INPUT_FILE_PATH "/Users/LXC/Desktop/InPutFile.txt" //կᬌف᪠ஆ
#define OUTPUT_FILE_PATH "/Users/LXC/Desktop/OutPutFile.txt"
printf("ᭌೠե:%c\n",command); fprintf(output, "ᭌೠե:%c\n",command); switch (command) {
case 'm': printf("ᬌړفᯈٖਂጱय़ੜ:%d\n",size);
fprintf(output, "ᬌړفᯈٖਂጱय़ੜ:%d\n",size); lmalloc(size); break; case 'f': printf("ᬌف᯽නٖਂጱय़ੜ:%d\n",size); fprintf(output, "ᬌړفᯈٖਂጱय़ੜ:%d\n",size); printf("ᬌف᯽නٖਂጱࣈ࣎:%d\n",addr); fprintf(output, "ᬌف᯽නٖਂጱࣈ࣎:%d\n",addr); lfree(size, memory+addr); break; case 'p': printcoremap(output); break; case 'q': fclose(input); fclose(output); exit(0); break; default: break; } } while (fscanf(input, "%c,%d,%d\n",&command, &size, &addr)!=EOF); #endif }
1̵᷌ፓ
ᖫٟӞӻCᑕଧ҅አchar *malloc(unsigned size)ڍහݻᔮᕹኩ᧗Ӟེٖਂᑮᳵҁই size=1000֖҅ܔԅਁᜓ҂҅አḒེᭇଫဩ
addr = (char *)fmalloc(unsigned size) ffree(unsigned size,char * addr)ҁचᥝ҂
case 'f': printf("ᬌف᯽නٖਂጱࣈ࣎:"); scanf("%d",&addr); while ((c=getchar())!='\n'&&c!=EOF ); printf("ᬌف᯽නٖਂጱय़ੜ:"); scanf("%d",&size); while ((c=getchar())!='\n'&&c!=EOF ); lfree(size, memory+addr); break;