slab分配器

最新推荐文章于 2024-01-03 16:17:00 发布
最新推荐文章于 2024-01-03 16:17:00 发布
阅读量753 收藏 3
点赞数 1
分类专栏： linux unix
原文链接：https://blog.csdn.net/wenqian1991/article/details/25652147
版权

用户应用程序对内存的需求是频繁的和任意的，而伙伴算法作为一个基础内存管理算法，并不具备提供这种任意性的条件，因此还需要以伙伴算法为基础，实现另外的内存管理机制，为用户提供申请任意大小内存的可能，这里就介绍 slab 分配器。

通俗的讲，slab 就是专门为某一模块预先一次性申请一定数量的内存备用，当这个模块想要使用内存的时候，就不再需要从系统中分配内存了（因为从系统中申请内存的时间开销相对来说比较大），而是直接从预申请的内存中拿出一部分来使用，这样就提高了这个模块的内存申请速度。

 

slab 要在合适的场合下使用才能发挥作用。使用 slab 通常需要满足以下两个条件：

第一条件是，当某一子系统需要频繁地申请和释放内存时，使用 slab 才会合理一些。如果某段程序中申请和释放内存的频率不高，就没必要预先申请一块很大的内存备用，然后再从这段私有空间中分配内存了。因为这样就意味着系统将会一次性损失过多内存，而由于内存请求的频率不高，也不会对系统性能有多大的提升。所以，对于频繁使用内存的程序来说，使用 slab 才有意义。

使用 slab 的另一个条件是，利用 slab 申请的内存必须是大小固定的。只有固定内存大小才有可能实现内存的高速申请和释放。

 

分配和释放数据结构时所有内核中最普遍的操作之一。Linux 内核提供了 slab 层（slab 分配器），其扮演了通用数据结构缓存层的角色。slab 层把不同的对象划分为所谓高速缓存组，其中每个高速缓存组都存放不同类型的对象，每种对象类型对应一个高速缓存。例如，一个高速缓存用于存放进程描述符，而另一个高速缓存存放索引节点对象，然后这些高速缓存又被划分为 slab。slab 由一个或多个物理上连续的页组成。一般情况下，slab 也就是仅仅由一页组成，每个高速缓存可以由多个 slab 组成。

 

slab 分配器把每一个请求的内存称之为对象。每个 slab 都包含一些对象成员，这里的对象指的是被缓存的数据结构。每个 slab 处于三种状态之一：满、部分满或空。一个满的 slab 没有空闲的对象（slab 中的对象都已被分配）。一个空的 slab 没有分配出任何对象（slab 中所有对象都是空闲的）。一个部分满的 slab 有一些对象已分配出去，有些对象还空闲着。当内核的某一部分需要一个新的对象时，先从部分满的 slab 中进行分配，如果没有部分满的 slab，就从空的 slab 中进行分配。如果没有空的 slab，就要创建一个 slab 了。

 

下面图示高速缓存、slab、对象之间的关系：

                                                           

每个高速缓存都使用 kmem_cache 结构来表示。这个结构包含3个链表：slabs_full，slabs_partial 和 slabs_empty，均存放在 kmem_list3 结构内（定义于 mm/slab.c），这些链表包含高速缓存中的所有slab。

slab 队列描述符

 

  1. /*

  2. * The slab lists for all objects.

  3. */

  4. struct kmem_list3 {

  5. struct list_head slabs_partial; /* partial list first, better asm code */

  6. struct list_head slabs_full;

  7. struct list_head slabs_free;

  8. unsigned long free_objects; /*高速缓存中空闲对象的个数*/

  9. unsigned int free_limit; /*整个slab高速缓存中空闲对象的上限*/

  10. unsigned int colour_next; /* Per-node cache coloring */

  11. spinlock_t list_lock; /*高速缓存自旋锁*/

  12. struct array_cache *shared; /* shared per node */

  13. struct array_cache **alien; /* on other nodes */

  14. unsigned long next_reap; /* updated without locking */

  15. int free_touched; /* updated without locking */

  16. };

 

