CS:APP3e 深入理解计算机系统_3e MallocLab实验

详细的题目要求和资源可以到 http://csapp.cs.cmu.edu/3e/labs.html 或者 http://www.cs.cmu.edu/~./213/schedule.html 获取。

在这个实验中我们需要实现自己的动态内存申请器（malloc、free、realloc）

前期准备：

完全阅读书本第9章

man 3 realloc

注意事项：

1.先从小的测试文件开始，例如short1-bal.rep

2.为了调试方便，在Makefile中将CFLAGS更改为：

CFLAGS = -Wall -O2 -m32 -ggdb

这样用GDB调试的时候就能看到源码了

3.地址要对8字节对齐。

4.注意

realloc

的实现要和libc一致。

5.本实验环境WORD=4=sizeof(void *)，DWORD=8（gcc -m32)

思路要点及其实现：

对于速度（thru）而言，我们需要关注malloc、free、realloc每次操作的复杂度。对于内存利用率（util）而言，我们需要关注internal fragmentation （块内损失）和 external fragmentation （块是分散不连续的，无法整体利用），即我们free和malloc的时候要注意整体大块利用（例如合并free块、realloc的时候判断下一个块是否空闲）。

我这里实现的是书上9.9.13和9.9.14提到的Explicit Free Lists + Segregated Free Lists + Segregated Fits ，详细的介绍参考书上写的。

块的结构如下，其中低三位由于内存对齐的原因总会是0，A代表最低位为1，即该块已经allocated：



堆的起始和结束结构如下：



Free list的结构如下，每条链上的块按大小由小到大排列，这样我们用“first hit”策略搜索链表的时候就能获得“best hit”的性能，例如第一条链，A是B的successor，B是A的predecessor，A的大小小于等于B；不同链以块大小区分，依次为{1}{2}{3~4}{5~8}...{1025~2048}... ：



更新：这里的箭头应该是双向的，画错了。

下面是各个模块的实现，部分代码改编自CS:APP3e官网的Code examples 的mm.c（完整代码），如需使用请联系Randy Bryant and Dave O'Hallaron 。这次注释用中文写的，就不另外解释了。

常数及指针运算的宏定义

/* 向上进行对齐 */
#define ALIGNMENT 8
#define ALIGN(size) ((((size) + (ALIGNMENT-1)) / (ALIGNMENT)) * (ALIGNMENT))

#define WSIZE     4
#define DSIZE     8

/* 每次扩展堆的块大小（系统调用“费时费力”，一次扩展一大块，然后逐渐利用这一大块） */
#define INITCHUNKSIZE (1<<6)
#define CHUNKSIZE (1<<12)

#define LISTMAX     16

#define MAX(x, y) ((x) > (y) ? (x) : (y))
#define MIN(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 SET_PTR(p, ptr) (*(unsigned int *)(p) = (unsigned int)(ptr))

#define GET_SIZE(p)  (GET(p) & ~0x7)
#define GET_ALLOC(p) (GET(p) & 0x1)

#define HDRP(ptr) ((char *)(ptr) - WSIZE)
#define FTRP(ptr) ((char *)(ptr) + GET_SIZE(HDRP(ptr)) - DSIZE)

#define NEXT_BLKP(ptr) ((char *)(ptr) + GET_SIZE((char *)(ptr) - WSIZE))
#define PREV_BLKP(ptr) ((char *)(ptr) - GET_SIZE((char *)(ptr) - DSIZE))

#define PRED_PTR(ptr) ((char *)(ptr))
#define SUCC_PTR(ptr) ((char *)(ptr) + WSIZE)

#define PRED(ptr) (*(char **)(ptr))
#define SUCC(ptr) (*(char **)(SUCC_PTR(ptr)))

全局变量

/* 分离空闲表 */
void *segregated_free_lists[LISTMAX];
/* 实验信息 */
team_t team = {"1603002","Qiuhao Li","liqiuhao727@outlook.com","",""};

Helper functions

/* 扩展推 */
static void *extend_heap(size_t size);
/* 合并相邻的Free block */
static void *coalesce(void *ptr);
/* 在prt所指向的free block块中allocate size大小的块，如果剩下的空间大于2*DWSIZE，则将其分离后放入Free list */
static void *place(void *ptr, size_t size);
/* 将ptr所指向的free block插入到分离空闲表中 */
static void insert_node(void *ptr, size_t size);
/* 将ptr所指向的块从分离空闲表中删除 */
static void delete_node(void *ptr);

Helper functions: extend_heap

