C语言实现简单内存分配器

最新推荐文章于 2024-04-30 09:55:29 发布
最新推荐文章于 2024-04-30 09:55:29 发布
阅读量958 收藏 7
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43344695/article/details/111405465
版权

为了理解虚拟内存分配规则，实现了简单的内存分配器。

该分配器基于隐式空闲链表实现，采用带边界标记的立即合并方式合并空闲块。

对于该空闲链表 ，头部包含一个字大小的占位块方便对齐，接下来包含两个字大小的头部与尾部作为链表头节点，包含一个设置大小为一个字，分配状态为已分配的块标记链表尾部。

每次分配空间首先扫描链表，寻找适配块，找到合适块则直接分配，否则申请最小一页的内存空间。

每次释放空间，将头尾分配标识位置零后，立即执行合并块操作，合并相邻空闲块空间。

mm.h 头文件及所需宏定义
#ifndef MM_ALLOCATOR
#define MM_ALLOCATOR
/*
*       基于隐式空闲链表,使用立即合并方式
*       栈最大容量为20G
*       每个内存块均包括头部与尾部，故最小块为一个双字大小
*		双字对齐
*       
*/
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <errno.h>
#include <signal.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
// 基本常数 和 宏
#define MAX_HEAP  1024 * 1024 * 20      //栈最大容量
#define WSIZE  4        //word size
#define DSIZE  8        //double word size
#define CHUNKSIZE  (1 << 12)    //初始空闲块大小 与 扩展堆默认大小

#define MAX(x,y) ((x) > (y) ?  (x) : (y))

#define PACK(size,alloc) ((size) | (alloc))     //包装块大小与分配状态,置于块头部或尾部

#define GET(p) (*(unsigned int *)(p))           //强转取址
#define PUT(p,val) (*(unsigned int *)(p) = (val))       //强转赋值

#define GET_SIZE(p) (GET(p) & ~0x7)     //用于头部尾部返回块大小
#define GET_ALLOC(p) (GET(p) & 0x1)     //返回分配状态

#define HDRP(bp) ((char *)(bp) - WSIZE) // bp为快指针指向第一位有效载荷字节 返回头部指针Header Pointer
#define FTRP(bp) ((char *)(bp) + GET_SIZE(HDRP(bp)) - DSIZE)    //返回尾部指针  Footer Pointer

#define NEXT_BLKP(bp) ((char *)(bp) + GET_SIZE(((char *)(bp) - WSIZE)))         //指向下一个块的块指针
#define PREV_BLKP(bp) ((char *)(bp) - GET_SIZE(((char *)(bp) - DSIZE)))         //指向前一个块的块指针


//外部接口
extern int mm_init(void);				//初始化所有内存块
extern void *mm_malloc(size_t size);	//分配块
extern void mm_free(void *ptr);	//释放块
extern void print_mem();		//打印所有块的地址，内存大小及分配状态
extern void mem_init(void);     //初始化操作堆栈
extern void *mem_sbrk(int incr);        //更改堆栈大小,但不允许收缩,简化实现sbrk()
#endif
mm.c 函数具体实现
#include "mm.h"

static char *mem_heap;  //堆栈栈底指针
static char *mem_brk;   //堆栈栈顶指针
static char *mem_max_addr;      //堆栈容量
//初始化堆栈
void mem_init(void)
{
        mem_heap = (char *)malloc(MAX_HEAP);
        mem_brk = (char *)mem_heap;
        mem_max_addr = (char *)(mem_heap + MAX_HEAP);

}
//栈扩容
void *mem_sbrk(int incr)
{
        char * old_brk = mem_brk;       //保存旧指针

        if(incr < 0 || (mem_brk + incr) > mem_max_addr){
                errno = ENOMEM;         //设置错误号
                fprintf(stderr,"ERROR : mem_sbrk faild.\n");;
                return (char *)-1;
        }

        mem_brk += incr;
        return (void *)old_brk;
}

//私有函数声明
static void *extend_heap(size_t);
static void *coalesce(void *bp);
static void *find_fit(size_t asize);
static void place(void *bp,size_t asize);
//extern end

