Lab7 Malloc Lab

STRUGGLE_399

已于 2022-04-18 19:58:52 修改

阅读量7.4k

点赞数 42

分类专栏： CSAPP 文章标签： c++ linux

于 2022-04-14 23:04:01 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_47089544/article/details/124184251

版权

Lab7 Malloc Lab

写在前言：这个实验的来源是CSAPP官网：CSAPP Labs ，如果感兴趣的话，可以点击这个链接🔗去下载。实验中的10个traces文件是没有附加的，可以点击这个🔗：traces file 自行下载。

实验说明

Malloc Lab实验要求我们实现一个动态内存分配器（Dynamic Memory Allocator），要求我们实现与标准C库中的malloc、free、realloc 具有相同功能的函数，可以自行定义块的空间结构。

唯一需要修改的文件是mm.c，里面声明了以下四个函数：

int mm_init(void);
void *mm_malloc(size_t size);
void mm_free(void *ptr);
void *mm_realloc(void *ptr, size_t size);

mm_init：在调用其它三个函数之前，mdriver会先调用 mm_init 进行必要的初始化，比如分配初始堆区，如果初始化不成功，返回-1，否则返回0。
mm_malloc：返回已分配块的有效载荷payload的起始地址，其中，payload的大小至少为size字节，除此之外，必须保证已分配块在堆区里面，并且不会与其它已分配块重叠。
mm_free：释放被ptr指向的已分配块（调用mm_malloc、mm_realloc得到的ptr），如果已经被释放，Nothing to do。
mm_realloc：返回一个已分配的块，其有效载荷payload的大小至少为size字节，并且有如下的限制：
- 如果ptr 为 NULL，那么等价于调用mm_alloc(size)；
- 如果size等于0，那么的等价于调用mm_free(ptr)；
- 否则，mm_realloc必须重新分配payload至少为size字节的块，并且保证新的块的内容和旧的块一致，值得注意的是，这个新块的地址有可能和旧块的地址相同，或者不同，取决于我们的实现方式。

性能评价指标

对于给定的n个分配和释放请求的某种顺序
$R_0,R_1,\cdots,R_k\cdots,R_{n-1}$
如果一个应用程序请求一个p字节的块，那么得到的已分配块的有效载荷（payload）就是p字节，在请求 $R_k$ 完成后，聚集有效载荷（aggregate payload）表示为 $P_k$ ，为当前已分配块的有效载荷之和， $H_k$ 表示为堆当前的大小（单调非递减）。

那么前k+1请求的 峰值利用率，表示为 $U_k=\frac{\max_{i\le k}P_i}{H_k}$ ，越接近1表示空间利用率越高。

其次，吞吐率，表示单位时间内完成的请求个数，比如，如果分配器1秒内完成了500个分配请求和500个释放请求，那么它的吞吐率就是每秒1000次操作。

总的来说，分配器的目标就是在整个序列中使得峰值利用率 $U_{n-1}$ 最大化，并且峰值利用率和吞吐率是互相牵制的，找到一个合适的折中就显得很重要。

mdriver会记录空间利用率和吞吐率，与标准C库的吞吐率进行比较，最终评价指标为：
$P=wU+(1-w)\min(1,\frac{T}{T_{libc}})$
其中， $w = 0.6$ ，这意味着空间利用率的占比更高。

使用隐式空闲链表

第一种实现方式就是书本上给出的简单分配器实现，使用的块结构为未优化的带边界标记的堆块形式。

但是CSAPP书本上没有给出realloc的实现方式，这需要我们自行实现。

在这里插入图片描述

这里的隐式空闲链表的结构包括序言快、若干个普通块（已分配/空闲）、以及一个结尾块，值得注意的是，添加序言块和结尾块实现是比较方便的，比如，在合并操作时，不需要进行边界的处理，结尾块是一个大小为0的已分配块，它标记着堆的结束位置。

首先是，操作链表的基本常数和宏定义：

