lab6 malloclab

已于 2023-08-06 10:03:20 修改
阅读量207 收藏 1
点赞数
分类专栏： CSAPP 文章标签： linux
于 2023-08-06 09:58:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/132128039
版权

在这里插入图片描述

前情提要

  1. 一定要把书中关于隐式空闲链表的实现代码好好看一下， 这个lab的代码和那个非常像

实验文档

  1. 只需要修改mm.c文件
  2. mdriver.c可以用来衡量性能
    1. make
    2. ./mdriver -V
  3. 需要完成的函数
    1. int mm_init(void)
      1. 最开始的时候调用
      2. 失败时返回-1，成功时返回0
    2. void *mm_malloc(size_t size)
      1. 返回堆上的一个地址
      2. 至少包含size字节
      3. 向8字节对齐
    3. void mm_free(void *ptr)
      1. 这个地址是通过malloc或者realloc分配的
      2. 这个地址还没有被free
    4. void *mm_realloc(void *ptr, size_t size)
      1. 如果ptr是null，则相当于调用malloc
      2. 如果size是0，相当于调用free
      3. 新的地址开始的内容需要和原来一样，但是大小由size决定
  4. 可以调用的函数
    1. void *mem sbrk(int incr)
      1. 为堆开辟内存空间
      2. 返回新开辟的内存的起始地址
    2. void *mem heap lo(void)：返回堆的起始位置
    3. void *mem heap hi(void)：返回堆的终止位置
    4. size t mem heapsize(void)返回堆的大小
    5. size t mem pagesize(void)返回内存页面的大小
  5. 测试
    1. ./mdriver -t traces/ -v

设计思路

  1. 模型选择书中的第603页的显示空闲链表
    1. 首部和尾部相同，记录 s i z e ∣ a l l o c size | alloc size∣alloc
    2. 首部后面紧跟着两个指针，分别是pre和next，这两个指针指向前后的空闲块。（其实我这里有个疑惑，按理说我们操作的地址都是64位的，怎么可以用一块表示一个地址，一块明明才32位）
  2. 空闲链表的管理采用书中9.9.14节介绍的方法
    1. 将空闲块按大小划分为16类，分别是大小为 1 , 2 − 3 , 4 − 7 , 8 − 15 1,2-3,4-7,8-15 1,2−3,4−7,8−15等等，最后一块记录的是 2 15 − 无穷 2^{15}-无穷 215−无穷。每一类都维护一个链表，链表从小到大地记录着当前存在且位于这一类大小范围内的空闲块的bp指针。
    2. 查找的方法类似于二分查找，找到大于等于当前块的类，然后从这个类开始找，如果找不到合适的块，就往下一类找。如果实在找不到，就要去扩展堆的大小了

mm_init

int mm_init(void)
这个函数是用来初始化我们的堆，

  1. 初始化空闲块数组
  2. 初始化原始的堆
    1. 申请4个块（16个字节），和书中的隐式链表一样
    2. 分别为这4个块设置size和alloc
  3. 申请扩展堆
    1. （构建初始的空闲块）
    2. 这里使用一个函数实现，因为后续还会使用到扩展堆这个操作
      具体实现如下：
int mm_init(void) {
  // 初始化记录空闲块的数组
  for (int i = 0; i < LIST_MAX_SIZE; i++) {
    segregated_free_lists[i] = NULL;
  }
  // 先请求空间来初始化堆的结构
  void *heap_listp;
  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));
  // 为堆申请一个chunksize的虚存空间
  if (extend_heap(CHUNKSIZE) == NULL) {
    return -1;
  }
  return 0;
}

extend_heap

static void *extend_heap(size_t size)
这个函数用来给堆扩展size大小的空间，要完成的功能如下所示

  1. 首先调整size：
    1. #define ALIGN(size) (((size) + (ALIGNMENT - 1)) & ~0x7)
    2. 这个宏就是实现了将size往最近的8的倍数舍入
  2. 使用mem_sbrk申请size大小的空闲块
  3. 设置新得到的空闲块的的首部和尾部，以及重新设置堆的尾部
    1. 新申请的空闲块的前一个4字节的小块就是之前堆的尾部，即长度为0，分配为为1的那个哥们。现在直接修改这个哥们，使其成为新申请的块的首部。
  4. 将这个空闲块给放到空闲链表中去
  5. 尝试合并这个空闲块，因为原来堆的后面可能就是空闲的内存块
    具体实现如下所示：