slab高速缓存描述符

 

 

  1. struct kmem_cache {

  2. /* 为了提高效率，每个CPU都有一个slab空闲对象*/

  3. struct array_cache *array[NR_CPUS];

  4.  

  5. unsigned int batchcount;//从本地高速缓存批量移入或移出对象的数目

  6. unsigned int limit; //本地高速缓存空闲对象的最大数目

  7. unsigned int shared;

  8.  

  9. unsigned int buffer_size;

  10. u32 reciprocal_buffer_size;

  11. /* 3) touched by every alloc & free from the backend */

  12.  

  13. unsigned int flags; /* constant flags */

  14. unsigned int num; /* 每个slab 对象的个数*/

  15.  

  16. unsigned int gfporder; //每个slab中连续页框的数目2^gfporder

  17.  

  18. /* 分配页框时，传递给伙伴系统的标志 */

  19. gfp_t gfpflags;

  20.  

  21. size_t colour; /* slab使用的颜色个数 */

  22. unsigned int colour_off; /* 着色偏移 */

  23. struct kmem_cache *slabp_cache;//指向存放slab描述符的cache

  24. unsigned int slab_size; //单个slab的大小

  25. unsigned int dflags; /* dynamic flags */

  26.  

  27. /* constructor func */

  28. void(*ctor)(void *obj);

  29.  

  30. /* 5) cache creation/removal */

  31. const char *name; //高速缓存的名字

  32. struct list_head next; //通过该字段，将该cachep链接到cachep连表上

  33.  

  34. /*

  35. * We put nodelists[] at the end of kmem_cache, because we want to size

  36. * this array to nr_node_ids slots instead of MAX_NUMNODES

  37. * (see kmem_cache_init())

  38. * We still use [MAX_NUMNODES] and not [1] or [0] because cache_cache

  39. * is statically defined, so we reserve the max number of nodes.

  40. */

  41. struct kmem_list3 *nodelists[MAX_NUMNODES]; //slab队列描述符数组

  42. /*

  43. * Do not add fields after nodelists[]

  44. */

  45. };


slab描述符

 

高速缓存中的每个 slab 都有自己的类型为 slab 的描述符：

 

  1. /*

  2. * struct slab

  3. *

  4. * Manages the objs in a slab. Placed either at the beginning of mem allocated

  5. * for a slab, or allocated from an general cache.

  6. * Slabs are chained into three list: fully used, partial, fully free slabs.

  7. */

  8. struct slab {

  9. struct list_head list; /*slab描述符的三个双向循环链表中的一个使用的指针*/

  10. /*也就是在高速缓存描述符的 kmem_list3 结构中的 slabs_full、slabs_partial或slabs_free链表使用的指针*/

  11.  

  12. unsigned long colouroff; /*slab中着色的偏移量*/

  13. void *s_mem; /* slab中第一个对象的地址 */

  14. unsigned int inuse; /* 当前正在使用的(非空闲)slab中的对象个数 */

  15. kmem_bufctl_t free; /*slab中下一个空闲对象的下标，如果没有剩余空闲对象则为BUFCTL_END*/

  16. unsigned short nodeid; /*该slab属于哪个内存节点*/

  17. };

slab 描述符可能会被存放在两个地方：

外部slab描述符（外置式）：存放在slab外部，位于cache_size指向的一个普通高速缓存中。

内部slab描述符（内置式）：存放在slab的内部，位于分配给slab的内存的第一个页框的起始位置。

 

slab对象描述符

每个对象都有类型为 kmem_bufctl_t 的一个描述符。对象描述符存放在一个数组中，位于相应的slab描述符之后。因此，与slab描述符本身类似，slab对象描述符也可以用两种可能的方式来存放：