/* Base constants and macros */
#define WSIZE		4		/* Word and header/footer size (bytes) */
#define DSIZE		8		/* Double word size (bytes) */
#define CHUNKSIZE	(1<<12)	/* Extend heap by this amount (bytes) */

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

/* Pack a size and allocated bit into a word*/
#define PACK(size, alloc)	((size) | (alloc))

/* Read and write a word at address p */
#define GET(p)		(*(unsigned int *)(p))
#define PUT(p, val)	(*(unsigned int *)(p) = val)

/* Read the size and allocated fields from address p */
#define GET_SIZE(p)		(GET(p) & ~0x7)
#define GET_ALLOC(p)	(GET(p) & 0x1)

/* Given block ptr bp, compute address of its header and footer */
#define HDRP(bp)	((char* )(bp) - WSIZE)
#define FTRP(bp)	((char* )(bp) + GET_SIZE(HDRP(bp)) - DSIZE)

/* Given block ptr bp, compute address of next and previous blocks */
#define NEXT_BLKP(bp)	((char *)(bp) + GET_SIZE(((char *)(bp) - WSIZE)))
#define PREV_BLKP(bp)	((char *)(bp) - GET_SIZE(((char *)(bp) - DSIZE)))

/* Heap prologue block pointer*/
static void *heap_listp;

创建初始空闲链表(init)

mm_init函数创建一个初始的堆，分配序言块和尾块，并且将其扩展，创建一个大小为4096字节的初始堆区。

/* 
 * mm_init - initialize the malloc package.
 */
int mm_init(void)
{
   
    /* Create the initial empty heap */
    if ((heap_listp = mem_sbrk(4*WSIZE)) == (void *)-1)
    	return -1;
    
    PUT(heap_listp, 0);								/* Alignment padding */
    PUT(heap_listp + (1*WSIZE), PACK(DSIZE, 1));	/* Prologue header */
    PUT(heap_listp + (2*WSIZE), PACK(DSIZE, 1));	/* Prologue footer */
    PUT(heap_listp + (3*WSIZE), PACK(0, 1));		/* Epilogue header */
    heap_listp += (2*WSIZE);
    
    /* Extend the empty heap with a free block of CHUNKSIZE bytes */
    if (extend_heap(CHUNKSIZE/WSIZE) == NULL) {
   
    	return -1;
   	}

    return 0;
}

/* extend_heap -- Extend heap */
static void *extend_heap(size_t words)
{
   
	char *bp;
	size_t size;
	
	/* Allocate an even number of words to maintain alignment */
	size = (words % 2) ? (words+1) * WSIZE : words * WSIZE;
	if ((long)(bp = mem_sbrk(size)) == -1)
		return NULL;
	
	/* Initialize free block header/footer and the epilogue header */
	PUT(HDRP(bp), PACK(size, 0));			/* Free block header */
	PUT(FTRP(bp), PACK(size, 0));			/* Free block footer */
	PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1));	/* New epilogue header */
	
	/* Coalesce if the previous block was free */
	return coalesce(bp);
}

释放和合并块(free)

mm_free释放一个块就是简单地把它的头部和尾部块设置为空闲即可，大小为这个块的大小，并且进行空闲块合并的操作。

/*
 * mm_free - Freeing a block and coalesce free block if can .
 */
void mm_free(void *ptr)
{
   
	size_t size = GET_SIZE(HDRP(ptr));
	
	PUT(HDRP(ptr), PACK(size, 0));
	PUT(FTRP(ptr), PACK(size, 0));
	coalesce(ptr);
}

/* coalesce -- Coalesce free block */
static void *coalesce(void *ptr)
{
   
	size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(ptr)));
	size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(ptr)));
	size_t size = GET_SIZE(HDRP(ptr));
	
	if (prev_alloc && next_alloc) {
   				/* Case 1 */
		return ptr;
	} else if (prev_alloc && !next_alloc) {
   		/* Case 2 */
		size += GET_SIZE(HDRP(NEXT_BLKP