static void *extend_heap(size_t size) {
  // word_count必须是偶数
  size = ALIGN(size);
  // 使用mem_sbrk去申请空间
  void *bp;
  if ((bp = mem_sbrk(size)) == (void *)-1) {
    return NULL;
  }
  // 将新申请的内存加到已有的堆上去
  // 现在有个指针bp，它指向的新申请的内存的真正的起始位置
  // 正常来说，这个bp的前一块就是之前堆的结尾块，是没用的，现在直接拿来做新申请的块的首部
  // 然后又将新申请的块的最后一块变成堆的尾部
  PUT(HDRP(bp), PACK(size, 0));
  PUT(FTRP(bp), PACK(size, 0));
  PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1));
  // 将这个新的空闲块插入到我们的列表里
  insert_node(bp, size);
  return coalesce(bp);
}

insert_node

static void insert_node(void *ptr, size_t size)
这个函数是将以ptr为bp指针的空闲块给塞到空闲块数组中去，bp指针指的是当前空闲块的有效载荷的第一个字节的地址，也就是头部+WSIZE

  1. 首先找到这个size应该对应数组的哪个下标。（数组的每个下标存储的链表）
  2. 拿到这个下标对应的链表，根据size找到应该插入到这个链表的哪个位置（链表是从小大递增的）
  3. 分情况插入
    1. 当前链表为空
    2. 在首部插入
    3. 在尾部插入
    4. 在链表中间插入
      这里具体的实现上就用了一些书上没有的宏定义，有点晦涩，所以解释一下。
  4. SET_PTR
    1. #define SET_PTR(p, ptr) (*(unsigned int *)(p) = (unsigned int)(ptr))
    2. 将地址p看做指向一个无符号int型整数，即一个32位数的地址，然后将地址ptr看做是一个32位数，即将地址ptr放到地址p指向的位置。
    3. 那么以后*(unsigned int *)(p)就可以得到ptr。
    4. 这个操作是用来存储这个空闲块的pre和next指针用的。p要么是pre指针所在的地址，要么是next指针所在的地址。然后*(unsigned int *)(p)就可以得到pre指针或者next指针
  5. GET_PRE_PTR
    1. #define GET_PRE_PTR(ptr) ((void *)(ptr))
    2. 这个宏传入一个ptr，这个ptr往往就是一个空闲块的bp指针。通过这个宏，可以得到这个空闲块存储pre指针的位置。
    3. 其实这一波操作之后返回的就是ptr自己，因为说过了，调用这个宏时，ptr往往传入的就是bp，而bp恰好就是空闲块中指向pre指针的指针。
    4. 之所以要做这种脱裤子放屁的事情，一个是为了使用起来更加清晰没有歧义，另一方面是为了和GET_SUCC_PTR的使用统一起来
    5. #define GET_SUCC_PTR(ptr) ((void *)(ptr) + WSIZE)就获得了指向next指针的指针
  6. GET_PRE
    1. #define GET_PRE(ptr) (*(void **)(GET_PRE_PTR(ptr)))
    2. 这个宏传入一个ptr，这个ptr其实往往就是某个空闲块的bp指针，然后返回这个空闲块存储的pre指针。
    3. 注意了GET_PRE_PTR实际上是指向pre指针的指针，但是呢，因为我们前面的定义中返回的void*，因此，我们需要先将它强制转为void**类型，即指向指针的指针。然后再通过*操作取出来pre空闲块真正的地址。
    4. #define GET_SUCC(ptr) (*(void **)(GET_SUCC_PTR(ptr)))就是取得真正的succ指针
      这玩意是有点恶心的，对照着下面的代码看，应该就明白了