外部对象描述符：存放在slab（描述符）的外面，位于高速缓存描述符的 slabp_cache 字段指向的一个普通高速缓存中。

内部对象描述符：存放在slab内部（上面的 struct slab 中定义了 kmem_bufctl_t ），正好位于描述符所描述的对象之前。

对象描述符只不过是一个无符号整数，只有在对象空闲时才有意义。它包含的是下一个空闲对象在 slab 中的下标，因此实现了slab内部空闲对象的一个简单链表。

 

slab 分配器的接口

slab 层的管理是在每个高速缓存的基础上，通过提供给整个内核一个简单的接口来完成的。通过接口就可以创建和撤销新的高速缓存，并在高速缓存内分配和释放对象。高速缓存及其内 slab 的复杂管理完全通过 slab 层的内部机制来处理。

接下来看看slab缓存是如何创建、撤销以及如何从缓存中分配一个对象的。一个新的kmem_cache 通过 kmem_cache_create() 函数来创建：

 

  1. struct kmem_cache *

  2. kmem_cache_create(const char *name, size_t size, size_t align,

  3. unsigned long flags, void(*ctor)(void *))

  4. /*成功，返回一个指向所创建的缓存的指针，否则返回NULL*/

 

第一个参数 *name 是一个字符串，存放着高速缓存的名字；第二个参数 size 是高速缓存中每个元素的大小；第三个参数 align 是slab 内第一个对象的偏移，它用来确保在页内进行特定的对齐。通常情况下，0 就可以满足要求，也就是标准对齐。flag 参数是可选的设置项，用来控制高速缓存的行为，最后一个参数 ctor 是对象的构造函数，一般是不需要的，用 NULL 来代替。

该函数不能在中断上下文中调用，因为它可能会睡眠。

 

撤销一个 kmem_cache 则是通过 kmem_cache_destroy() 函数：

void kmem_cache_destroy(struct kmem_cache *cachep)

调用该函数之前应该满足以下三个条件：首先 cachep 所指向的缓存中所有 slab 都为空闲，否则的话是不可以撤销的；其次在调用kmem_cache_destroy() 过程中以及调用之后，调用中需要确保不会再访问这个缓存；最后，该函数也可能会引起阻塞，因此不能在中断上下文中使用。

 

 

从缓存中分配、释放对象

创建了高速缓存，就可以通过一下函数获取对象：

void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)

该函数从给定的高速缓存 cachep 中返回一个指向对象的指针。如果高速缓存的所有 slab 中都没有空闲对象，那么slab 层必须通过 kmem_getpages() 获取新的页（后面讲到），flag 的值传递给 _get_free_pages()。

 

最后释放一个对象，并把它返回给原先的 slab，可以使用下面这个函数：

 

void kmem_cache_free(struct kmem_cache *cachep, void *objp)

这样能把 cachep 中的对象 objp 标记为空闲。

 

 

创建新的 slab

