gh0s7/csapp2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

malloclab to finish

Browse Source
This commit is contained in:
CGH0S7
2025-05-26 19:19:19 +08:00
parent 4c3ef87f66
commit e861bfd45e
4 changed files with 261 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

279
malloclab/mm.c
View File

@@ -1,4 +1,5 @@
/*
#define MAX(x, y) ((x) > (y) ? (x) : (y))
/*
* mm-naive.c - 参考实现，是一个最快的、最低效率的malloc.
*
* 在这个参考实现中，分配一个块，仅仅是增加brk指针，
@@ -10,139 +11,227 @@
* 的话来说清楚。
* 请将此文件，重新命名为mm_201309060024.c（就是mm_你的学号.c）
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#ifndef _WIN32
#include <unistd.h>
#endif
#include <string.h>
#include "mm.h"
#include "memlib.h"
#include "mm.h"
/*********************************************************
* 亲们请注意：开始之前，请把下面的信息修改为你的个人信息
********************************************************/
/*********************************************************
* 亲们请注意：开始之前，请把下面的信息修改为你的个人信息
********************************************************/
team_t team = {
/* 团队名字 */
"Tom is a Cat",
/* 团队老大的名字 */
"Tom",
/* 团队老大的email地址 */
"Tom@sina.com",
/* 团队其他成员的名字 (如果没有，就空着) */
"",
/* 团队其他成员的email地址 (如果没有，就空着) */
""
};
/* 团队名字 */
"Tom is a Cat",
/* 团队老大的名字 */
"Tom",
/* 团队老大的email地址 */
"Tom@sina.com",
/* 团队其他成员的名字 (如果没有，就空着) */
"",
/* 团队其他成员的email地址 (如果没有，就空着) */
""};
/* 单字 (4) 还是双字 (8) 边界对齐 */
#define ALIGNMENT 8
/* 舍入到最近的ALIGNMENT边界上 */
#define ALIGN(size) (((size) + (ALIGNMENT-1)) & ~0x7)
#define ALIGN(size) (((size) + (ALIGNMENT - 1)) & ~0x7)
#define SIZE_T_SIZE (ALIGN(sizeof(size_t)))
// 定义块头部和尾部的大小
#define WSIZE 4 // 字大小（4字节）
#define DSIZE 8 // 双字大小（8字节）
#define CHUNKSIZE (1 << 12) // 扩展堆的默认大小（4KB）
// 将大小和分配位打包成一个字
#define PACK(size, alloc) ((size) | (alloc))
// 读取和写入地址p处的字
#define GET(p) (*(unsigned int *)(p))
#define PUT(p, val) (*(unsigned int *)(p) = (val))
// 从地址p读取大小和分配位
#define GET_SIZE(p) (GET(p) & ~0x7)
#define GET_ALLOC(p) (GET(p) & 0x1)
// 计算块的头部和尾部地址
#define HDRP(bp) ((char *)(bp) - WSIZE)
#define FTRP(bp) ((char *)(bp) + GET_SIZE(HDRP(bp)) - DSIZE)
// 计算下一个和前一个块的地址
#define NEXT_BLKP(bp) ((char *)(bp) + GET_SIZE(((char *)(bp) - WSIZE)))
#define PREV_BLKP(bp) ((char *)(bp) - GET_SIZE(((char *)(bp) - DSIZE)))
static char *heap_listp; // 指向堆的起始位置
static void *extend_heap(size_t words);
static void *coalesce(void *bp);
static void *find_fit(size_t asize);
static void place(void *bp, size_t asize);
static void print_block(int request_id, int payload);
/*
* mm_init - 初始化malloc系统，此函数，在整个运行期间，只被调用1次，用于建立初始化环境
* mm_init -
* 初始化malloc系统，此函数，在整个运行期间，只被调用1次，用于建立初始化环境
*/
int mm_init(void)
{
return 0;
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;
}
/*
* mm_malloc - 通过增加brk指针，来分配一块内存。
* 总是分配一块内存，它的大小是ALIGNMENT的整数倍（对齐）。
*/
void* mm_malloc(size_t size)
{
// 将大小调整到ALIGNMENT的整数倍（对齐）
int newsize = ALIGN(size + SIZE_T_SIZE);
static void *extend_heap(size_t words) {
char *bp;
size_t size;
// 修改brk指针
void* p = mem_sbrk(newsize);
if (p == (void*)-1)
{
printf("[%s]mm_alloc失败：size=%zu newsize=%d\n", __func__, size, newsize);
return NULL;
}
else {
*(size_t*)p = size;
return (void*)((char*)p + SIZE_T_SIZE);
}
// 分配偶数个字以保持对齐
size = (words % 2) ? (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);
}
/*
* mm_free - 释放一块内存。其实没干啥事....
*/
void mm_free(void* ptr)
{
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) { // Case 1
return bp;
} else if (prev_alloc && !next_alloc) { // Case 2
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
} else if (!prev_alloc && next_alloc) { // Case 3
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
PUT(FTRP(bp), PACK(size, 0));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
bp = PREV_BLKP(bp);
} else { // Case 4
size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(FTRP(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;
}
/*
* mm_realloc - 重新扩展一块已分配的内存。仅仅是使用mm_malloc和mm_free来实现，很蠢
*/
void* mm_realloc(void* ptr, size_t size)
{
void* oldptr = ptr;
void* newptr;
size_t copySize;
void *mm_malloc(size_t size) {
size_t asize; // 调整后的块大小
size_t extendsize; // 如果没有合适的块，扩展堆的大小
char *bp;
// 首先分配一块大一点的内存
newptr = mm_malloc(size);
if (newptr == NULL)
return NULL;
copySize = *(size_t*)((char*)oldptr - SIZE_T_SIZE);
if (size < copySize)
copySize = size;
if (size == 0)
return NULL;
// 把老内存里面的内容，复制到新内存里面
memcpy(newptr, oldptr, copySize);
if (size <= DSIZE)
asize = 2 * DSIZE;
else
asize = DSIZE * ((size + (DSIZE) + (DSIZE - 1)) / DSIZE);
// 释放掉老内存
mm_free(oldptr);
if ((bp = find_fit(asize)) != NULL) {
place(bp, asize);
return bp;
}
// 返回新内存的指针
return newptr;
extendsize = MAX(asize, CHUNKSIZE);
if ((bp = extend_heap(extendsize / WSIZE)) == NULL)
return NULL;
place(bp, asize);
return bp;
}
void mm_free(void *bp) {
if (bp == NULL)
return;
size_t size = GET_SIZE(HDRP(bp));
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
coalesce(bp);
}
void *mm_realloc(void *ptr, size_t size) {
if (ptr == NULL)
return mm_malloc(size);
if (size == 0) {
mm_free(ptr);
return NULL;
}
void *newptr = mm_malloc(size);
if (newptr == NULL)
return NULL;
size_t copySize = GET_SIZE(HDRP(ptr)) - DSIZE;
if (size < copySize)
copySize = size;
memcpy(newptr, ptr, copySize);
mm_free(ptr);
return newptr;
}
static void *find_fit(size_t asize) {
void *bp;
for (bp = heap_listp; GET_SIZE(HDRP(bp)) > 0; bp = NEXT_BLKP(bp)) {
if (!GET_ALLOC(HDRP(bp)) && (asize <= GET_SIZE(HDRP(bp)))) {
return bp;
}
}
return NULL;
}
static void place(void *bp, size_t asize) {
size_t csize = GET_SIZE(HDRP(bp));
if ((csize - asize) >= (2 * DSIZE)) {
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(csize - asize, 0));
PUT(FTRP(bp), PACK(csize - asize, 0));
} else {
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
}
}
/*
* mm_heapcheck - 目前暂不支持堆检查，可以不用修改
*/
void mm_heapcheck(void)
{
}
*/
void mm_heapcheck(void) {}
/*
* 输出一块数据 - 用于heapcheck，然而在此并没有什么用，可以不用修改
*/
static void print_block(int request_id, int payload)
{
printf("\n[%s]$BLOCK %d %d\n", __func__, request_id, payload);
static void print_block(int request_id, int payload) {
printf("\n[%s]$BLOCK %d %d\n", __func__, request_id, payload);
}