32、深入解析内存管理：从严格别名到高级调试

深入解析内存管理：从严格别名到高级调试

1. 严格别名规则

在C和C++编程中，严格别名规则是一个常被忽视却至关重要的概念。简单来说，严格别名规则要求对象只能通过其实际类型、该实际类型的限定版本（如 const 或 volatile ）、有符号或无符号版本、包含该实际类型成员的结构体或联合体，或者 char 指针来访问。

例如，通过两个 uint16_t 指针访问一个 uint32_t 变量的常见模式就违反了严格别名规则。当你对指针进行类型转换并解引用时，很可能就违反了这一规则。如果你曾看到过 gcc 发出的警告“dereferencing type-punned pointer will break strict-aliasing rules”，那就说明你已经违反了该规则。

严格别名规则在C++中早已存在，而在C语言里，直到C99才将其标准化。 gcc 会强制执行严格别名规则，这样做有助于生成更优化的代码。具体规则可参考ISO C99标准的6.5节。

2. 数据段管理

Unix系统历来提供了直接管理数据段的接口，不过大多数程序并不直接使用这些接口，因为 malloc() 等分配方案更易用且功能更强大。下面为大家介绍这些接口：

#include <unistd.h>
int brk (void *end);
void * sbrk (intptr_t increment);

这些函数的命名源于早期的Unix系统，当时堆和栈位于同一内存段。堆中的动态内存分配从段的底部向上增长，而栈则从段的顶部向下朝堆增长，两者的分界线被称为“break”或“断点”。在现代系统中，数据段有自己独立的内存映射，我们仍将映射的结束地址称为断点。

• brk() 函数：将数据段的断点（即数据段的结束地址）设置为 end 指定的地址。调用成功时返回0，失败时返回 -1，并将 errno 设置为 ENOMEM 。
• sbrk() 函数：将数据段的结束地址增加 increment 字节， increment 可以是正的或负的。该函数返回更新后的断点。当 increment 为0时，可获取当前的断点，示例代码如下：

printf ("The current break point is %p\n", sbrk (0));

需要注意的是，POSIX和C标准都未对这两个函数进行定义，但几乎所有的Unix系统都支持其中一个或两个。为保证程序的可移植性，建议使用基于标准的接口。

3. 匿名内存映射

glibc 中的内存分配结合了数据段和内存映射。实现 malloc() 的经典方法是将数据段划分为一系列2的幂次方大小的分区，然后返回最接近请求大小的分区来满足分配需求。释放内存只需将分区标记为“空闲”即可。如果相邻的分区都空闲，它们可以合并成一个更大的分区。若堆的顶部完全空闲，系统可以使用 brk() 降低断点，缩小堆并将内存返回给内核。

这种算法被称为伙伴内存分配方案，它的优点是速度快且简单，但会引入两种类型的碎片化问题：
- 内部碎片化 ：当为满足分配需求而使用的内存超过请求大小时，就会发生内部碎片化，这会导致可用内存的使用效率低下。
- 外部碎片化 ：当有足够的空闲内存可以满足请求，但这些内存被分割成两个或更多不相邻的块时，就会出现外部碎片化。这可能导致内存使用效率低下（因为可能会使用一个更大但不太合适的块），或者内存分配失败（如果没有其他可选块）。

此外，这种方案还可能导致一个内存分配“锁定”另一个，阻止传统的C库将释放的内存返回给内核。例如，分配了两个内存块A和B，块A位于断点处，块B位于A的下方。即使程序释放了B，C库也无法调整断点，直到A也被释放。

为避免这些问题，对于大内存分配， glibc 不使用堆，而是创建匿名内存映射来满足分配请求。匿名内存映射类似于基于文件的映射，但它不依赖于任何文件，因此被称为“匿名”。它是一个大的、初始化为零的内存块，可直接使用，就像是为单个分配专门创建的全新堆。由于这些映射位于堆之外，不会导致数据段的碎片化。

3.1 匿名内存映射的优缺点