前面说到，如果高速缓存的所有 slab 中都没有空闲对象，那么 slab分配器必须通过 kmem_getpages() 获取新的页。当slab 分配器创建新的 slab时，它依靠分区页框分配器来获得一组连续的空闲页框。

 

  1. static void *kmem_getpages(struct kmem_cache *cachep, gfp_t flags, int nodeid)

  2. {

  3. struct page *page;

  4. int nr_pages;

  5. int i;

  6.  

  7. #ifndef CONFIG_MMU

  8. /*

  9. * Nommu uses slab's for process anonymous memory allocations, and thus

  10. * requires __GFP_COMP to properly refcount higher order allocations

  11. */

  12. flags |= __GFP_COMP;

  13. #endif

  14.  

  15. flags |= cachep->gfpflags;

  16. if (cachep->flags & SLAB_RECLAIM_ACCOUNT)

  17. flags |= __GFP_RECLAIMABLE;

  18. /*从指定内存节点分配 2^gfporder 个连续页

  19. 会调用__alloc_pages()*/

  20. page = alloc_pages_exact_node(nodeid, flags | __GFP_NOTRACK, cachep->gfporder);

  21. if (!page)

  22. return NULL;

  23.  

  24. nr_pages = (1 << cachep->gfporder);//分配的页数

  25. if (cachep->flags & SLAB_RECLAIM_ACCOUNT)

  26. add_zone_page_state(page_zone(page),

  27. NR_SLAB_RECLAIMABLE, nr_pages);

  28. else

  29. add_zone_page_state(page_zone(page),

  30. NR_SLAB_UNRECLAIMABLE, nr_pages);

  31. for (i = 0; i < nr_pages; i++)

  32. __SetPageSlab(page + i);

  33.  

  34. if (kmemcheck_enabled && !(cachep->flags & SLAB_NOTRACK)) {

  35. kmemcheck_alloc_shadow(page, cachep->gfporder, flags, nodeid);

  36.  

  37. if (cachep->ctor)

  38. kmemcheck_mark_uninitialized_pages(page, nr_pages);

  39. else

  40. kmemcheck_mark_unallocated_pages(page, nr_pages);

  41. }

  42. /*物理地址转换为虚拟地址返回*/

  43. return page_address(page);

  44. }

kmem_getpages() 函数中调用 alloc_pages_exact_node() 函数最终是使用 __alloc_pages() 来返回一个 struct page 结构。进入 __alloc_pages() 然后转到 __alloc_pages_nodemask()，调用get_page_from_freelist() 函数从 zonelist 中取得相关 zone，并从其中返回一个可用的 struct page 页面，一个物理页面的分配是从 zonelist（一个 zone 的结构数组）中的 zone 返回的。

上面可以看出，slab 是在物理页面基础上实现的。

 

接着调用 kmem_freepages() 释放内存，对于给定的高速缓存页，kmem_freepages() 最终调用的是 free_pages()

 

 

  1. static void kmem_freepages(struct kmem_cache *cachep, void *addr)

  2. {

  3. unsigned long i = (1 << cachep->gfporder);

  4. struct page *page = virt_to_page(addr);//内核虚拟地址转换为该页的描述结构 struct page*

  5. const unsigned long nr_freed = i;

  6.  

  7. kmemcheck_free_shadow(page, cachep->gfporder);

  8.  

  9. if (cachep->flags & SLAB_RECLAIM_ACCOUNT)

  10. sub_zone_page_state(page_zone(page),

  11. NR_SLAB_RECLAIMABLE, nr_freed);

  12. else

  13. sub_zone_page_state(page_zone(page),

  14. NR_SLAB_UNRECLAIMABLE, nr_freed);

  15. while (i--) {

  16. BUG_ON(!PageSlab(page));

  17. __ClearPageSlab(page);

  18. page++;

  19. }

  20. if (current->reclaim_state)

  21. current->reclaim_state->reclaimed_slab += nr_freed;

  22. free_pages((unsigned long)addr, cachep->gfporder);

  23. }

从代码也可以看出 kmem_getpages() 与 kmem_freepages() 是对立的。
 

 

给高速缓存分配 slab

一个新创建的高速缓存没有包含任何 slab，因此也没有空闲的对象。只有当以下两个条件都为真时，才给高速缓存分配 slab。

  • 已发出一个分配新对象的请求
  • 高速缓存不包含任何空闲对象

 

 

  1. /*

  2. * Grow (by 1) the number of slabs within a cache. This is called by

  3. * kmem_cache_alloc() when there are no active objs left in a cache.

  4. */

  5. static int cache_grow(struct kmem_cache *cachep,

  6. gfp_t flags, int nodeid, void *objp)

