mysql源码学习笔记：内存管理模块MEM_ROOT

分手后的思念是犯贱 2022-06-18 06:10 178阅读 0赞

MEM\_ROOT为mysql的内存管理模块，用于统一申请和释放内存，减少在堆中的内存申请操作的次数，以提升性能。

**基础结构**

申请的内存空间使用的结构体

typedef struct st\_used\_mem

struct st\_used\_mem \*next; /\*连接指针，连接当前链表下所有的结构体\*/

unsigned int left; /\*当前结构体中剩余的空间\*/

unsigned int size; /\*结构体申请的size\*/

\}  **USED\_MEM;**

MEM\_ROOT结构体

typedef struct st\_mem\_root

USED\_MEM \*free; /\*可以使用的预申请空间链表\*/

USED\_MEM \*used; /\*使用中，且没有可用空间的预申请空间链表\*/

USED\_MEM \*pre\_alloc; /\*初始时预申请的\*/

size\_t min\_malloc /\*剩余的最小空间，如果预申请的空间剩余大小小于min\_alloc，将他移到used队列\*/;

size\_t block\_size; /\*每次申请内存块的基础大小\*/

unsigned int block\_num; /\* 计算申请内存的参数，最终每次申请内存块大小为 block\_size \* (block\_num >> 2) ，每次申请内存后该值+1\*/

unsigned int first\_block\_usage; /\*记录第一块内存块使用的次数，用作是否将第一块移入used链表的判断依据之一\*/

size\_t max\_capacity; /\*允许申请的最大空间地址的大小\*/

size\_t allocated\_size; /\*总计分配内存大小\*/

void (\*error\_handler)(void); /\*操作出错的是错误处理函数\*/

\}  **MEM\_ROOT** ;

一个使用中的MEM\_ROOT结构如下：

![Image 1][]

其中每个内存块由一个 **USED\_MEM** 结构体和内存空间组成，内存空间为向操作系统申请的内存。

MEM\_ROOT结构体中free链表和used链表将所有的内存块连接起来（红色斜线卫为已经使用的内存）。

**初始化**

初始化过程主要为所有变量赋初始值。如果输入参数pre\_alloc\_size为0，那么初始化过程是不申请任何大小的内存空间的。

void init\_alloc\_root(...MEM\_ROOT \*mem\_root, size\_t block\_size,size\_t pre\_alloc\_size )

| mem\_root->pre\_alloc= 0;

| ...

/\*每次申请空间的大小，用于后续申请空间使用\*/

| mem\_root->block\_size= block\_size - ALLOC\_ROOT\_MIN\_BLOCK\_SIZE;

/\*如果指定了参数pre\_alloc\_size，那么申请一块大小为pre\_alloc\_size的内存空间\*/

| if (pre\_alloc\_size)