static char *heap_listp;//指向序言块的指针
void print_mem()
{
        int cnt = 0;
        for(char* it = heap_listp;GET_SIZE(HDRP(it)) > 0;it = NEXT_BLKP(it)){
                printf("%d : addr %p size %d alloc %d\n",++cnt,it,GET_SIZE(HDRP(it)),GET_ALLOC(HDRP(it)));
        }
        printf("mem end\n");
//栈扩容
static void *extend_heap(size_t words)
{
        char *bp;
        size_t size;

        size = (words & 1) ? (words + 1) * WSIZE : words * WSIZE; //双字对齐
        if((long)(bp = mem_sbrk(size)) == -1) return NULL;

        PUT(HDRP(bp),PACK(size,0));
        PUT(FTRP(bp),PACK(size,0));
        PUT(HDRP(NEXT_BLKP(bp)),PACK(0,1));

        return coalesce(bp);

}

//初始化创建空闲列表
int mm_init(void)
{
        if((heap_listp = mem_sbrk(4 * WSIZE)) == (void *)-1)    //初始块分配失败
                return -1;
        PUT(heap_listp, 0);     //对齐填充块
        PUT(heap_listp + (1*WSIZE), PACK(DSIZE,1));     //序言块头部
        PUT(heap_listp + (2*WSIZE), PACK(DSIZE,1));     //序言块尾部

        PUT(heap_listp + (3*WSIZE), PACK(0,1));         //栈顶指针指向结尾快
        heap_listp += (2 * WSIZE);      //指向序言块
        if(extend_heap(CHUNKSIZE/WSIZE) == NULL) return -1;     //创建初始空闲块
        return 0;
}
//合并与当前块相邻的空闲块
static void *coalesce(void *bp)
{
        size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp)));     //上一个块的状态
        size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp)));     //下一个块的状态
        size_t size = GET_SIZE(HDRP(bp));       //当前块大小
        //四种情况下的合并方式
        if(prev_alloc && next_alloc){
                return bp;
        }
        else if(prev_alloc && !next_alloc){
                size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
                PUT(HDRP(bp),PACK(size,0));
                PUT(FTRP(NEXT_BLKP(bp)),PACK(size,0));
        }
        else if(!prev_alloc && next_alloc){

                size += GET_SIZE(HDRP(PREV_BLKP(bp)));
                PUT(HDRP(PREV_BLKP(bp)),PACK(size,0));
                PUT(FTRP(bp),PACK(size,0));
                bp = PREV_BLKP(bp);
        }
        else{
                size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(HDRP(NEXT_BLKP(bp)));
                PUT(HDRP(PREV_BLKP(bp)),PACK(size,0));
                PUT(FTRP(NEXT_BLKP(bp)),PACK(size,0));
                bp = PREV_BLKP(bp);
        }
        return bp;
}
//释放bp指向的块
void mm_free(void *bp)
{
        size_t size = GET_SIZE(HDRP(bp));
        PUT(HDRP(bp),PACK(size,0));//设置头部
        PUT(FTRP(bp),PACK(size,0));//设置尾部
        coalesce(bp);   //合并相邻块

}

void *mm_malloc(size_t size)
{
        size_t asize;
        size_t extendsize;
        char *bp;
        if(size == 0) return NULL;
        if(size <= DSIZE) asize = 2 * DSIZE;
        else asize = DSIZE * ((size + DSIZE + (DSIZE - 1)) / DSIZE);    //用需求大小+头尾大小 向上取整
        if((bp = find_fit(asize)) != NULL){
                place(bp,asize);
                return bp;
        }
        extendsize = MAX(CHUNKSIZE,asize);      //请求扩展内存大小
        if((bp = extend_heap(extendsize/WSIZE)) == NULL){
                return NULL;
        }
        place(bp,asize);
        return bp;
}
//首次适配法寻找合适块
static void *find_fit(size_t asize)
{
        char *bp = heap_listp;
        for(bp = heap_listp;GET_SIZE(HDRP(bp)) > 0;bp = NEXT_BLKP(bp)){
                if(!GET_ALLOC(HDRP(bp)) && GET_SIZE(HDRP(bp)) >= asize)
                        return bp;
        }
        return NULL;

}
//分配块
static void place(void *bp, size_t asize)
{
        size_t old_size = GET_SIZE(HDRP(bp));
        if(old_size - asize >= DSIZE){
                PUT(HDRP(bp),PACK(asize,1));
                PUT(FTRP(bp),PACK(asize,1));
                bp = NEXT_BLKP(bp);
                PUT(HDRP(bp),PACK(old_size - asize, 0));
                PUT(FTRP(bp),PACK(old_size - asize, 0));
        }
        else{ZZ

                PUT(HDRP(bp),PACK(old_size,1));
                PUT(FTRP(bp),PACK(old_size,1));
        }
}
main测试函数
#include "mm.h"