当这些情况发生时，slab 分配器通过调用 cache_grow() 函数给高速缓存分配一个新的 slab。而这个函数调用 kmem_getpages() 从分区页框分配器获得一组页框来存放一个单独的 slab，然后又调用 alloc_slabmgmt() 获得一个新的slab描述符。如果高速缓存描述符的CFLGS_OFF_SLAB 标志置位，则从高速缓存描述符的 slabp_cache 字段指向的普通高速缓存中分配这个新的 slab 描述符；否则，从 slab 的第一个页框中分配这个 slab 描述符。

这里分析一下alloc_slabmgmt()函数：

 

 

  1. /*分配slab管理对象*/

  2. static struct slab *alloc_slabmgmt(struct kmem_cache *cachep, void *objp,

  3. int colour_off, gfp_t local_flags,

  4. int nodeid)

  5. {

  6. struct slab *slabp;

  7.  

  8. if (OFF_SLAB(cachep)) {

  9. /* Slab management obj is off-slab. */

  10. /* 外置式slab。从general slab cache中分配一个管理对象，

  11. slabp_cache指向保存有struct slab对象的general slab cache。

  12. slab初始化阶段general slab cache可能还未创建，slabp_cache指针为空

  13. ，故初始化阶段创建的slab均为内置式slab。*/

  14. slabp = kmem_cache_alloc_node(cachep->slabp_cache,

  15. local_flags, nodeid);

  16. /*

  17. * If the first object in the slab is leaked (it's allocated

  18. * but no one has a reference to it), we want to make sure

  19. * kmemleak does not treat the ->s_mem pointer as a reference

  20. * to the object. Otherwise we will not report the leak.

  21. *//* 对第一个对象做检查 */

  22. kmemleak_scan_area(slabp, offsetof(struct slab, list),

  23. sizeof(struct list_head), local_flags);

  24. if (!slabp)

  25. return NULL;

  26. }

  27. else {/* 内置式slab。objp为slab首页面的虚拟地址，加上着色偏移

  28. ，得到slab管理对象的虚拟地址 */

  29. slabp = objp + colour_off;

  30. /* 计算slab中第一个对象的页内偏移，slab_size保存slab管理对象的大小

  31. ，包含struct slab对象和kmem_bufctl_t数组 */

  32. colour_off += cachep->slab_size;

  33. } /* 在用（已分配）对象数为0 */

  34. slabp->inuse = 0;

  35. /* 第一个对象的页内偏移，可见对于内置式slab，colouroff成员不仅包括着色区

  36. ，还包括管理对象占用的空间

  37. ，外置式slab，colouroff成员只包括着色区。*/

  38. slabp->colouroff = colour_off;

  39. /* 第一个对象的虚拟地址 */

  40. slabp->s_mem = objp + colour_off;

  41. /* 内存节点ID */

  42. slabp->nodeid = nodeid;

  43. /* 第一个空闲对象索引为0，即kmem_bufctl_t数组的第一个元素 */

  44. slabp->free = 0;

  45. return slabp;

  46. }

 

 

 

接着，cache_grow() 调用 cache_init_objs()，它将构造方法（如果调用了的话）应用到新 slab 包含的所有对象上。最后，cache_grow() 调用 list_add_tail() 来将新得到的 slab 描述符 *slabp，添加到高速缓存描述符 *cachep 的全空 slab 链表的末端，并更新高速缓存中的空闲对象计数器；

 

从高速缓存中释放 slab

在两种条件下才能撤销slab：

  • slab 高速缓存中有太多的空闲对象
  • 被周期性调用的定时器函数确定是否有完全未使用的slab能被释放