• 优点 ：
  • 无碎片化问题：当程序不再需要匿名内存映射时，只需取消映射，内存就会立即返回给系统。
  • 可调整性：匿名内存映射可调整大小、权限，还能像普通映射一样接收建议。
  • 独立分配：每个分配都存在于单独的内存映射中，无需管理全局堆。
• 缺点 ：
  • 空间浪费：每个内存映射的大小必须是系统页面大小的整数倍，因此非页面大小整数倍的分配会导致“松弛”空间的浪费。对于小分配，这种浪费相对分配大小更为明显。
  • 开销较大：创建新的内存映射比从堆中分配内存的开销更大，尤其是对于小分配，这种开销的影响更为显著。

综合考虑这些优缺点， glibc 的 malloc() 函数使用数据段来满足小分配，使用匿名内存映射来满足大分配。目前的阈值是128 KB，即小于或等于128 KB的分配来自堆，而更大的分配来自匿名内存映射。不过，这个阈值是可配置的。

3.2 创建匿名内存映射

在Linux系统中，创建匿名内存映射非常简单。可以使用 mmap() 系统调用创建内存映射，使用 munmap() 系统调用销毁映射：

#include <sys/mman.h>
void * mmap (void *start,
             size_t length,
             int prot,
             int flags,
             int fd,
             off_t offset);
int munmap (void *start, size_t length);

创建匿名内存映射比创建基于文件的映射更容易，因为无需打开和管理文件，主要区别在于需要设置一个特殊标志来表示映射是匿名的。以下是一个创建512 KB匿名内存映射的示例：

void *p;
p = mmap (NULL,                        /* do not care where */
          512 * 1024,                  /* 512 KB */
          PROT_READ | PROT_WRITE,      /* read/write */
          MAP_ANONYMOUS | MAP_PRIVATE, /* anonymous, private */
          -1,                          /* fd (ignored) */
          0);                          /* offset (ignored) */
if (p == MAP_FAILED)
        perror ("mmap");
else
        /* 'p' points at 512 KB of anonymous memory... */

对于大多数匿名映射， mmap() 的参数与上述示例类似，通常只需根据需要调整分配的大小。其他参数的一般设置如下：
- start ：通常设置为 NULL ，表示匿名映射可以从内核选择的任何内存位置开始。指定非 NULL 值时，该值必须按页对齐，但这会限制可移植性。
- prot ：通常设置 PROT_READ 和 PROT_WRITE 位，使映射可读可写。因为如果无法读写，空映射就没有意义。一般不希望在匿名映射中执行代码，因为这可能会带来安全风险。
- flags ：设置 MAP_ANONYMOUS 位表示映射是匿名的，设置 MAP_PRIVATE 位表示映射是私有的。
- fd 和 offset ：当设置了 MAP_ANONYMOUS 标志时，这两个参数会被忽略。不过，为了保证可移植性，建议将 fd 设置为 -1。

通过匿名映射获得的内存与从堆中获得的内存看起来相同，而且匿名映射的页面已经初始化为零，这是因为内核通过写时复制将应用程序的匿名页面映射到一个零填充的页面。因此，无需使用 memset() 来初始化返回的内存，这也是使用 calloc() 而不是 malloc() 后再调用 memset() 的一个好处。

使用 munmap() 函数可以释放匿名映射，将分配的内存返回给内核：

int ret;
/* all done with 'p', so give back the 512 KB mapping */
ret = munmap (p, 512 * 1024);
if (ret)
        perror ("munmap");

3.3 映射 /dev/zero

一些Unix系统（如BSD）没有 MAP_ANONYMOUS 标志，它们通过映射特殊设备文件 /dev/zero 来实现类似的功能。这个设备文件提供的语义与匿名内存相同，映射包含写时复制的全零页面，其行为与匿名内存一致。