static void insert_node(void *ptr, size_t size) {
  // 首先找到这个size应该在哪个格子里
  int pos = find_pos(size);
  // 扫描这个格子里存的链表，找到应该插入的位置
  void *pre_ptr = NULL;
  void *cur_ptr = segregated_free_lists[pos];
  while (cur_ptr != NULL && size > GET_SIZE(HDRP(cur_ptr))) {
    pre_ptr = cur_ptr;
    cur_ptr = GET_SUCC(cur_ptr);
  }
  // 分情况讨论，正常来说，我们应该插入pre_ptr和cur_ptr之间
  // 前驱比自己小，后续比自己大
  // 如果pre_ptr为空
  if (pre_ptr == NULL) {
    // 如果cur_ptr也为空，说明这个链表就是空的，直接插入即可
    if (cur_ptr == NULL) {
      segregated_free_lists[pos] = ptr;
      SET_PTR(GET_PRE_PTR(ptr), NULL);
      SET_PTR(GET_SUCC_PTR(ptr), NULL);
    } else {
      // cur_ptr不为空，说明要插入的是第一个位置
      segregated_free_lists[pos] = ptr;
      SET_PTR(GET_PRE_PTR(cur_ptr), ptr);
      SET_PTR(GET_SUCC_PTR(ptr), cur_ptr);
      SET_PTR(GET_PRE_PTR(ptr), NULL);
    }
    // pre_ptr不为空
  } else {
    // 如果cur_ptr为空，说明是在链表尾部插入
    if (cur_ptr == NULL) {
      SET_PTR(GET_SUCC_PTR(pre_ptr), ptr);
      SET_PTR(GET_PRE_PTR(ptr), pre_ptr);
      SET_PTR(GET_SUCC_PTR(ptr), NULL);
    } else {
      // 如果cur_ptr不为空，说明是在链表中间插入
      SET_PTR(GET_SUCC_PTR(pre_ptr), ptr);
      SET_PTR(GET_PRE_PTR(ptr), pre_ptr);
      SET_PTR(GET_SUCC_PTR(ptr), cur_ptr);
      SET_PTR(GET_PRE_PTR(cur_ptr), ptr);
    }
  }
}

coalesce

static void *coalesce(void *bp)

  1. 这个函数的作用是将bp指向的空闲块和前后的空闲块合并，但是前后的空闲块也不一定存在，所以要分类讨论
  2. 这个函数返回合并之后的空闲块的起始地址，这个起始地址只会在前面存在空闲块的情况下返回前面空闲块的起始地址，否则就是返回当前的bp
    具体实现思路
  3. 首先分别获取前面和后面的内存块是否被分配（地址意义上的前后内存块，而不是空闲内存块那个意义上的）
  4. 分类讨论，该合并合并，如果需要合并
    1. 先将参与合并的空闲内存块在空闲内存数组中给删了
    2. 然后设置合并之后的空闲内存块的首部和尾部
    3. 最后给它加入到空闲内存数组中去
static void *coalesce(void *bp) {
  // 首先获取前后内存块的状态
  int is_pre_alloc = GET_ALLOC(HDRP(PREV_BLKP(bp)));
  int pre_size = GET_SIZE(HDRP(PREV_BLKP(bp)));
  int is_next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp)));
  int next_size = GET_SIZE(HDRP(NEXT_BLKP(bp)));
  int cur_size = GET_SIZE(HDRP(bp));
  // 根据状态分类讨论
  int new_size;
  // 前后均分配了
  if (is_pre_alloc && is_next_alloc) {
    return bp;
  } else if (is_pre_alloc && !is_next_alloc) {
    // 前面分配了，后面没分配，所以和后面合并
    // 首先，在空闲块数组中删除这两个块
    delete_node(bp);
    delete_node(NEXT_BLKP(bp));
    // 然后修改首部和尾部
    new_size = cur_size + next_size;
  } else if (!is_pre_alloc && is_next_alloc) {
    delete_node(bp);
    delete_node(PREV_BLKP(bp));
    new_size = pre_size + cur_size;
    // 修改当前的bp，因为和前面合并了，现在的bp应该指向前面的块的头部
    bp = PREV_BLKP(bp);
  } else {
    // 前后都是空的
    delete_node(bp);
    delete_node(PREV_BLKP(bp));
    delete_node(NEXT_BLKP(bp));
    new_size = pre_size + cur_size + next_size;
    bp = PREV_BLKP(bp);
  }
  // 修改当前合并后的空闲块的首部和尾部
  PUT(HDRP(bp), PACK(new_size, 0));
  // 只要设置好了头部，那么尾部就可以直接操作
  PUT(FTRP(bp), PACK(new_size, 0));
  // 将这个空闲块插入空闲块数组
  insert_node(bp, new_size);
  return bp;
}