在两种情况下，调用 slab_destory() 函数撤销一个slab，并释放相应的页框到分区页框分配器：

 

 

  1. /**

  2. * slab_destroy - destroy and release all objects in a slab

  3. * @cachep: cache pointer being destroyed

  4. * @slabp: slab pointer being destroyed

  5. *

  6. * Destroy all the objs in a slab, and release the mem back to the system.

  7. * Before calling the slab must have been unlinked from the cache. The

  8. * cache-lock is not held/needed.

  9. */

  10. /*销毁slab，需要释放slab管理对象和slab对象*/

  11. static void slab_destroy(struct kmem_cache *cachep, struct slab *slabp)

  12. {

  13. /*获得slab首页面的虚拟地址*/

  14. void *addr = slabp->s_mem - slabp->colouroff;

  15.  

  16. /*debug用*/

  17. slab_destroy_debugcheck(cachep, slabp);

  18.  

  19. /*使用SLAB_DESTROY_BY_RCU标志来创建的slab高速缓存*/

  20. if (unlikely(cachep->flags & SLAB_DESTROY_BY_RCU)) {

  21. /*rcu方式释放*/

  22. struct slab_rcu *slab_rcu;

  23.  

  24. slab_rcu = (struct slab_rcu *)slabp;

  25. slab_rcu->cachep = cachep;

  26. slab_rcu->addr = addr;

  27. call_rcu(&slab_rcu->head, kmem_rcu_free); //注册一个回调来延期释放slab

  28. }

  29. else {

  30. /*释放slab占用的页面到伙伴系统中*/

  31. /*内置式，slab管理对象和slab对象一起，可以同时释放*/

  32. kmem_freepages(cachep, addr);

  33. /*外置式，还需释放slab管理对象*/

  34. if (OFF_SLAB(cachep))

  35. kmem_cache_free(cachep->slabp_cache, slabp); //释放对象

  36. }

  37. }

 

 

slab 分配器大致情况就是这样，那么Linux 内存管理当中为什么要引进slab分配器呢？众所周知，内存管理比较难缠的就是内存碎片的问题，操作系统必须具备可以提供给进程运行时申请和释放任意大小内存的功能，这就是内存的动态分配。而动态分配就不可避免的将会产生内存碎片的问题，内存碎片就是碎片的内存，描述一个系统中所有不可用的空闲内存，内存是空闲的但是不可用，是因为负责动态分配内存的分配算法使得这些空闲的内存无法使用，原因在于这些个空闲内存比较小并且不连续，无法满足内存管理算法中的申请需求。

 

这些内存碎片存在的方式有两种：a. 内部碎片  b. 外部碎片

内部碎片的产生：因为所有的内存分配必须起始于可被4、8或16整除（内存对齐，视处理器体系结构而定）的地址或者因为MMU的分页机制的限制，决定内存分配算法仅能把预定大小的内存块分配客户（前面博文已介绍）。就是分配满足上面对齐条件的最小的大小内存，如果申请的不满足对齐条件，势必会多分配一点不需要的多余内存空间，造成内部碎片。如：申请43Byte，因为没有合适大小的内存，会分配44Byte或48Byte，就会存在1Byte或3Byte的多余空间。

外部碎片的产生：频繁的分配与回收物理页面会导致大量的、连续且小的页面块夹杂在已分配的页面中间，从而产生外部碎片。比如有一块共有100个单位的连续空闲内存空间，范围为0~99，如果从中申请了一块10 个单位的内存块，那么分配出来的就是0~9。这时再继续申请一块 5个单位的内存块，这样分配出来的就是 10~14。如果将第一块释放，此时整个内存块只占用了 10~14区间共 5个单位的内存块。然后再申请20个单位的内存块，此时只能从 15开始，分配15~24区间的内存块，如果以后申请的内存块都大于10个单位，那么 0~9 区间的内存块将不会被使用，变成外部碎片。

 

在解决小的内存碎片上，Linux 采用伙伴算法解决外部碎片的产生，但会因此产生内部碎片，基于此，Linux 内存管理采用了 slab allocation 机制：整理内存以便重复使用来避免常见的内部碎片问题。很显然 slab 机制是基于 buddy 短发的，前者是后者的细化。

重新说说slab 分配器的基本原理：按照预定固定的大小，将分配的内存分割成特定长度的块，以完全解决内存碎片问题。换句话说就是，将分配的内存分割成各种尺寸的块，并把相同尺寸的块分成组。另外分配到的内存不会释放，而是返回到对应的组，重复利用。

                                    