Linux一直提供 /dev/zero 设备，并支持对其进行映射以获取零填充的内存。在引入 MAP_ANONYMOUS 之前，Linux程序员就采用了这种BSD风格的方法。为了与旧版本的Linux保持向后兼容，或者提高程序在其他Unix系统上的可移植性，开发者仍然可以映射 /dev/zero 来替代创建匿名映射。以下是一个映射 /dev/zero 的示例：

void *p;
int fd;
/* open /dev/zero for reading and writing */
fd = open ("/dev/zero", O_RDWR);
if (fd < 0) {
        perror ("open");
        return -1;
}
/* map [0,page size) of /dev/zero */
p = mmap (NULL,                   /* do not care where */
          getpagesize (),         /* map one page */
          PROT_READ | PROT_WRITE, /* map read/write */
          MAP_PRIVATE,            /* private mapping */
          fd,                     /* map /dev/zero */
          0);                     /* no offset */
if (p == MAP_FAILED) {
        perror ("mmap");
        if (close (fd))
                perror ("close");
        return -1;
}
/* close /dev/zero, no longer needed */
if (close (fd))
        perror ("close");
/* 'p' points at one page of memory, use it... */

通过这种方式映射的内存同样可以使用 munmap() 进行取消映射。不过，这种方法会增加打开和关闭设备文件的系统调用开销，因此匿名内存映射是更快速的解决方案。

4. 高级内存分配

许多内存分配操作受 glibc 或内核参数的限制和控制，程序员可以使用 mallopt() 函数来更改这些参数：

#include <malloc.h>
int mallopt (int param, int value);

mallopt() 函数将指定的内存管理相关参数 param 设置为 value 。调用成功时返回非零值，失败时返回0。需要注意的是， mallopt() 不会设置 errno ，并且通常会返回成功，因此不要对返回值抱有过高期望。

Linux目前支持以下七个 param 值，这些值都在 <malloc.h> 中定义：
| 参数 | 来源 | 默认值 | 有效值 | 特殊值 |
| ---- | ---- | ---- | ---- | ---- |
| M_CHECK_ACTION | Linux特定 | 0 | 0 - 2 | |
| M_GRAIN | XPG标准 | Linux不支持 | | |
| M_KEEP | XPG标准 | Linux不支持 | | |
| M_MMAP_MAX | Linux特定 | 64 * 1024 | >= 0 | 0禁用mmap()的使用 |
| M_MMAP_THRESHOLD | Linux特定 | 128 * 1024 | >= 0 | 0禁用堆的使用 |
| M_MXFAST | XPG标准 | 64 | 0 - 80 | 0禁用快速分箱 |
| M_NLBLKS | XPG标准 | Linux不支持 | | |
| M_PERTURB | Linux特定 | 0 | 0或1 | 0禁用扰动 |
| M_TOP_PAD | Linux特定 | 0 | >= 0 | 0禁用顶部填充 |
| M_TRIM_THRESHOLD | Linux特定 | 128 * 1024 | >= -1 | -1禁用修剪 |

XPG标准还定义了另外三个参数 M_GRAIN 、 M_KEEP 和 M_NLBLKS ，但在Linux上设置这些参数的值没有效果。

程序必须在第一次调用 malloc() 或其他内存分配接口之前调用 mallopt() 。以下是一个使用示例：

int ret;
/* use mmap() for all allocations over 64 KB */
ret = mallopt (M_MMAP_THRESHOLD, 64 * 1024);
if (!ret)
        fprintf (stderr, "mallopt failed!\n");

5. 精细调整：malloc_usable_size() 和 malloc_trim()

Linux提供了两个函数来对 glibc 的内存分配系统进行底层控制：
- malloc_usable_size() ：该函数用于查询给定内存分配中可用的字节数。

#include <malloc.h>
size_t malloc_usable_size (void *ptr);

调用成功时，它返回 ptr 所指向的内存块的实际分配大小。由于 glibc 可能会对分配进行向上取整以适应现有块或匿名映射，因此分配的可用空间可能会比请求的大，但绝不会小于请求的大小。以下是一个使用示例：

