Glib学习（20）内存片 Memory Slices

绝地灬酷狼 2022-04-24 14:58 344阅读 0赞

glib源码下载：http://ftp.gnome.org/pub/gnome/sources/glib/  
glib帮助文档：https://developer.gnome.org/glib/

本节主要讲解一下Memory Allocation函数，基本就是linux系统函数的封装，我把函数使用谷歌翻译了一下，没有仔细校验，因为英语是在太差，而且函数基本差不多，懂了一个就能举一反三。基本都是实际使用的函数，就不提供例程了。  
Includes  
\#include <gmodule.h>

描述  
内存片提供了一种节省空间和多处理的可扩展方式来分配相同大小的内存，就像原始的GMemChunks（来自GLib 2.8）一样，同时避免了过多的内存浪费，可伸缩性和性能问题。  
为了实现这些目标，切片分配器采用了复杂的分层设计，灵感来自Bonwick的slab分配器（Bonwick94 Jeff Bonwick，slab分配器：对象缓存内核内存分配器.USENIX 1994，Bonwick01 Bonwick和Jonathan Adams，杂志 和vmem：将slab分配器扩展到许多cpu和任意资源.USENIX 2001）  
它使用posix\_memalign（）来优化许多同等大小的块的分配，并且具有每线程空闲列表（所谓的杂志层）以快速满足已知结构大小的分配请求。 这伴随着额外的缓存逻辑，以便在将内存释放到系统之前将其释放一段时间。 由于对齐约束而未使用的内存用于缓存着色（块地址的随机分布）以提高CPU缓存利用率。 切片分配器的缓存层使其自身适应高锁争用以提高可伸缩性。  
切片分配器可以分配小到两个指针的块，与malloc（）不同，它不会为每个块保留额外的空间。 对于大块大小，g\_slice\_new（）和g\_slice\_alloc（）将自动委托给系统malloc（）实现。 对于新编写的代码，建议使用新的g\_slice API而不是g\_malloc（）和系列函数，只要对象在其生命周期内没有调整大小，并且在释放时分配时使用的对象大小仍然可用。  
以下是使用切片分配器的示例：

gchar *mem[10000];
    gint i;
    
    // Allocate 10000 blocks.
    for (i = 0; i < 10000; i++)
      {
        mem[i] = g_slice_alloc (50);
    
        // Fill in the memory with some junk.
        for (j = 0; j < 50; j++)
          mem[i][j] = i * j;
      }
    
    // Now free all of the blocks.
    for (i = 0; i < 10000; i++)
      g_slice_free1 (50, mem[i]);

以下是使用切片分配器和数据结构的示例：

GRealArray *array;
    
    // Allocate one block, using the g_slice_new() macro.
    array = g_slice_new (GRealArray);
    
    // We can now use array just like a normal pointer to a structure.
    array->data            = NULL;
    array->len             = 0;
    array->alloc           = 0;
    array->zero_terminated = (zero_terminated ? 1 : 0);
    array->clear           = (clear ? 1 : 0);
    array->elt_size        = elt_size;
    
    // We can free the block, so it can be reused.
    g_slice_free (GRealArray, array);

函数

**g\_slice\_alloc ()**  
gpointer  
g\_slice\_alloc (gsize block\_size);  
从切片分配器分配一块内存。 发出的块地址可以预期与至少1 \* sizeof（void \*）对齐，但通常切片是2 \* sizeof（void \*）字节对齐，如果使用malloc（）原始实现，则可以以libc依赖的方式减少对齐。请注意，可以使用G\_SLICE = always-malloc环境变量更改基础切片分配机制。  
参数  
block\_size  
要分配的字节数  
返回值  
指向已分配内存块的指针，当且仅当mem\_size为0时才为NULL

**g\_slice\_alloc0 ()**  
gpointer  
g\_slice\_alloc0 (gsize block\_size);  
通过g\_slice\_alloc（）分配一块内存，并将返回的内存初始化为0.注意，可以使用G\_SLICE = always-malloc环境变量更改基础切片分配机制。  
参数  
block\_size  
要分配的字节数  
返回值  
指向已分配块的指针，当且仅当mem\_size为0时才为NULL

**g\_slice\_copy ()**  
gpointer  
g\_slice\_copy (gsize block\_size,  
              gconstpointer mem\_block);  
从切片分配器分配一块内存，并从mem\_block将block\_size字节复制到其中。  
如果block\_size不为零，则mem\_block必须为非NULL。  
参数  
block\_size  
要分配的字节数  
mem\_block  
要复制的内存  
返回值  
指向已分配内存块的指针，当且仅当mem\_size为0时才为NULL