针对上面说的两种碎片，浅谈slab 分配器的优点。slab 分配器将分配的内存分割成特定长度的块，如上面图示。如果申请87个单位的内存块，同样会造成内存浪费，回顾前面说到的使用slab的第二个条件：使用slab申请的内存必须是大小固定的，另外slab中包含的是对象（被缓存的数据结构）。每个数据结构自然是特定大小的，这样申请的时候可以快速的从中分配对应对象大小的内存块，达到高效的目的，特别适用于频繁使用的数据结构。某对象撤销之后，并不会释放，而是重新返回slab（链表），撤销大小为88bytes大小的内存之后，并不会释放，而是返回继续挂载在 slab class 1中（类似于先前博文介绍的STL第二级空间配置器），这样避免了外部碎片。

           

水平有限，如有错误，敬请指正，谢谢！                                

参考资料：

《Linux内核设计与实现》

《深入理解Linux内核》

转载自：https://blog.csdn.net/wenqian1991/article/details/25652147

phone1126
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Slab块分配器详解
qq_41952309的博客
09-07 1462
slab块分配器学习笔记——包括slab思想及数据结构、高速缓存描述符结构、每处理器数组缓存、内存回收等内容。
linux内存占用问题调查——slab
赶路人儿
05-22 6994
1、问题描述： 最近在维护一台CentOS服务器的时候，发现内存无端"损失"了许多，free和ps统计的结果相差十几个G，登上去发现： $ free -g total used free shared buffers cached Mem: 15 15 0
内存管理专题05 slab分配器
weixin_42154057的博客
03-10 1766
内存管理专题05 slab分配器原理
内存管理-slab[原理]
aoyizu7608的博客
10-10 210
前言 主要讲解原理，基于2.6.32版本内核源码。本文整体思路：先由简单内存模型逐渐演进到当下通用服务器面对的内存模型，讨论每一个内存模型下slab设计需要解决的问题。 历史简介 linux内核运行需要动态分配内存，有两种分配方案： 第一种：以页为单位分配内存，一次申请内存的长度必须是页的整数倍 第二种：按需分配内存,一次申请内存的长度是随机的。 第一种分配方案通过bu...
Linux内核中的内存管理——slab
tombaby_come的博客
03-14 1988
在学习c语言时，我们常常会使用到malloc()去申请一块内存空间，用于存放我们的数据。刚开始我们只要知道申请内存时使用用malloc去申请一块就可以，而其中的原理我们并不关心。但是随着我们对运行环境的要求越来越多样化，复杂化，以及对稳定性以及性能问题的要求逐渐变得越来越重要时，我们往往需要关注到性能问题。而研究性能问问，如果只停留在知道使用malloc()可以去申请一块内存空间是远远不够的，此时我们就需要去研究相关的原理和代码。
Linux内存管理Slab分配器
01-31
Linux所使用的slab分配器的基础是JeffBonwick 为SunOS操作系统首次引入的一种算法。Jeff的分配器是围绕对象缓存进行的。在内核中，会为有限的对象集（例如文件描述符和其他常见结构）分配大量内存。Jeff 发现对内核...
论文研究-Linux系统中SLAB分配器内存回收算法分析和优化 .pdf
08-16
Linux系统中SLAB分配器内存回收算法分析和优化，陈卉，张振华，SLAB分配器在linux系统中的使用大大提高了内核中分配内存对象的效率，并且解决了小对象分配内存时产生的内存碎片问题。而该分配器的
LINUX中的Slab分配器.pdf
09-07
Linux中的Slab分配器是一种高效的内存管理机制，它在Linux 2.2及以后的版本中引入，以解决早期Linux版本中简单的二次幂表分配器存在的内存浪费和低利用率问题。Slab分配器的设计目标是提供更快的内存分配速度，更高...
Linux Slab分配器分析文档
12-22
Linux下Slab分配器比较详细的分析文档，Slab分配器的思想对程序设计时的内存分配是很有帮组的，3年前写的了，分享给大家，也欢迎指正错误。
linux系统slab内存占用
weixin_33851604的博客
06-27 832
今天遇见了一个问题，发现一台系统为redhat 5.8的跑storm的机器内存报警，然后跟了一下，发现系统内存耗尽了，但是通过top或者ps命令看到所有应用或系统进程内存占用率总和不到10%。[@storm-yd8325 ~]# free -m total used free shared buffers...
SLAB 分配器详解
最新发布
m0_74282605的博客
01-03 1047
虽然对象分配和释放的操作只针对处理器本地的活动 slab，但是在某些特殊的情况下会为当前处理器创建新的活动 slab 并把原先未用完的活动 slab 加到 NUMA 节点 的Partial 队列中（例如，在处理器 A 上运行的某内核执行绪申请对象，但是 A 的活动 slab 中已经没有空闲对象，因此必须创建新的 slab。SLAB 分配器多年以来一直位于 Linux 内核的内存管理部分的核心地带，内核黑客们一般不愿意主动去更改它的代码，因为它实在是非常复杂，而且在大多数情况下，它的工作完成的相当不错。
[内核内存] slab分配器1---slab机制详解
菁的博客
05-08 4115
文章目录1 slab分配器原理2 slab分配器重要数据结构以及组织关系2.1 slab cache描述符struct kmem_cache2.2 slab描述符struct page3.slab分配器中各个重要结构体间的关系总结 linux中的伙伴系统内存分配器是以页（4k）为最小粒度来进行内存分配。在实际的应用中，内核存储的大多数obj（如strcut task_strcuct，struct inode等数据结构）往往只需要几字节到几百字节不等。如果这些内核object的内存申请和释放都通过伙伴系统进行
深入linux内核架构--slab分配器（建议收藏）
m0_74282605的博客
11-12 1387
但是仔细想一想kmem_cache_node中的slab页帧结构你会发现，如果没有着色偏移的话，那么每次对应的缓存行一般都是从一个固定值开始的，假如我们忽略slab head的大小，每次slab对象都从页的起始位置开始分配，由于slab对象与cache line 一般来说是不等的，那么每次映射的缓存行一般是0 ~ 61或者0 ~ 62这种，所以62，63这种缓存行就会有较低访问概率，所以就需要这个着色偏移，还有一个__per_cpu array_cache用于表示该缓存在各个CPU中的slab对象；
Linux内存管理 slub分配器
生活需要深度
04-14 1718
内核管理页面使用了2个算法：伙伴算法和slub算法，伙伴算法以页为单位管理内存，但在大多数情况下，程序需要的并不是一整页，而是几个、几十个字节的小内存。于是需要另外一套系统来完成对小内存的管理，这就是slub系统。slub系统运行在伙伴系统之上，为内核提供小内存管理的功能。 ​ slub把内存分组管理，每个组分别包含 8、64、512、…2048个字节，在4K页大小的默认情况下，另外还有两个特殊的组，分别是96B和192B，共11组。之所以这样分配是因为如果申请2^12B大小的内存，就可以使用伙伴系统提供
Linux内存管理：(二)slab分配器
qq_58538265的博客
12-24 1220
文章说明：Linux内核版本：5.0架构：ARM64参考资料及图片来源：《奔跑吧Linux内核》
Linux slab 分配器源码解析
小立仔
07-12 1040
基于Linux内核2.6.32 slab 分配器源码解析
页分配器和slab分配器
06-05
页分配器和slab分配器是两种不同的内存分配算法。 页分配器是一种基于页面的内存分配算法，它将物理内存划分为固定大小的页面，并提供函数来分配和释放这些页面。在Linux内核中，页分配器主要由buddy分配器和slub...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值