static void *extend_heap(size_t size)
{
void *ptr;
/* 内存对齐 */
size = ALIGN(size);
/* 系统调用“sbrk”扩展堆 */
if ((ptr = mem_sbrk(size)) == (void *)-1)
return NULL;

/* 设置刚刚扩展的free块的头和尾 */
PUT(HDRP(ptr), PACK(size, 0));
PUT(FTRP(ptr), PACK(size, 0));
/* 注意这个块是堆的结尾，所以还要设置一下结尾 */
PUT(HDRP(NEXT_BLKP(ptr)), PACK(0, 1));
/* 设置好后将其插入到分离空闲表中 */
insert_node(ptr, size);
/* 另外这个free块的前面也可能是一个free块，可能需要合并 */
return coalesce(ptr);
}

Helper functions: insert_node

static void insert_node(void *ptr, size_t size)
{
int listnumber = 0;
void *search_ptr = NULL;
void *insert_ptr = NULL;

/* 通过块的大小找到对应的链 */
while ((listnumber < LISTMAX - 1) && (size > 1))
{
size >>= 1;
listnumber++;
}

/* 找到对应的链后，在该链中继续寻找对应的插入位置，以此保持链中块由小到大的特性 */
search_ptr = segregated_free_lists[listnumber];
while ((search_ptr != NULL) && (size > GET_SIZE(HDRP(search_ptr))))
{
insert_ptr = search_ptr;
search_ptr = PRED(search_ptr);
}

/* 循环后有四种情况 */
if (search_ptr != NULL)
{
/* 1. ->xx->insert->xx 在中间插入*/
if (insert_ptr != NULL)
{
SET_PTR(PRED_PTR(ptr), search_ptr);
SET_PTR(SUCC_PTR(search_ptr), ptr);
SET_PTR(SUCC_PTR(ptr), insert_ptr);
SET_PTR(PRED_PTR(insert_ptr), ptr);
}
/* 2. [listnumber]->insert->xx 在开头插入，而且后面有之前的free块*/
else
{
SET_PTR(PRED_PTR(ptr), search_ptr);
SET_PTR(SUCC_PTR(search_ptr), ptr);
SET_PTR(SUCC_PTR(ptr), NULL);
segregated_free_lists[listnumber] = ptr;
}
}
else
{
if (insert_ptr != NULL)
{ /* 3. ->xxxx->insert 在结尾插入*/
SET_PTR(PRED_PTR(ptr), NULL);
SET_PTR(SUCC_PTR(ptr), insert_ptr);
SET_PTR(PRED_PTR(insert_ptr), ptr);
}
else
{ /* 4. [listnumber]->insert 该链为空，这是第一次插入 */
SET_PTR(PRED_PTR(ptr), NULL);
SET_PTR(SUCC_PTR(ptr), NULL);
segregated_free_lists[listnumber] = ptr;
}
}
}

Helper functions: delete_node

static void delete_node(void *ptr)
{
int listnumber = 0;
size_t size = GET_SIZE(HDRP(ptr));

/* 通过块的大小找到对应的链 */
while ((listnumber < LISTMAX - 1) && (size > 1))
{
size >>= 1;
listnumber++;
}

/* 根据这个块的情况分四种可能性 */
if (PRED(ptr) != NULL)
{
/* 1. xxx-> ptr -> xxx */
if (SUCC(ptr) != NULL)
{
SET_PTR(SUCC_PTR(PRED(ptr)), SUCC(ptr));
SET_PTR(PRED_PTR(SUCC(ptr)), PRED(ptr));
}
/* 2. [listnumber] -> ptr -> xxx */
else
{
SET_PTR(SUCC_PTR(PRED(ptr)), NULL);
segregated_free_lists[listnumber] = PRED(ptr);
}
}
else
{
/* 3. [listnumber] -> xxx -> ptr */
if (SUCC(ptr) != NULL)
{
SET_PTR(PRED_PTR(SUCC(ptr)), NULL);
}
/* 4. [listnumber] -> ptr */
else
{
segregated_free_lists[listnumber] = NULL;
}
}
}

Helper functions: coalesce

