实现一个malloc内存分配器

实现一个malloc内存分配器是一项复杂的任务，要求对底层操作系统的内存管理策略有深入的了解以及对数据结构的准确使用。malloc是用于动态内存分配的一个函数，其在C标准库中定义。简化的malloc实现涉及到请求、分配、管理和释放内存块。在一个更高级的实现中，还需要考虑内存对齐和碎片整理等因素。以下是实现一个基本malloc内存分配器的基本步骤和概念：

步骤 1: 确定内存分配策略

首先需要选择一个内存分配策略。常见的策略有“最先适配”、“最佳适配”和“最差适配”。这一策略将影响分配器如何从可用内存块列表中选择内存块来满足分配请求。

步骤 2: 初始内存请求

一个malloc分配器通常从操作系统请求一大块内存，以满足后续的分配请求。在Unix-like操作系统中，可以使用 brk或 mmap系统调用来请求内存。

步骤 3: 管理可用内存块列表

你需要实现一种机制来跟踪哪些内存块是组织和维护，通常可以通过内存中的链表来管理。每个内存块在物理内存上都有一个header，用于存储该块的大小和是否已经被分配的状态。

步骤 4: 分配内存块

当malloc被调用时，分配器遍历内存块链表，根据所选择的策略找到合适的内存块。如果找到的内存块比请求的大小大很多，那么它可以被分割成两部分：一部分满足当前请求，剩下的部分仍然保留在可用内存块链表中。

步骤 5: 释放内存块

当free函数被调用时，分配器将该内存块标记为未分配，并尝试与相邻的未分配块合并，以减少内存碎片。

步骤 6: 处理内存不足

当malloc无法找到足够的空间来满足一个请求时，它应该再次请求操作系统获得更多内存，或者返回null指针。

步骤 7: 碎片整理

随着时间推移，内存分配和释放可能会导致内存碎片化。实现一个有效率的内存分配器可能需要包括某种形式的碎片整理策略来优化内存使用。

示例代码

下面给出了一个非常基础的内存分配器示例实现：

#include <stddef.h>
#include <unistd.h>

typedef char ALIGN[16]; // 内存对齐
union header {          // 块的头信息
  struct {
    size_t size;
    unsigned is_free;
    union header *next;
  } s;
  ALIGN stub;
};

typedef union header header_t;

header_t *head, *tail;

header_t *get_free_block(size_t size) {
  header_t *curr = head;
  while(curr) {
    // 找到足够大的未分配块
    if (curr->s.is_free && curr->s.size >= size) {
      return curr;
    }
    curr = curr->s.next;
  }
  return NULL;
}

void *malloc(size_t size) {
  // 大小为0，返回NULL
  if (!size) {
    return NULL;
  }
  header_t *header;
  if ((header = get_free_block(size))) { // 查看是否有足够大小的可用块
    header->s.is_free = 0; // 标记为已分配
    return (void*)(header + 1); // 返回内存块
  }

  // 没有找到合适的块，向OS请求更多内存
  size_t total_size = size + sizeof(header_t);
  void *block = sbrk(total_size);
  if (block == (void*) -1) {
    return NULL; // sbrk失败
  }
  header = block;
  header->s.size = size;
  header->s.is_free = 0;

  // 更新全局列表
  if (!head) {
    head = header;
  }
  if (tail) {
    tail->s.next = header;
  }
  tail = header;
  return (void*)(header + 1);
}

void free(void *block) {
  if (!block) {
    return;
  }
  header_t *header, *tmp;
  void *programbreak;

  header = (header_t*)block - 1;
  programbreak = sbrk(0);

  // 检查是否可以实际释放内存
  if ((char*)block + header->s.size == programbreak) {
    if (head == tail) {
      head = tail = NULL;
    } else {
      tmp = head;
      while (tmp) {
        if(tmp->s.next == tail) {
          tmp->s.next = NULL;
          tail = tmp;
        }
        tmp = tmp->s.next;
      }
    }
    sbrk(0 - sizeof(header_t) - header->s.size);
    return;
  }
  header->s.is_free = 1; // 标记为未分配
}

在实现中，有几个关键点需要注意：

1. 我们维护了一个全局链表来跟踪内存块，每个内存块的头部存储它的大小、分配状态以及下一个内存块的指针。
2. 通过 sbrk进行内存请求的增量调整。
3. 我们提供了自定义的 malloc和 free实现，将内存块标记为已分配或未分配，并且必要时合并相邻的未分配块。