mm_malloc

void *mm_malloc(size_t size)

  1. 这个函数是分配一个size大小的内存块，并返回这个内存块的bp指针
    实现思路
  2. 首先要特判size不合法的情况，小于等于0
  3. 然后要调整size
    1. 如果size不足最小块的要求，将size变为最小快的长度。最小快应该是2*DSIZE
    2. 如果size不为8的倍数，修改为8个倍数。之所以要修改为8个倍数，是为了对齐的要求。对齐是为了取内存数据的时候，一次可以成功取出来，避免出现一个数据存在于两个cache行的情况
  4. 根据size去空闲内存数组中去找是否有合适的内存块。可能size对应的那个链表中找不到，那就去索引更大的链表中找
  5. 如果实在找不到，那就要申请扩展堆
  6. 最后修改找到的空闲块（这一步通过place操作完成）
void *mm_malloc(size_t size) {
  // 首先调整size为合法值，最小为2*DSIZE，否则一定要是8的倍数
  if (size == 0) {
    return NULL;
  } else if (size <= DSIZE) {
    size = 2 * DSIZE;
  } else {
    size = ALIGN(size + DSIZE);
  }
  // 根据size去空闲块数组里找最合适的那个
  int pos = find_pos(size);
  void *fit_ptr = NULL;
  while (pos < LIST_MAX_SIZE) {
    // 去当前项里面找
    void *cur_ptr = segregated_free_lists[pos];
    while (cur_ptr != NULL) {
      if (GET_SIZE(HDRP(cur_ptr)) < size) {
        cur_ptr = GET_SUCC(cur_ptr);
      } else {
        fit_ptr = cur_ptr;
        break;
      }
    }
    if (fit_ptr != NULL) {
      break;
    }
    pos++;
  }
  // 如果没有足够大的，说明堆要扩充空间了
  if (fit_ptr == NULL) {
    if ((fit_ptr = extend_heap(MAX(size, CHUNKSIZE))) == NULL) {
      return NULL;
    }
  }
  // 在该空闲块中分配size大小的块
  fit_ptr = place(fit_ptr, size);
  return fit_ptr;
}

place

static void *place(void *bp, size_t size)

  1. 这个函数是将bp所指向的内存块分配size大小的内存走，即留下原大小减去size大小的内存块
  2. 这里用了一个很神奇的优化方法。不是一直把这个空闲块的前size个字节给分配掉，而是根据size的大小讨论，如果比较小就分配前size个字节，如果比较大就分配后size个字节。之所以这样优化，是为了避免一些极端情况下出现很多外部内存碎片
  3. 分配的操作的实现其实是通过设置首部和尾部实现的，分别设置前部和后部的首尾部，就完成了分配的操作，然后将新生成的小空闲内存块给加入到空闲内存数组中去
    实现思路
  4. 如果剩下的空闲块不足一个最小空闲块，那就直接全部分配
  5. 如果size比较大，分配后size个字节，这个比较大是一个经验值，选一个效果比较好就行了
  6. 如果size比较小，分配前size个字节
static void *place(void *bp, size_t size) {
  // 在bp中分配size大小的空闲块走
  // 先在数组中删除bp空闲块
  delete_node(bp);
  // 获得bp块的长度
  size_t free_size = GET_SIZE(HDRP(bp));
  // 如果剩下的小于2*DSIZE，那就不用再插入回去了
  if (free_size - size < 2 * DSIZE) {
    PUT(HDRP(bp), PACK(free_size, 1));
    PUT(FTRP(bp), PACK(free_size, 1));
  } else if (size >= 96) {
    PUT(HDRP(bp), PACK(free_size - size, 0));
    PUT(FTRP(bp), PACK(free_size - size, 0));
    insert_node(bp, free_size - size);
    bp = NEXT_BLKP(bp);
    PUT(HDRP(bp), PACK(size, 1));
    PUT(FTRP(bp), PACK(size, 1));
  } else {
    // 注意，这里是把前半部分给分配了，不能修改bp，最后还是要返回bp
    // 前半部分要分配，后半部分重新插入
    PUT(HDRP(bp), PACK(size, 1));
    PUT(FTRP(bp), PACK(size, 1));
    // 修改bp指向后半段
    PUT(HDRP(NEXT_BLKP(bp)), PACK(free_size - size, 0));
    PUT(FTRP(NEXT_BLKP(bp)), PACK(free_size - size, 0));
    // 重新放入空闲块数组
    insert_node(NEXT_BLKP(bp), free_size - size);
  }
  return bp;
}