static void *coalesce(void *ptr)
{
_Bool is_prev_alloc = GET_ALLOC(HDRP(PREV_BLKP(ptr)));
_Bool is_next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(ptr)));
size_t size = GET_SIZE(HDRP(ptr));
/* 根据ptr所指向块前后相邻块的情况，可以分为四种可能性 */
/* 另外注意到由于我们的合并和申请策略，不可能出现两个相邻的free块 */
/* 1.前后均为allocated块，不做合并，直接返回 */
if (is_prev_alloc && is_next_alloc)
{
return ptr;
}
/* 2.前面的块是allocated，但是后面的块是free的，这时将两个free块合并 */
else if (is_prev_alloc && !is_next_alloc)
{
delete_node(ptr);
delete_node(NEXT_BLKP(ptr));
size += GET_SIZE(HDRP(NEXT_BLKP(ptr)));
PUT(HDRP(ptr), PACK(size, 0));
PUT(FTRP(ptr), PACK(size, 0));
}
/* 3.后面的块是allocated，但是前面的块是free的，这时将两个free块合并 */
else if (!is_prev_alloc && is_next_alloc)
{
delete_node(ptr);
delete_node(PREV_BLKP(ptr));
size += GET_SIZE(HDRP(PREV_BLKP(ptr)));
PUT(FTRP(ptr), PACK(size, 0));
PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0));
ptr = PREV_BLKP(ptr);
}
/* 4.前后两个块都是free块，这时将三个块同时合并 */
else
{
delete_node(ptr);
delete_node(PREV_BLKP(ptr));
delete_node(NEXT_BLKP(ptr));
size += GET_SIZE(HDRP(PREV_BLKP(ptr))) + GET_SIZE(HDRP(NEXT_BLKP(ptr)));
PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0));
PUT(FTRP(NEXT_BLKP(ptr)), PACK(size, 0));
ptr = PREV_BLKP(ptr);
}

/* 将合并好的free块加入到空闲链接表中 */
insert_node(ptr, size);

return ptr;
}

Helper functions: place

static void *place(void *ptr, size_t size)
{
size_t ptr_size = GET_SIZE(HDRP(ptr));
/* allocate size大小的空间后剩余的大小 */
size_t remainder = ptr_size - size;

delete_node(ptr);

/* 如果剩余的大小小于最小块，则不分离原块 */
if (remainder < DSIZE * 2)
{
PUT(HDRP(ptr), PACK(ptr_size, 1));
PUT(FTRP(ptr), PACK(ptr_size, 1));
}

/* 否则分离原块，但这里要注意这样一种情况（在binary-bal.rep和binary2-bal.rep有体现）：
*  如果每次allocate的块大小按照小、大、小、大的连续顺序来的话，我们的free块将会被“拆”成以下这种结构：
*  其中s代表小的块，B代表大的块

s      B      s       B     s      B      s     B
+--+----------+--+----------+-+-----------+-+---------+
|  |          |  |          | |           | |         |
|  |          |  |          | |           | |         |
|  |          |  |          | |           | |         |
+--+----------+--+----------+-+-----------+-+---------+

*  这样看起来没什么问题，但是如果程序后来free的时候不是按照”小、大、小、大“的顺序来释放的话就会出现“external fragmentation”
*  例如当程序将大的块全部释放了，但小的块依旧是allocated：

s             s             s             s
+--+----------+--+----------+-+-----------+-+---------+
|  |          |  |          | |           | |         |
|  |   Free   |  |   Free   | |   Free    | |   Free  |
|  |          |  |          | |           | |         |
+--+----------+--+----------+-+-----------+-+---------+

*  这样即使我们有很多free的大块可以使用，但是由于他们不是连续的，我们不能将它们合并，如果下一次来了一个大小为B+1的allocate请求
*  我们就还需要重新去找一块Free块
*  与此相反，如果我们根据allocate块的大小将小的块放在连续的地方，将达到开放在连续的地方：

s  s  s  s  s  s      B            B           B
+--+--+--+--+--+--+----------+------------+-----------+
|  |  |  |  |  |  |          |            |           |
|  |  |  |  |  |  |          |            |           |
|  |  |  |  |  |  |          |            |           |
+--+--+--+--+--+--+----------+------------+-----------+

*  这样即使程序连续释放s或者B，我们也能够合并free块，不会产生external fragmentation
*  这里“大小”相对判断是根据binary-bal.rep和binary2-bal.rep这两个文件设置的，我这里在96附近能够达到最优值
*
*/
else if (size >= 96)
{
PUT(HDRP(ptr), PACK(remainder, 0));
PUT(FTRP(ptr), PACK(remainder, 0));
PUT(HDRP(NEXT_BLKP(ptr)), PACK(size, 1));
PUT(FTRP(NEXT_BLKP(ptr)), PACK(size, 1));
insert_node(ptr, remainder);
return NEXT_BLKP(ptr);
}

else
{
PUT(HDRP(ptr), PACK(size, 1));
PUT(FTRP(ptr), PACK(size, 1));
PUT(HDRP(NEXT_BLKP(ptr)), PACK(remainder, 0));
PUT(FTRP(NEXT_BLKP(ptr)), PACK(remainder, 0));
insert_node(NEXT_BLKP(ptr), remainder);
}
return ptr;
}