| if ((mem\_root->free= mem\_root->pre\_alloc = (USED\_MEM\*) my\_malloc(,..pre\_alloc\_size+ ALIGN\_SIZE(sizeof(USED\_MEM)),

**申请空间**

mysql会首先使用my\_malloc根据初始化时输入的空间大小预申请一块较大的空间，每次调用alloc\_root函数，会在这块大的空间中，分配出一块空间地址作为alloc\_root函数的返回（目的是将多次零散的malloc操作合并成一次大的malloc操作，以提升性能）。

当预申请的空间不足时。会重新申请一块大的地址空间。当alloc\_root需要申请的空间大于预申请的空间时，mem\_root会动态的调整预申请空间的大小来满足alloc\_root的需求，如果max\_capacity未设置，那么无论alloc\_root申请多大的空间，mem\_root均会申请足够大的预申请空间来满足它的需求（如果操作系统允许）。

void \*alloc\_root(MEM\_ROOT \*mem\_root, size\_t length)

/\*

\* 1.读取第一个内存空间节点，并判断是否应该将第一个空间节点放入used链表

\* 2.在整个free链表中查看，查找第一个满足需求的（剩余空间超过length）的节点

\*/

| (\*(prev= &mem\_root->free)) /\*在free链表中读取第一个节点\*/

| if ((\*prev)->left < length) && /\*该节点剩余空间不满足需求\*/

mem\_root->first\_block\_usage++ >= ALLOC\_MAX\_BLOCK\_USAGE\_BEFORE\_DROP && /\*该节点的使用次数达到了权值(10次)\*/

(\*prev)->left < ALLOC\_MAX\_BLOCK\_TO\_DROP /\*该节点剩余空间小于4096\*/

| next->next= mem\_root->used; /\*同时满足上述3个条件，将节点移入used链表\*/

| mem\_root->used= next;

| mem\_root->first\_block\_usage= 0;

| for (next= \*prev ; next && next->left < length ; next= next->next) /\*遍历free链表，查找满足需求\*/

| prev= &next->next;

/\*

\* 在free链表中没有找到满足需要的内存块节点，或者第一次使用mem\_root，需要申请新的内存节点

\*/

| if (! next) /\*没找到满足条件的节点\*/

| block\_size= mem\_root->block\_size \* (mem\_root->block\_num >> 2); /\*mem\_root 需要申请的大小\*/

| get\_size= length+ALIGN\_SIZE(sizeof(USED\_MEM)); /\*需求的空间大小\*/

| get\_size= MY\_MAX(get\_size, block\_size); /\*两者取大最为申请值\*/

| is\_mem\_available(mem\_root, get\_size) /\*判断是否超出了允许的最大值\*/

| if (mem\_root->max\_capacity

if ((mem\_root->allocated\_size + size) > mem\_root->max\_capacity)

| next = (USED\_MEM\*) my\_malloc..., get\_size,MYF(MY\_WME | ME\_FATALERROR) /\*申请 get\_size大小的空间\*/

/\*

\* 更新mem\_root参数，根据新的内存块的剩余空间的大小，将内存块放入free链表或者used链表

\*/

| mem\_root->allocated\_size+= get\_size;

| mem\_root->block\_num++;

| next->next= \*prev; /\*放入free链表\*/

| ...

| if ((next->left-= (uint)length) < mem\_root->min\_malloc) /\*如果剩余空间小于min\_malloc，放入used链表 \*/

next->next= mem\_root->used;

**重置**

复用MEM\_ROOT，重置后，所有的内存块均被重置为未使用状态，所有的内存块均在free链表中。与全新的MEM\_ROOT相比，重置后的mem\_root并不会释放已经申请好的内存块。

mark\_blocks\_free(MEM\_ROOT\* root)

|last= &root->free;

|for (next= root->free; next; next= \*(last= &next->next)) /\*遍历free 链表，将所有内存块的left置位最大\*/

next->left= next->size - (uint)ALIGN\_SIZE(sizeof(USED\_MEM));

|\*last= next=root->used; /\*将used链表接在free链表最后\*/

| for (; next; next= next->next) /\*遍历原used链表，将所有内存块的left置位最大\*/

next->left= next->size - (uint)ALIGN\_SIZE(sizeof(USED\_MEM));

| root->used= 0;

| root->first\_block\_usage= 0;

**释放**

根据输入的参数，或者将MEM\_ROOT重置，或者将所有申请的内存块释放。

void free\_root(MEM\_ROOT \*root, myf MyFlags)

|if (MyFlags & MY\_MARK\_BLOCKS\_FREE) /\*参数为MY\_MARK\_BLOCKS\_FREE，重置MEM\_ROOT\*/

mark\_blocks\_free(root);

/\*

\* 遍历free链表和used链表，将除pre\_alloc外的所有内存块释放，重置pre\_alloc

\*/

| for (next=root->used; next ;)

my\_free(old);

| for (next=root->free; next ;)

my\_free(old);

| if (root->pre\_alloc)

root->free=root->pre\_alloc;

**总结**

MEM\_ROOT模块为mysql内部的内存管理模块，使用MEM\_ROOT模块，每次申请一个较大的内存块，将这个内存块根据需求拆分为小内存块使用。

对于申请内存size较少，并且申请较为频繁的情况，MEM\_ROOT模块能比较好的提升性能。

而对于申请内存size较大的情况。使用MEM\_ROOT与直接使用malloc申请，性能几乎持平。

[Image 1]:

mysql源码学习笔记：内存管理模块MEM_ROOT

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 RT-Thread学习笔记【内存管理】

相关 Spark内存管理及源码

相关 1.mysql学习笔记：mysql的源码安装

相关 mysql 源码学习笔记：mysqld启动流程

相关 Memcache源码阅读（4）---内存管理

相关 mysql源码学习笔记：内存管理模块MEM_ROOT

相关 mysql源码学习笔记：文件读写模块IO_CACHE

相关内存管理（Linux内核源码分析）

相关 mysql源码学习笔记：系统变量variables

相关 Memcached源码分析之内存管理