size_t len = 21;
size_t size;
char *buf;
buf = malloc (len);
if (!buf) {
        perror ("malloc");
        return -1;
}
size = malloc_usable_size (buf);
/* we can actually use 'size' bytes of 'buf' ... */

• malloc_trim() ：该函数用于强制 glibc 将所有可立即释放的内存返回给内核。

#include <malloc.h>
int malloc_trim (size_t padding);

调用成功时，它会尽可能缩小数据段，保留 padding 字节的预留空间，然后返回1。失败时返回0。通常，当可释放的内存达到 M_TRIM_THRESHOLD 字节时， glibc 会自动执行这种缩小操作，并使用 M_TOP_PAD 作为填充。

这两个函数主要用于调试或学习目的，它们不具有可移植性，并且会将 glibc 内存分配系统的底层细节暴露给程序。

6. 内存分配调试

程序可以通过设置环境变量 MALLOC_CHECK_ 来启用内存子系统的增强调试功能。虽然额外的调试检查会降低内存分配的效率，但在应用程序开发的调试阶段，这种开销往往是值得的。

由于调试是通过环境变量控制的，因此无需重新编译程序。例如，可以使用以下命令：

$ MALLOC_CHECK_=1 ./rudder

MALLOC_CHECK_ 的不同设置会产生不同的效果：
- 设置为0：内存子系统会默默忽略任何错误。
- 设置为1：会将详细的错误信息打印到 stderr 。
- 设置为2：程序会立即通过 abort() 终止。

需要注意的是，由于 MALLOC_CHECK_ 会改变程序的运行行为，因此 setuid 程序会忽略该变量。

7. 获取统计信息

Linux提供了 mallinfo() 函数来获取与内存分配系统相关的统计信息：

#include <malloc.h>
struct mallinfo mallinfo (void);

通过调用这个函数，我们可以了解内存分配系统的详细状态，这对于调试和性能优化非常有帮助。

综上所述，内存管理是一个复杂而重要的领域，从严格别名规则到高级调试功能，每个环节都需要我们深入理解和谨慎处理。希望本文能帮助大家更好地掌握内存管理的相关知识，编写出更高效、更稳定的程序。

深入解析内存管理：从严格别名到高级调试

8. 总结与建议

内存管理在C和C++编程中是一个复杂且关键的领域，涉及到诸多概念和技术。下面为大家总结一些关键要点和实用建议：
- 严格别名规则 ：要时刻牢记严格别名规则，避免通过不合法的类型转换指针来访问对象，防止违反规则导致的未定义行为。在编写代码时，尽量遵循规则，以确保代码的可移植性和稳定性。
- 数据段管理 ：虽然 brk() 和 sbrk() 函数提供了直接管理数据段的方式，但为保证程序的可移植性，建议优先使用基于标准的内存分配接口，如 malloc() 和 free() 。
- 匿名内存映射 ：对于大内存分配，考虑使用匿名内存映射，以避免堆碎片化问题。但要注意其可能带来的空间浪费和创建开销，合理设置 M_MMAP_THRESHOLD 参数。
- 高级内存分配 ：使用 mallopt() 函数可以对内存分配进行更精细的控制，但要在调用 malloc() 之前进行设置，并且了解各个参数的作用和影响。
- 调试与统计 ：在开发过程中，利用 MALLOC_CHECK_ 环境变量进行内存分配调试，以及使用 mallinfo() 函数获取内存分配统计信息，有助于及时发现和解决内存管理问题。

9. 流程图：内存分配流程

graph TD;
    A[开始内存分配请求] --> B{请求大小 <= M_MMAP_THRESHOLD?};
    B -- 是 --> C[使用数据段（伙伴内存分配方案）];
    B -- 否 --> D[创建匿名内存映射];
    C --> E{是否有合适分区?};
    E -- 是 --> F[返回分区];
    E -- 否 --> G[扩展数据段];
    G --> C;
    D --> H[使用mmap()创建映射];
    H --> I[返回映射内存];
    F --> J[使用内存];
    I --> J;
    J --> K{是否释放内存?};
    K -- 是 --> L{使用数据段分配?};
    L -- 是 --> M[标记分区为空闲，合并相邻空闲分区];
    L -- 否 --> N[使用munmap()释放映射];
    M --> O{顶部空闲内存 >= M_TRIM_THRESHOLD?};
    O -- 是 --> P[使用sbrk()返回内存给内核];
    O -- 否 --> Q[等待下次分配];
    N --> Q;
    K -- 否 --> J;