free

void mm_free(void *ptr)

  1. 这个函数是将ptr指向的空闲内存块给free掉
    实现思路
  2. 首先设置首尾部，将其alloc的状态改为0
  3. 然后加入空闲块链表
  4. 最后尝试空闲块的合并
    其实到这里就可以发现，设置一个块就只需要修改首部和尾部，空闲块再丢入空闲块数组并尝试合并即可
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)

  1. 这个函数是将ptr指向的块给扩展为size大小
  2. 这里有个优化的思路就是能不copy就尽量不copy，因为如果要copy那就会引起复制以及free当前块。所以最好能和后面的内存块合并。
    实现思路
  3. 首先需要处理size非法的情况
    1. 为0啊
    2. 不足最小块的大小的要求啊
    3. 向8对齐啊
  4. 如果size小于当前空闲块大小，则直接忽略
  5. 如果这个块是堆的尾部，那么可以试着去扩展堆，这样可以减少copy的操作，但是这个优化可有可无吧只能说
  6. 如果这个块后面是一个空闲块，可以将这个空闲块并入当前块，看看是否可以满足要求，如果可以的话就合并，然后返回答案
  7. 如果上面都不行，那就只能重新malloc然后memcpy，再free掉当前内存块了
    写博客的时候才发现我下面的实现有几个问题
  8. 扩展堆尾部以及和后面的块合并的时候，如果成功了，那是不是给这个块扩的太多了？超过了它需要的size的要求
  9. 我依稀记得实验文档好像要求可以实现缩小，即size是可以小于当前空闲块大小的，但是我这里是直接忽略了
  10. 上面两个问题好像不对导致结果错误，但是会牺牲空间，并且第2点会带来一点安全隐患，因为我并没有真正的缩小块，用户依然可以访问。只能希望用户在realloc之后，就按他想要的size来操作这个内存块了。
  11. 但是太懒了，不想实现了。
    代码实现
void *mm_realloc(void *ptr, size_t size) {
  // 首先检查size的合法性
  if (size == 0) {
    return NULL;
  }
  // 修改size使其对齐
  if (size <= DSIZE) {
    size = 2 * DSIZE;
  } else {
    size = ALIGN(size + DSIZE);
  }
  // 计算当前块的大小与要求的size的差值
  int cur_size = GET_SIZE(HDRP(ptr));
  int change_size = cur_size - size;
  // 如果size小于等于当前长度，则不需要重新分配
  if (change_size >= 0) {
    return ptr;
  }
  // 如果当前块后面就是结尾
  if (GET_SIZE(HDRP(NEXT_BLKP(ptr))) == 0) {
    // 扩展
    if (extend_heap(MAX(change_size, CHUNKSIZE)) == NULL) {
      return NULL;
    }
    // 扩展成功，修改头尾部
    delete_node(NEXT_BLKP(ptr));
    PUT(HDRP(ptr), PACK(cur_size + MAX(change_size, CHUNKSIZE), 1));
    PUT(FTRP(ptr), PACK(cur_size + MAX(change_size, CHUNKSIZE), 1));
    return ptr;
  }
  // 如果当前块后面有个free块，尝试去合并，看看是不是可以
  if (!GET_ALLOC(HDRP(NEXT_BLKP(ptr)))) {
    // 如果加起来长度够的话
    int next_size = GET_SIZE(HDRP(NEXT_BLKP(ptr)));
    if (cur_size + next_size >= size) {
      delete_node(NEXT_BLKP(ptr));
      PUT(HDRP(ptr), PACK(cur_size + next_size, 1));
      PUT(FTRP(ptr), PACK(cur_size + next_size, 1));
      return ptr;
    }
  }
  // 最后一步了，只能去重新申请
  void *new_ptr = mm_malloc(size);
  memcpy(new_ptr, ptr, cur_size);
  mm_free(ptr);
  return new_ptr;
}