初始化堆 mm_init：

int mm_init(void)
{
int listnumber;
char *heap;

/* 初始化分离空闲链表 */
for (listnumber = 0; listnumber < LISTMAX; listnumber++)
{
segregated_free_lists[listnumber] = NULL;
}

/* 初始化堆 */
if ((long)(heap = mem_sbrk(4 * WSIZE)) == -1)
return -1;

/* 这里的结构参见本文上面的“堆的起始和结束结构” */
PUT(heap, 0);
PUT(heap + (1 * WSIZE), PACK(DSIZE, 1));
PUT(heap + (2 * WSIZE), PACK(DSIZE, 1));
PUT(heap + (3 * WSIZE), PACK(0, 1));

/* 扩展堆 */
if (extend_heap(INITCHUNKSIZE) == NULL)
return -1;

return 0;
}

申请块：mm_malloc：

void *mm_malloc(size_t size)
{
if (size == 0)
return NULL;
/* 内存对齐 */
if (size <= DSIZE)
{
size = 2 * DSIZE;
}
else
{
size = ALIGN(size + DSIZE);
}

int listnumber = 0;
size_t searchsize = size;
void *ptr = NULL;

while (listnumber < LISTMAX)
{
/* 寻找对应链 */
if (((searchsize <= 1) && (segregated_free_lists[listnumber] != NULL)))
{
ptr = segregated_free_lists[listnumber];
/* 在该链寻找大小合适的free块 */
while ((ptr != NULL) && ((size > GET_SIZE(HDRP(ptr)))))
{
ptr = PRED(ptr);
}
/* 找到对应的free块 */
if (ptr != NULL)
break;
}

searchsize >>= 1;
listnumber++;
}

/* 没有找到合适的free块，扩展堆 */
if (ptr == NULL)
{
if ((ptr = extend_heap(MAX(size, CHUNKSIZE))) == NULL)
return NULL;
}

/* 在free块中allocate size大小的块 */
ptr = place(ptr, size);

return ptr;
}

释放块：mm_free：

void mm_free(void *ptr)
{
size_t size = GET_SIZE(HDRP(ptr));

PUT(HDRP(ptr), PACK(size, 0));
PUT(FTRP(ptr), PACK(size, 0));

/* 插入分离空闲链表 */
insert_node(ptr, size);
/* 注意合并 */
coalesce(ptr);
}

调整块：mm_realloc：

void *mm_realloc(void *ptr, size_t size)
{
void *new_block = ptr;
int remainder;

if (size == 0)
return NULL;

/* 内存对齐 */
if (size <= DSIZE)
{
size = 2 * DSIZE;
}
else
{
size = ALIGN(size + DSIZE);
}

/* 如果size小于原来块的大小，直接返回原来的块 */
if ((remainder = GET_SIZE(HDRP(ptr)) - size) >= 0)
{
return ptr;
}
/* 否则先检查地址连续下一个块是否为free块或者该块是堆的结束块，因为我们要尽可能利用相邻的free块，以此减小“external fragmentation” */
else if (!GET_ALLOC(HDRP(NEXT_BLKP(ptr))) || !GET_SIZE(HDRP(NEXT_BLKP(ptr))))
{
/* 即使加上后面连续地址上的free块空间也不够，需要扩展块 */
if ((remainder = GET_SIZE(HDRP(ptr)) + GET_SIZE(HDRP(NEXT_BLKP(ptr))) - size) < 0)
{
if (extend_heap(MAX(-remainder, CHUNKSIZE)) == NULL)
return NULL;
remainder += MAX(-remainder, CHUNKSIZE);
}

/* 删除刚刚利用的free块并设置新块的头尾 */
delete_node(NEXT_BLKP(ptr));
PUT(HDRP(ptr), PACK(size + remainder, 1));
PUT(FTRP(ptr), PACK(size + remainder, 1));
}
/* 没有可以利用的连续free块，而且size大于原来的块，这时只能申请新的不连续的free块、复制原块内容、释放原块 */
else
{
new_block = mm_malloc(size);
memcpy(new_block, ptr, GET_SIZE(HDRP(ptr)));
mm_free(ptr);
}

return new_block;
}

最终结果：