**g\_slice\_free1 ()**  
void  
g\_slice\_free1 (gsize block\_size,  
               gpointer mem\_block);  
释放一块内存。  
必须通过g\_slice\_alloc（）或g\_slice\_alloc0（）分配内存，并且block\_size必须与分配时指定的大小相匹配。 请注意，可以使用G\_DEBUG = gc-friendly环境变量更改确切的发布行为，有关相关的调试选项，请参阅G\_SLICE。  
如果mem\_block为NULL，则此函数不执行任何操作。  
参数  
block\_size  
块的大小  
mem\_block  
指向要释放的块的指针

**g\_slice\_free\_chain\_with\_offset ()**  
void  
g\_slice\_free\_chain\_with\_offset (gsize block\_size,  
                                gpointer mem\_chain,  
                                gsize next\_offset);  
释放结构类型类型的内存块的链接列表。  
内存块必须大小相等，通过g\_slice\_alloc（）或g\_slice\_alloc0（）分配，并通过下一个指针（类似于GSList）链接在一起。 每个块中下一个字段的偏移量作为第三个参数传递。 请注意，可以使用G\_DEBUG = gc-friendly环境变量更改确切的发布行为，有关相关的调试选项，请参阅G\_SLICE。  
如果mem\_chain为NULL，则此函数不执行任何操作。  
参数  
block\_size  
块的大小  
mem\_chain  
指向链的第一个块的指针  
next\_offset  
块中下一个字段的偏移量

**g\_slice\_new()**  
\#define             g\_slice\_new(type)  
一个方便的宏，用于从切片分配器分配一块内存。  
它使用sizeof（@type）调用g\_slice\_alloc（）并将返回的指针强制转换为给定类型的指针，从而避免在源代码中强制转换类型。 请注意，可以使用G\_SLICE = always-malloc环境变量更改基础切片分配机制。  
这永远不会返回NULL，因为sizeof（@type）的最小分配大小是1个字节。  
参数  
type  
要分配的类型，通常是结构名称  
返回值  
指向已分配块的指针，强制转换为指向类型的指针。  
\[not nullable\]

**g\_slice\_new0()**  
\#define             g\_slice\_new0(type)  
一个方便的宏，用于从片分配器分配一块内存并将内存设置为0。  
它使用sizeof（@type）调用g\_slice\_alloc0（）并将返回的指针强制转换为给定类型的指针，从而避免在源代码中强制转换类型。 请注意，可以使用G\_SLICE = always-malloc环境变量更改基础切片分配机制。  
这永远不会返回NULL，因为sizeof（@type）的最小分配大小是1个字节。  
参数  
type  
要分配的类型，通常是结构名称  
返回值  
指向已分配块的指针，强制转换为指向类型的指针。  
\[not nullable\]

**g\_slice\_dup()**  
\#define             g\_slice\_dup(type, mem)  
使用切片分配器复制内存块的便捷宏。  
它使用sizeof（@type）调用g\_slice\_copy（）并将返回的指针强制转换为给定类型的指针，从而避免在源代码中强制转换类型。 请注意，可以使用G\_SLICE = always-malloc环境变量更改基础切片分配机制。  
这永远不会返回NULL。  
参数  
type  
要复制的类型，通常是结构名称  
mem  
要复制到已分配块的内存。  
\[not nullable\]  
返回值  
指向已分配块的指针，强制转换为指向类型的指针。  
\[not nullable\]

**g\_slice\_free()**  
\#define             g\_slice\_free(type, mem)  
一个方便的宏，用于释放已从切片分配器分配的内存块。  
它使用sizeof（type）作为块大小调用g\_slice\_free1（）。 请注意，可以使用G\_DEBUG = gc-friendly环境变量更改确切的发布行为，有关相关的调试选项，请参阅G\_SLICE。  
如果mem为NULL，则此宏不执行任何操作。  
参数  
type  
要释放的块的类型，通常是结构名称  
mem

a pointer to the block to free  
指向要释放的块的指针

**g\_slice\_free\_chain()**  
\#define             g\_slice\_free\_chain(type, mem\_chain, next)  
释放结构类型类型的内存块的链接列表。 内存块必须大小相等，通过g\_slice\_alloc（）或g\_slice\_alloc0（）分配，并通过下一个指针（类似于GSList）链接在一起。 类型中下一个字段的名称作为第三个参数传递。 请注意，可以使用G\_DEBUG = gc-friendly环境变量更改确切的发布行为，有关相关的调试选项，请参阅G\_SLICE。  
如果mem\_chain为NULL，则此函数不执行任何操作。  
参数  
type  
mem\_chain块的类型  
mem\_chain  
指向链的第一个块的指针  
next  
类型中下一个指针的字段名称