出现的错误

  1. 死循环：忘记给pos++
  2. 段错误：place的时候，没有正确返回bp指针
  3. 不知名错误：在realocate的时候，在尾部重新申请位置的情况下，忘记把新申请的从空闲块里删除了
是小肖啊！
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CSAPP-----malloc lab
qq_41983709的博客
10-15 2826
我跟着深入理解计算机系统，自己实现了一遍malloc这个实验，书中要求自己实现一个动态内存分配器，malloc，free，realloc; 我只是简单的把malloc实现了，realloc并没有仔细的去做; 最终实验结果将根据空间利用率和吞吐量进行判断; 书中介绍了几种动态内存管理分配的策略： 隐式空闲链表，书中将一个每次分配的块，设置成有固定大小的4字节头节点和4字节尾节点，然后根据每个...
malloclab_malloclab_malloclab_c_
10-02
ics课程第九章实现动态内存分配，最后得了86分，实在不想改了
CSAPP Malloc lab
最新发布
weixin_43876597的博客
03-10 1152
是一个 C 语言中的语句，它的含义是将一个指针类型的值设置为-1，然后将其转换为void指针类型，并返回。这通常用于表示一个特殊的错误条件或者指示函数执行失败。sizeof函数的单位是byte。ALIGN 找到最小的alignment的倍数。
CSAPP malloclab实验
张嘉睿的博客
02-01 3111
书本配套实验地址 构造一个分配器是一件富有挑战的任务。设计空间很大，有多种块格式、空闲链表格式，以及放置、分割和合并策略可供选择。另一个挑战就是我们经常被迫在类型系统的安全和熟悉的限定之外编程，依赖于容易出错的指针强制类型转换和指针运算，这些操作都属于典型的低层系统编程。 一、理解动态内存分配器是个什么东西？ 其实动态内存分配器就是我们平时在C语言上用的malloc和free,realloc，通过分配堆上的内存给程序，我们通过向堆申请一块连续的内存，然后将堆中连续的内存按malloc所需要的块来分配，不够了
CSAPP Lab5- MallocLab
青衫客36的博客
05-28 1410
本实验需要用c语言实现一个动态的存储分配器，也就是你自己版本的malloc，free，realloc函数。
CMU15-213 (CS: APP) ：malloclab实验记录
2301_77482503的博客
02-18 1268
本文是对CMU15-213课程的第七个实验—malloclab的个人实验记录以及心得分享
Lab7 Malloc Lab
weixin_47089544的博客
04-14 5857
CSAPP Lab7 Malloc Lab，详细地介绍了三种解决方案，由浅入深，隐式空闲链表、显式空闲链表、分离适配链表，最高得分88。
Malloc动态内存分配
TranSad的博客
08-10 710
在C语言中我们会使用malloc来动态地分配内存，这样做的一个主要理由是有些数据结构的大小只有在运行时才能确定。例如，如果你正在编写一个程序，需要用户输入一些数据，但你不知道用户会输入多少数据，那么你就需要使用动态内存分配。而是一种用于动态内存分配的数据结构，当程序员使用malloc或其他动态内存分配函数请求内存时，这些函数会从堆中分配内存。：应用程序会分配和释放空间。例如，在C语言中，我们使用malloc来分配内存，然后在不再需要的时候使用free来释放内存。这种分配器需要程序员明确地管理内存。
CSAPP(CMU 15-213)：Lab6 Malloclab详解
qq_42241839的博客
03-23 9196
# 前言 本系列文章意在记录答主学习CSAPP Lab的过程，也旨在可以帮助后人一二，欢迎大家指正！ tips:本lab主要是为了体验应用程序如何使用和管理虚拟内存，写一个动态存储分配器（dynamic storage allocator） 目标：使用不同方法在内存利用率(memory utilization)和吞吐率（throughput）之中达到trade-off，逐步优化。 Handout 要求 修改mm.c文件，其中包括四个函数： int mm_init(void); 初始化堆空间，错误返回
计算机系统Malloc lab实验笔记
z_J03的博客
01-02 438
首先下载trace，然后去config.h更改文件路径。（官方文件包里不包含这个，但我不知道去哪下载，因为老师给的包里有）到这里我已经解决了头文件缺失的问题，但出现了链接报错。运行失败就按报错找解决方案，这次是缺少<system/codes.h>头文件。代码是借鉴的别人的文章，但是看太多了忘记到底是哪篇了，这次没办法贴链接。执行完这两条，虚拟机没抽风就会得到未更改的mm运行结果。只改路径部分，改为存放trace的位置。不行再安装gcc-multilib包。到这里这次就运行成功了。安装libc-dev。
CSAPP Lab6 Malloc Lab 完整Traces（包含amptjp-bal.rep）.zip
10-23
由于CSAPP:3e Malloc Lab的Traces不完整 所以这个是完整版的Traces 里面包含了amptjp-bal.rep等等10个完整Traces 希望对你有所帮助 免费下载嗷 希望CSDN别给我设定积分下载了
csapp lab6 malloc lab 96pt
08-05
csapp lab6 malloc lab 完成方法 显示空闲链表 pt96
ics malloc lab
01-12
ics的malloc lab，完全通过测试，优化程度很高，performance分数高。
ICS mallocLab 满分
03-02
CMU的malloclab，用的是二叉树，当然较小的块用链表组织。
CSAPP-Lab6：MallocLab
qq_39308644的博客
06-24 531
CSAPP-Lab6：MallocLab
malloc lab
肖恩123的博客
03-10 1610
实验参考资料
CSAPP Malloc Lab
jokerMingge的博客
02-04 956
在这个实验室中，您将为C程序编写一个动态存储分配器，即您自己版本的、和例程，实现一个正确，高效和快速的分配器。本实验性能指标有两个方面，内存利用率和吞吐量，这两个方面都是动态存储分配器优秀与否的重要衡量指标，我们的分配器需要在吞吐量和内存利用率直接取得平衡以获取更高的分数。若从官网中下载的实验文件，缺少测试文件，可从这里下载。本实验的代码中使用了大量的宏和指针，需要特别小心。此外，为方便调试程序以及便利地对比各个版本的差异，使用了宏进行条件编译。完成实验的方法有多种，下面主要根据书中介绍的分配器进行编码。隐
<csapp> malloc lab （《深入理解计算机系统》lab6） (附lab4\lab5下载地址)
Stone
08-05 7435
一直很懒，好久没更了，jiu
csapp实验malloclab
01-20
malloclab是CSAPP(Computer Systems: A Programmer's Perspective)教材中的一个实验项目，旨在帮助学生了解内存管理和动态内存分配的细节。 实验的主要任务是实现一个简单的动态内存分配器。这个内存分配器需要提供malloc、free和realloc函数的功能，来动态管理内存。实验中提供了一个基本的代码框架，学生需要在这个框架上完成具体的实现。 整个实验可以分为三个部分：分配器的初始化、分配和释放内存的处理。 在初始化部分，学生需要定义一个初始的堆，为其分配一块内存，并根据实验要求设置好堆的初始状态。 在分配内存的部分，学生需要实现malloc函数。这个函数接收一个参数（需要分配的字节数）并返回指向分配内存的指针。学生需要根据实验要求分配内存，并保证分配的内存块满足对齐和避免碎片化的要求。 在释放内存的部分，学生需要实现free函数。这个函数接收一个参数（指向待释放内存块的指针）并将该内存块标记为可用。学生需要根据实验要求处理不同的情况，比如释放合并相邻的空闲块。 此外，实验还有一些额外的要求，如实现realloc函数，处理内存使用情况的统计等。 通过完成malloclab实验，学生可以深入了解内存管理和动态内存分配的工作原理。这个实验还提供了一个实践机会，让学生亲自动手实现一个简单的内存分配器，从而更好地理解和掌握相关的概念和技术。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值