当前位置：文档之家 › Uclibc中的malloc机制分析

Uclibc中的malloc机制分析

  • 格式：pdf
  • 大小：466.89 KB
  • 文档页数：18

Uclibc中的malloc机制分析Uclibc是嵌入式linux系统里面使用最多的c lib库。

最近在学习linux内核内存管理方面的东西，学完之后一直对用户空间的内存管理很迷糊，特找了libc中的malloc部份代码研究了一下，小有心得。

特总结成此文。

本文档结构：一：准备知识二：堆空间的管理结构三：堆空间的初始化四：FA结构的操作五：malloc的实现六：free的实现七：总结一： 准备知识：用户空间中，经常会调用malloc 与 free进行内存管理，它是在进程的堆空间中分配内存。

如下图所示：二：堆空间的管理结构：堆空间表示的数据结构struct heap{//堆空间空闲区的表示结构struct heap_free_area *free_areas;//用于在多线程环境中加锁保护#ifdef HEAP_USE_LOCKINGpthread_mutex_t lock;#endif};heap_free_area结构在代码被代码作者称之为FA结构。

它的定义如下：struct heap_free_area{//空闲区的大小size_t size;//用于构造循环链表struct heap_free_area *next, *prev;};注意：在FA结构里并没有定义指向空闲区的指针，这是因为FA结构正好放在空闲区的后面。

堆栈区空间结构如下所示：三：堆空间的初始化：全局变量__malloc_heap表示了整个堆栈空间。

它的初始化过程如下示：struct heap __malloc_heap = HEAP_INIT_WITH_FA (initial_fa);HEAP_INIT_WITH_FA的定义如下：#ifdef HEAP_USE_LOCKING# define HEAP_INIT { 0, PTHREAD_MUTEX_INITIALIZER }# define HEAP_INIT_WITH_FA(fa) { &fa._fa, PTHREAD_MUTEX_INITIALIZER }#else# define HEAP_INIT { 0 }# define HEAP_INIT_WITH_FA(fa) { &fa._fa }#endif变量initial_fa初始化如下：HEAP_DECLARE_STATIC_FREE_AREA (initial_fa, 256);#define HEAP_DECLARE_STATIC_FREE_AREA(name, size) \static struct \{ \char space[(size) - sizeof (struct heap_free_area)]; \struct heap_free_area _fa; \} name = { "", { (size), 0, 0 } }如此可以看出初始化的堆空间为256个字节。

从上面的初始化也可以看到，在FA结构的前面静态定义了一个数组空间。

这也印证了上面说的“FA结构正好放在空闲区的后面”四：FA结构的操作：1：#define HEAP_FREE_AREA_SIZE(fa) ((fa)->size)FA所代表的空闲区大小，此大小已经包含FA本身占的空间2:#define HEAP_FREE_AREA_START(fa) ((void *)((char *)(fa + 1) - (fa)->size))FA所代表空闲区的起始位置。

fa+1到达空闲区末端。

指针再下移大小个单位，即为空闲区的起始位置3：#define HEAP_FREE_AREA_END(fa) ((void *)(fa + 1))返回FA所表示空闲区的末尾。

从FA所表示的结构可看出。

从FA的地址上移一个FA的大小，刚好到达空闲的末尾4：#define HEAP_MIN_FREE_AREA_SIZE \HEAP_ADJUST_SIZE (sizeof (struct heap_free_area) + 32)最少的空闲区大小。

空闲区最少要能存上一个heap_free_area大小，此外还要有32字节的空闲，这是从效率来考虑的。

Malloc分配内存的时候，有时候它会把一个FA分为两段。

如果剩余的内存少于HEAP_MIN_FREE_AREA_SIZE.还不如全部都将内存分配出去。

因为维护空闲内存需要影响效率。

这从我们后面的malloc 与 free分析中可以看到5:__heap_delete (struct heap *heap, struct heap_free_area *fa)该函数是将fa从heap中删除，它的实现如下：extern inline void__heap_delete (struct heap *heap, struct heap_free_area *fa){if (fa->next)fa->next->prev = fa->prev;if (fa->prev)fa->prev->next = fa->next;elseheap->free_areas = fa->next; //如果删除的是它的首节点}只是一个简单的链表操作，将fa从循环链表中脱节。

6:__heap_link_free_area (struct heap *heap, struct heap_free_area *fa,struct heap_free_area *prev,struct heap_free_area *next)从代码注释上看该函数是指prev 与 next 之间的Fa合并到一起。

实际上它只是在prev 与next 之间插入了一项而已。

实现如下：extern inline void__heap_link_free_area (struct heap *heap, struct heap_free_area *fa,struct heap_free_area *prev,struct heap_free_area *next){fa->next = next;fa->prev = prev;if (prev)prev->next = fa;elseheap->free_areas = fa; //插入节点为首节点的情况if (next)next->prev = fa;}7：__heap_link_free_area_after (struct heap *heap,struct heap_free_area *fa,struct heap_free_area *prev)该函数实际上只是fa链接至prev后。

等调用的时候再分析它。

__heap_link_free_area_after (struct heap *heap,struct heap_free_area *fa,struct heap_free_area *prev){if (prev)prev->next = fa;elseheap->free_areas = fa;fa->prev = prev;}8：__heap_add_free_area (struct heap *heap, void *mem, size_t size,struct heap_free_area *prev,struct heap_free_area *next)该函数将从mem地址开始的size大小的内存所代码的FA结构，插入prev和next之间。

它的实现如下：extern inline struct heap_free_area *__heap_add_free_area (struct heap *heap, void *mem, size_t size,struct heap_free_area *prev,struct heap_free_area *next){//先取得内存段所在的FA结构，再将FA结构插入到prev与next之间struct heap_free_area *fa = (struct heap_free_area *)((char *)mem + size - sizeof (struct heap_free_area));fa->size = size;//将fa插入prev.next之间__heap_link_free_area (heap, fa, prev, next);return fa;}这函数的实现很有意思。

它先取内存段的末地址，然后再返回heap_free_area个单位，存上一个FA 结构。

这里也印证了，FA结构刚好放在了空闲区的末尾9:__heap_free_area_alloc (struct heap *heap,struct heap_free_area *fa, size_t size)该函数从fa所表示的空闲中，分配size大小的内存实现如下：extern inline size_t__heap_free_area_alloc (struct heap *heap,struct heap_free_area *fa, size_t size){size_t fa_size = fa->size;//如果该空闲区剩余的内存太少。

将它全部都分配出去//参考HEAP_MIN_FREE_AREA_SIZE的分析if (fa_size < size + HEAP_MIN_FREE_AREA_SIZE)/* There's not enough room left over in FA after allocating the block, sojust use the whole thing, removing it from the list of free areas. */{//将fa从heap中删除__heap_delete (heap, fa);/* Remember that we've alloced the whole area. */size = fa_size;}else/* Reduce size of FA to account for this allocation. */fa->size = fa_size - size;return size;}从上面可以看出，分配内存时，只是简单的缩少了空闲区的长度。

10: __heap_alloc (heap, &size);从堆heap中分配size字节的内存实现如下：void *__heap_alloc (struct heap *heap, size_t *size){struct heap_free_area *fa;size_t _size = *size;void *mem = 0;//根据HEAP_GRANULARITY 对齐 sizeof(double)_size = HEAP_ADJUST_SIZE (_size);//如果要分配的内存比FA结构还要小，那就调整它为FA大小if (_size < sizeof (struct heap_free_area))/* Because we sometimes must use a freed block to hold a free-area node,we must make sure that every allocated block can hold one. */_size = HEAP_ADJUST_SIZE (sizeof (struct heap_free_area));HEAP_DEBUG (heap, "before __heap_alloc");/* Look for a free area that can contain _SIZE bytes. *///遍历堆中的FA，找出有合适大小的空闲区for (fa = heap->free_areas; fa; fa = fa->next)if (fa->size >= _size){/* Found one! */mem = HEAP_FREE_AREA_START (fa);//从该空间中分得内存。

合集下载

malloc底层分配原理

malloc底层分配原理

malloc底层分配原理在C语言中，我们经常使用malloc函数来动态分配内存。

malloc 函数的底层分配原理主要涉及到操作系统的内存管理机制。

操作系统将计算机的内存划分为多个块，每个块的大小可以不相同，这样就可以灵活地分配内存。

malloc函数通过与操作系统进行交互，请求一块指定大小的内存空间。

当我们调用malloc函数时，它会首先检查是否有足够的连续内存空间可供分配。

如果有足够的连续内存空间，则会将这段空间分配给我们，并返回一个指向这段内存空间起始地址的指针。

如果没有足够的连续内存空间，则会返回NULL，表示分配失败。

malloc函数的底层分配原理是通过操作系统提供的系统调用来实现的。

具体来说，当我们调用malloc函数时，它会先检查是否已经申请过内存空间。

如果已经申请过，则会在之前申请的内存空间中寻找足够大的连续空闲块来满足当前的内存申请。

如果找到了合适的空闲块，则将其分配给我们；如果没有找到合适的空闲块，则会向操作系统发起系统调用，请求额外的内存空间。

当操作系统接收到malloc函数的请求时，它会根据当前的内存分配策略来决定如何分配内存。

常见的内存分配策略有分页式内存管理和段式内存管理。

在分页式内存管理中，内存被划分为固定大小的页，每个页都有一个对应的页表来记录该页的使用情况。

当操作系统接收到malloc函数的请求时，它会在页表中查找足够大的连续空闲页来满足请求。

如果找到了合适的连续空闲页，则将其分配给malloc函数；如果没有找到合适的连续空闲页，则会进行内存换页操作，将一些不常用的页换出到磁盘上，腾出足够的内存空间来满足请求。

在段式内存管理中，内存被划分为多个段，每个段的大小可以不同。

当操作系统接收到malloc函数的请求时，它会在段表中查找足够大的连续空闲段来满足请求。

如果找到了合适的连续空闲段，则将其分配给malloc函数；如果没有找到合适的连续空闲段，则会向操作系统发起系统调用，请求额外的内存空间。

c语言中malloc作用

c语言中malloc作用

c语言中malloc作用C语言中`malloc`的作用在C语言中，`malloc`是一种常用的内存分配函数。

它的作用是动态地在程序运行时分配一块指定大小的内存空间，供程序使用。

`malloc`函数的完整原型如下：```cvoid* malloc(size_t size);```其中`size`是要分配的内存空间大小，返回值是一个`void`类型的指针，指向分配得到的内存块的起始地址。

由于`malloc`返回的是`void*`类型，因此根据实际需要，我们需要将其强制类型转换为特定的指针类型。

`malloc`函数的使用需要按照以下步骤进行：1. 引入`stdlib.h`头文件，该头文件中包含了`malloc`函数的定义。

2. 使用`malloc`函数进行内存分配。

3. 使用分配得到的内存空间。

4. 使用完毕后，使用`free`函数释放内存空间。

下面是一个简单的示例代码，展示了`malloc`函数的具体用法：```c#include <stdio.h>#include <stdlib.h>int main() {int *ptr;int n, i;printf("输入数组的长度：");scanf("%d", &n);// 使用malloc函数分配内存空间 ptr = (int*) malloc(n * sizeof(int)); if (ptr == NULL) {printf("内存分配失败。

\n");return 0;}printf("输入%d个整数：\n", n); for (i = 0; i < n; i++) {scanf("%d", &ptr[i]);}printf("你输入的数组是：");for (i = 0; i < n; i++) {printf("%d ", ptr[i]);}// 使用完毕后释放内存空间free(ptr);return 0;}```在上述示例中，我们通过`malloc`函数动态地分配了一个长度为`n`的整型数组所需的内存空间。

C语言中malloc函数的用法以及原理

C语言中malloc函数的用法以及原理

C语言中malloc函数的用法以及原理malloc函数是C语言中的一个动态内存分配函数，用于在运行时从堆中分配指定大小的内存空间。

它的原型为：```cvoid *malloc(size_t size);```其中，size_t是一个无符号整数类型，表示要分配的内存大小（以字节为单位）。

malloc函数返回一个指向分配内存的指针，如果分配失败则返回NULL。

malloc函数的用法很简单，只需要传入要分配的内存大小即可。

例如，下面的代码分配了一个大小为10字节的内存块，并将其地址赋给指针变量ptr：```c#include <stdio.h>#include <stdlib.h>int maiint *ptr = (int*)malloc(10 * sizeof(int));if (ptr == NULL)printf("内存分配失败\n");return 1;}//使用分配的内存块for (int i = 0; i < 10; i++)ptr[i] = i;printf("%d ", ptr[i]);}//释放内存free(ptr);return 0;```malloc函数的原理是通过调用操作系统提供的内存管理函数来实现的。

具体来说，malloc函数会向操作系统请求一块连续的内存空间，并将其分配给程序使用。

操作系统会维护一个内存空闲链表，用于记录可用的内存块。

当malloc函数被调用时，它会在空闲链表中找到一块足够大的内存块，并将其分配给程序。

如果找不到足够大的内存块，则分配失败。

为了提高内存分配的效率，malloc函数通常会分配比实际所需内存稍大的内存块，并将多余的部分保留起来。

这样做的目的是为了下次分配时可以直接使用这块多余的内存，而不需要再次向操作系统请求。

这种方式称为内存块的“对齐”或“填充”。

当程序使用完通过malloc函数分配的内存后，应该调用free函数来释放内存，以便将其返回给操作系统。

malloc从哪里得到的内存空间

malloc从哪里得到的内存空间

malloc从哪里得到的内存空间malloc 从哪里得到的内存空间引子在计算机高级编程语言中，C 语言相对来说是一种低级语言，从某种意义上讲，C 语言就是现代的“汇编语言”。

说C 语言低级很大程度上是因为C 程序员需要手动管理存储，具体反应在公认最难最容易出错的指针上。

比如编写C 程序时，经常会出现莫名奇妙的段错误，并且内存泄漏会在不知不觉的情况下发生，直到耗尽你的计算机内存资源为止。

更危险的则是缓冲区溢出，使程序非常容易受到攻击。

发明C++ 的一个目的是为了提升C 语言的抽象能力，还有一个目的就是为了消除指针，但C++ 显然没有做到这一点。

Java 则继承了C++ 的遗愿，彻底的消灭了指针。

Java 等高级语言采用严格的内存管理，动态的垃圾回收等机制使得程序员不用去手动管理内存，不用和底层打交道。

但C 语言的地位仍是无法取代的。

在必须和底层打交道的时候，就得使用C 语言（有时候甚至要用汇编语言），比如现代操作系统都是用C 语言编写的。

另外，高级语言在引入高级特征的同时，效率上就会有所损失，在非常强调执行效率的地方，C 语言通常是首选。

动态存储器分配大多是C 程序在运行时会需要额外的存储，并且不能事先知道需要的存储大小，这时候使用一种动态存储分配器（dynamic memory allocator）。

C 标准库提供了一个称为 malloc 的程序进行显式存储器分配，使用 free 函数来释放已分配内存，另外还有 calloc 和 realloc 两个函数。

#includevoid * malloc (size_t size);void * calloc (size_t num, size_t size);void * realloc(void * ptr, size_t size);void free (void * ptr);malloc 返回指向size 个字节的存储块的指针；calloc 返回指向num * size 个存储器块的指针，即分配 num 个 size 大小的连续存储块，并且存储器初始化为0. 注意：malloc 并不保证得到存储块初始化为 0；realloc 用在当 malloc 分配的存储块大小不够时，分配更大的块，并将数据复制到新的块。