int main()
{
        mem_init();
        mm_init();
        char *p = (char *)mm_malloc((sizeof(char)) * 10);
        print_mem();
        if(p == NULL){
                fprintf(stderr,"mm_malloc error!\n");
                exit(1);
        }
        printf("addr of p:%p\n",p);
        mm_free(p);
        print_mem();
        printf("free ok\n");
        char *p1 = (char *)mm_malloc((sizeof(char)) * 20);
        print_mem();
        printf("addr of p1 :%p\n",p1);
        char *p2 = (char *)mm_malloc(sizeof(char) * 5000);
        print_mem();
        printf("addr of p2 :%p\n",p2);
        mm_free(p1);
        print_mem();
        mm_free(p2);
        print_mem();
        return 0;

}
运行结果
1 : addr 0x7f6115d44018 size 8 alloc 1
2 : addr 0x7f6115d44020 size 24 alloc 1
3 : addr 0x7f6115d44038 size 4072 alloc 0
mem end
addr of p:0x7f6115d44020
1 : addr 0x7f6115d44018 size 8 alloc 1
2 : addr 0x7f6115d44020 size 4096 alloc 0
mem end
free ok
1 : addr 0x7f6115d44018 size 8 alloc 1
2 : addr 0x7f6115d44020 size 32 alloc 1
3 : addr 0x7f6115d44040 size 4064 alloc 0
mem end
addr of p1 :0x7f6115d44020
1 : addr 0x7f6115d44018 size 8 alloc 1
2 : addr 0x7f6115d44020 size 32 alloc 1
3 : addr 0x7f6115d44040 size 5008 alloc 1
4 : addr 0x7f6115d453d0 size 4064 alloc 0
mem end
addr of p2 :0x7f6115d44040
1 : addr 0x7f6115d44018 size 8 alloc 1
2 : addr 0x7f6115d44020 size 32 alloc 0
3 : addr 0x7f6115d44040 size 5008 alloc 1
4 : addr 0x7f6115d453d0 size 4064 alloc 0
mem end
1 : addr 0x7f6115d44018 size 8 alloc 1
2 : addr 0x7f6115d44020 size 9104 alloc 0
mem end
灯又烬
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
malloc lab
肖恩123的博客
03-10 1628
实验参考资料
操作系统C语言模拟内存分配算法的模拟实现
m0_46270930的博客
11-17 3783
使用一个一维数组来模拟内存储空间，建立内存块来记录内存分配使用情况，通过随机产生进程及其所需要的内存来模拟真实的进程。通过给进程分配内存及回收来实现对动态不等长存储管理方法。 #include "math.h" //#include "stdafx.h" #include "stdio.h" #include "stdlib.h" typedef struct MEMORY_BLOCK { int name;//进程名称 int address;//地址空间 int length;
Linux链表内存分配器,动态内存分配(malloc/free)简单实现--隐式空闲链表
weixin_29530803的博客
05-01 514
本文使用隐式空闲链表实现简单的动态内存分配。动态内存分配器维护一个大块区域，也就是堆，处理动态的内存分配请求。分配器将堆视为一组不同大小的块的集合来维护，每个块要么是已分配的，要么是空闲的。实现动态内存分配要考虑以下问题：(1)空闲块组织：我们如何记录空闲块？(2)放置：我们如何选择一个合适的空闲块来放置一个新分配的块？(3)分割：在我们将一个新分配的块放置到某个空闲块之后，我们如何处理这个空闲块...
深入理解计算机系统----第九章虚拟内存
qq_40182703的博客
08-22 2151
原文链接 https://www.jianshu.com/p/e1b82b230917 虚拟存储器又叫做虚拟内存，我们现在的操作系统普遍都支持了虚拟内存，这样做是因为我们同时运行着太多的程序了，就目前我电脑的状态来看，我既要打开浏览器，又要听歌，可能同时还登陆的有QQ，如果不使用虚拟内存4G的内存空间很快就会被耗尽，而一旦没有了内存空间，其他程序就无法加载了。虚拟内存的出现就是为了解决这个问...
C语言与内存管理技术：内存池、 slab allocator、jemalloc等内存分配器实现（一）
weixin_56154577的博客
04-30 1170
C语言自问世以来，一直是系统编程领域的中流砥柱。它凭借其底层访问能力、高效执行以及广泛的操作系统支持，成为操作系统内核、驱动程序、高性能服务器及嵌入式系统开发的首选语言。在系统编程中，C语言的内存管理扮演着核心角色，它允许程序员直接控制内存的分配与释放，这是实现高性能和灵活性的关键。
如何用C语言实现一个简单的内存分配器
liuyanhong13的博客
10-02 1456
Memory Allocator 101-写一个简单的内存分配器 原文：https://arjunsreedharan.org/post/148675821737/memory-allocators-101-write-a-simple-memory 与本文相关的代码： github.com/arjun024/memalloc 可以访问译者的github ，阅读体验更佳... https://github.com/KatePang13/Note/blob/main/%E4%B8%80%E4%B...
C语言内存分配
光何
08-05 468
在任何程序设计环境及语言中，内存管理都十分重要。在目前的计算机系统或嵌入式系统中，内存资源仍然是有限的。因此在程序设计中，有效地管理内存资源是程序员首先考虑的问题。 第1节主要介绍内存管理基本概念，重点介绍C程序中内存的分配，以及C语言编译后的可执行程序的存储结构和运行结构，同时还介绍了堆空间和栈空间的用途及区别。 第2节主要介绍C语言中内存分配及释放函数、函数的功能，以及如何调用这些
内存分配简单的c语言
12-11
在这个问题中，我们讨论的是一个简单的C语言实现，它模拟了内存分配和释放的过程，特别是使用了`malloc()`和`free()`两个函数。这两个函数在C语言中是标准库函数，分别用于动态地分配和释放内存。 `malloc()`函数...
基于c语言实现的文本编辑器系统源码
最新发布
05-11
【基于C语言实现的文本编辑器系统源码】是一个适合初学者和进阶学习者的技术实践项目，尤其对于想要深入理解C语言以及操作系统层面文本处理的开发者来说，这是一个绝佳的学习资源。通过分析和实践这个项目，你可以...
内存分配器：自定义C ++内存分配器
02-11
内存分配器 自定义C ++内存分配器
zmalloc-c:内存分配器
05-02
内存分配器 这是C语言中的内存分配器。它使用来避免碎片。 公共接口包括标准的malloc ， calloc ， realloc和free 。 例子 # include < stdio> # include " ../src/zmalloc.h " // gcc -Wall -Wextra hello.c ../src/zmalloc.c // prints "hello world" to stdout int main () { char *world; world = zmalloc ( 6 * sizeof ( char )); world[ 0 ] = ' w ' ; world[ 1 ] = ' o ' ; world[ 2 ] = ' r ' ; world[ 3 ] = ' l ' ; world[ 4 ] = ' d ' ; world[ 5 ] =
操作系统内存分配算法模拟实现.pdf
05-17
在本文中，我们将深入探讨操作系统内存分配的基本原理和常见算法，并以一个简单的模拟实现为例，来理解内存分配与回收的过程。 一、内存分配算法 1. 首次适应算法（First Fit） 首次适应算法是最简单的内存分配...
C语言实现运算器的原理 完整编程代码.zip
06-18
7. **内存管理**：虽然在简单的运算器实现中可能不太明显，但在更复杂的程序中，了解如何动态分配和释放内存（使用`malloc`和`free`函数）是必要的，以防止内存泄漏。 8. **函数**：通过封装代码，我们可以创建函数...
linux简单内存分配器
12-20
本篇将深入探讨"linux简单内存分配器"，即一个基于malloc实现的简化版本。 首先，malloc的工作原理是通过操作系统提供的系统调用来请求内存。在Linux中，这个系统调用通常是brk或mmap。malloc接收一个参数，即所需...
内存分配器详解及Ｃ语言实现
李兆龙的博客
08-27 4472
引子 在有些特殊的情况下我们没有办法确定我们程序中要使用的数据大小　但我们又不想一次将数组这种数据结构开的过大　因为我们的内存毕竟是有限的　那该怎么办呢　没错　就是动态内存分配，Ｃ语言中是malloc 与 free Ｃ++中是new 与 delete ，我们还知道动态内存是在堆上分配的，而且是一条链表(怎么样的链表呢　我们后面会说)，底子更好的同学还知道malloc实际上就是调用了mmap函数与s...
C语言进阶—C语言高手之路视频教程
11-28
C语言高手之路，大量C语言干货让你分分钟从小白变大牛 ！ 本视频中包含的知识点：1、标准教程中很少出现，却非常重要的知识点。2、企业面试绝对会考察的知识点，面试轻松过关！3、基础知识升级、加深对C语言的理解。4、让你C语言功底与芸芸大众区分开来。黄强老师精心打磨、诚意之作，只为让你更轻松的学习！
C语言动态内存的分配（附详细代码例子）
weixin_59042805的博客
05-02 3049
文章目录前言一、malloc二、free函数三.calloc四.realloc总结 前言 在C语言中，我们开辟内存的方式有两种 1.静态开辟内存 2.动态开辟内存 静态例： int a[10] = {0} ; 我们这里定义的数组所开辟的内存是在栈区中开辟的，数组a指定为40个字节 ,这种分配固定大小的内存分配称为静态内存分配。 在很多时候，我们申请的空间是未知的 比如说通讯录，我们不知道需要存下多少个号码，这时候就存在一个问题，你定的空间需要多少个字节，当申请的太少，就会出现存不下去的情况，
C/C++通用内存分配器原理解析
xunye的博客
04-09 1333
C/C++分配器存在的问题 1、分配速度慢，通常用于为大型对象（数百个或数千个bytes）分配内存 2、存在一个管理内存的记忆池，常会耗用一部分内存资源，对于new分得得每一块内存，都会对其进行登记，而登记所需内存达4~32个bytes，对于分配小型对象，用于登记所需内存占比大，不适合用于分配小型对象的内存。 内存分配器的工作方式 内存分配器管理一个由raw bytes所组成的内存池，能够从池中分配任意大小的内存区块。 管理内存需要的簿记结构，内存控制块: struct MemControlBlock {
在Ubuntu 22.04.2环境下使用C语言，利用标准库的malloc和链表去模拟实现简单的内存分配器
06-01
好的，我会尽力回答你的问题。首先，我们需要了解一下内存分配的基本原理。在C语言中，内存分配通常使用malloc函数。它会在堆上分配一块指定大小的空间，并返回一个指针，指向这块空间的起始地址。 我们可以使用链表来实现一个简单的内存分配器。具体来说，我们可以将堆划分为多个固定大小的块，然后使用链表来管理这些块。 下面是一个简单的示例代码： ``` #include <stdio.h> #include <stdlib.h> // 定义一个内存块结构体 typedef struct block { int size; // 内存块大小 struct block* next; // 下一个内存块 } block_t; // 定义一个内存池结构体 typedef struct { block_t* head; // 内存块链表头 int block_size; // 内存块大小 int num_blocks; // 内存块数量 } mem_pool_t; // 初始化内存池 void mem_pool_init(mem_pool_t* pool, int block_size, int num_blocks) { int i; block_t *p, *q; // 分配内存池空间 pool->head = (block_t*)malloc(block_size * num_blocks); pool->block_size = block_size; pool->num_blocks = num_blocks; // 初始化内存块链表 p = pool->head; for (i = 0; i < num_blocks; i++) { p->size = block_size; q = p++; q->next = p; } q->next = NULL; } // 内存分配函数 void* mem_alloc(mem_pool_t* pool, int size) { block_t *p, *q; // 遍历内存块链表，寻找第一个大小足够的内存块 for (p = pool->head, q = NULL; p != NULL; q = p, p = p->next) { if (p->size >= size) { // 将找到的内存块从链表中移除 if (q == NULL) { pool->head = p->next; } else { q->next = p->next; } // 返回内存块指针 return (void*)p; } } // 没有找到合适的内存块 return NULL; } // 内存释放函数 void mem_free(mem_pool_t* pool, void* ptr) { block_t *p, *q; // 将被释放的内存块插入到内存块链表头部 p = (block_t*)ptr; for (q = pool->head; q != NULL && q < p; q = q->next) { if (q->next > p) { break; } } p->next = q->next; q->next = p; } // 测试代码 int main() { mem_pool_t pool; int i; void* ptr[10]; // 初始化内存池 mem_pool_init(&pool, sizeof(int), 10); // 分配内存块 for (i = 0; i < 10; i++) { ptr[i] = mem_alloc(&pool, sizeof(int)); *(int*)ptr[i] = i; } // 输出内存块内容 for (i = 0; i < 10; i++) { printf("%d ", *(int*)ptr[i]); } printf("\n"); // 释放内存块 for (i = 0; i < 10; i++) { mem_free(&pool, ptr[i]); } return 0; } ``` 在这个示例代码中，我们定义了一个内存块结构体，以及一个内存池结构体。内存池结构体包含一个内存块链表头，以及内存块大小和数量等信息。我们使用mem_pool_init函数来初始化内存池，使用mem_alloc函数来分配内存块，使用mem_free函数来释放内存块。在测试代码中，我们分配了10个int类型的内存块，并存储了它们的值，然后释放了这些内存块。 需要注意的是，这个示例代码只是一个简单的演示，实际的内存分配器需要考虑更多的因素，如内存对齐、内存碎片等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值