这个流程图展示了内存分配和释放的整体流程，从请求内存开始，根据请求大小决定使用数据段还是匿名内存映射，在使用完内存后进行释放操作，并根据情况调整数据段大小。

10. 实际应用案例

为了更好地理解上述内存管理技术的应用，下面给出一个简单的实际应用案例。假设我们需要编写一个程序来处理大量的数据，可能会涉及到频繁的内存分配和释放操作。

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <sys/mman.h>
#include <unistd.h>

#define LARGE_ALLOCATION_SIZE (256 * 1024)  // 256 KB
#define SMALL_ALLOCATION_SIZE (100)

void large_allocation() {
    void *p = mmap(NULL, LARGE_ALLOCATION_SIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
    if (p == MAP_FAILED) {
        perror("mmap");
        return;
    }
    // 使用内存
    for (size_t i = 0; i < LARGE_ALLOCATION_SIZE; i++) {
        ((char *)p)[i] = 'A';
    }
    // 释放内存
    if (munmap(p, LARGE_ALLOCATION_SIZE)) {
        perror("munmap");
    }
}

void small_allocation() {
    char *buf = (char *)malloc(SMALL_ALLOCATION_SIZE);
    if (!buf) {
        perror("malloc");
        return;
    }
    // 使用内存
    for (size_t i = 0; i < SMALL_ALLOCATION_SIZE; i++) {
        buf[i] = 'B';
    }
    // 释放内存
    free(buf);
}

int main() {
    // 设置高级内存分配参数
    if (!mallopt(M_MMAP_THRESHOLD, 128 * 1024)) {
        fprintf(stderr, "mallopt failed!\n");
    }

    // 进行大内存分配
    large_allocation();

    // 进行小内存分配
    small_allocation();

    // 获取内存分配统计信息
    struct mallinfo info = mallinfo();
    printf("Total non-mmapped bytes (arena): %d\n", info.arena);
    printf("Number of free chunks: %d\n", info.ordblks);

    return 0;
}

在这个案例中，我们分别实现了大内存分配和小内存分配的函数。大内存分配使用匿名内存映射，小内存分配使用 malloc() 。在 main() 函数中，我们设置了 M_MMAP_THRESHOLD 参数，并获取了内存分配的统计信息。

11. 常见问题解答

以下是一些关于内存管理的常见问题及解答：
- 问题1：为什么会出现内存碎片化问题？
- 解答：伙伴内存分配方案在分配和释放内存时，可能会导致内部碎片化（使用的内存超过请求大小）和外部碎片化（空闲内存被分割成不相邻的块）。
- 问题2：如何避免内存碎片化？
- 解答：对于大内存分配，使用匿名内存映射可以避免堆碎片化。同时，合理安排内存分配和释放顺序，也有助于减少碎片化。
- 问题3： mallopt() 函数的参数设置有什么注意事项？
- 解答：要在第一次调用 malloc() 之前设置参数，并且了解每个参数的作用和取值范围。一些参数的设置可能会对内存分配产生重大影响，需要谨慎调整。
- 问题4： MALLOC_CHECK_ 环境变量的不同值有什么区别？
- 解答：设置为0时，忽略内存分配错误；设置为1时，打印错误信息到 stderr ；设置为2时，程序会立即终止。

通过以上内容，我们对内存管理的各个方面有了更深入的了解。在实际编程中，要根据具体需求和场景，合理运用各种内存管理技术，以提高程序的性能和稳定性。希望大家在掌握这些知识后，能够编写出更加优秀的代码。