Linux 記憶體管理：slab 分配器

slab · 發表 2018-10-17 07:01:18

摘要： Linux 記憶體管理是一個非常複雜的子系統，要完全說清的話估計要一本書的篇幅。但 Linux 記憶體管理可以劃分成多個部分來闡述，這篇文章主要介紹 slab 演算法。 Linux 有個叫夥伴系統的分配演算法，這個演算法主要解決分配連續個記憶體頁的問題。夥伴分配演算法主要以記憶體頁（...

Linux 記憶體管理是一個非常複雜的子系統，要完全說清的話估計要一本書的篇幅。但 Linux 記憶體管理可以劃分成多個部分來闡述，這篇文章主要介紹 slab 演算法。

Linux 有個叫夥伴系統的分配演算法，這個演算法主要解決分配連續個記憶體頁的問題。夥伴分配演算法主要以記憶體頁（ 4KB ）作為分配單位，就是說夥伴分配演算法每次可以分配 2 ^order 個記憶體頁（ order 為 0 、 1 、 2...9 ）。但有時候我們只需要申請一個很小的記憶體區（如 32 位元組），這時候使用夥伴分配演算法就顯得浪費了。為了解決小記憶體分配問題， Linux 使用了 slab 分配演算法。

相關資料結構

slab 演算法有兩個重要的資料結構，一個是 kmem_cache_t ，另外一個是 slab_t 。下面我們先來看看 kmem_cache_t 結構：

1. struct kmem_cache_s {

2. struct list_head slabs_full;

3. struct list_head slabs_partial;

4. struct list_head slabs_free;

5. unsigned int objsize;

6. unsigned int flags;

7. unsigned int num;

8. spinlock_t spinlock;

10. /* 2) slab additions /removals */

11. /* order of pgs per slab (2^n) */

12. unsigned int gfporder;

13.

14. /* force GFP flags, e.g. GFP_DMA */

15. unsigned int gfpflags;

16.

17. size_t colour;

18. unsigned int colour_off;

19. unsigned int colour_next;

20. kmem_cache_t *slabp_cache;

21. ...

22. struct list_head next;

23. ...

24. };

下面介紹一下 kmem_cache_t 結構中比較重要的欄位：

slab_full ：完全分配的 slab
slab_partial ：部分分配的 slab
slab_free ：沒有被分配過的 slab
objsize ：儲存的物件大小
num ：一個 slab 能夠儲存的物件個數
gfporder ：一個 slab 由 2 ^gfporder 個記憶體頁組成
colour/colour_off/colour_next ：著色區大小（後面會講到）

slab_t 結構定義如下：

1. typedef struct slab_s {

2. struct list_head list;

3. unsigned long colouroff;

4. void *s_mem;

5. unsigned int inuse;

6. kmem_bufctl_t free;

7. } slab_t;

slab_t 結構各個欄位的用途如下：

list ：連線（全滿 / 部分 / 全空）鏈
colouroff ：著色補償
s_mem ：儲存物件的起始記憶體地址
inuse ：已經分配多少個物件
free ：用於連線空閒的物件

用圖來表示它們之間的關係，如下：

這裡需要解釋一下，一個 slab 會被劃分為多個物件（可以理解為結構體），這些物件是 slab 演算法分配的最小單元，而一個 slab 一般有一個或者多個記憶體頁（但不能超過 2 ⁴ 個頁面）組成。

在 kmem_cache_t 結構中的 slab_free 連結串列的 slab 是記憶體回收的主要備選物件。由於物件是從 slab 中分配和釋放，所以單個 slab 可以在 slab 列表中進行一定。例如，當一個 slab 中所有物件被分配完時，就從 slab_partial 列表中移動到 slab_full 列表中。而當一個在 slab_free 列表中的 slab 被分配物件時，就會從 slab_free 列表中移動到 slab_partial 列表中。當一個 slab 中所有物件被釋放時，就會從 slab_partial 列表中移動到 slab_free 列表中。

slab分配器初始化

slab 分配器的初始化由 kmem_cache_init() 函式完成，如下：

1. void __init kmem_cache_init( void )

2. {

3. size_t left_over;

5. init_MUTEX(&cache_chain_sem);

6. INIT_LIST_HEAD(&cache_chain);

8. kmem_cache_estimate( 0 , cache_cache.objsize, 0 ,

9. &left_over, &cache_cache.num);

10. if (!cache_cache.num)

11. BUG();

12.

13. cache_cache.colour = left_over/cache_cache.colour_off;

14. cache_cache.colour_next = 0 ;

15. }

這個函式主要用來初始化 cache_cache 這個變數， cache_cache 是一個型別為 kmem_cache_t 的結構體變數，定義如下：

1. static kmem_cache_t cache_cache = {

2. slabs_full: LIST_HEAD_INIT(cache_cache.slabs_full),

3. slabs_partial: LIST_HEAD_INIT(cache_cache.slabs_partial),

4. slabs_free: LIST_HEAD_INIT(cache_cache.slabs_free),

5. objsize: sizeof(kmem_cache_t),

6. flags: SLAB_NO_REAP,

7. spinlock: SPIN_LOCK_UNLOCKED,

8. colour_off: L1_CACHE_BYTES,

9. name: "kmem_cache" ,

10. };

為什麼需要一個這樣的物件呢？因為本身 kmem_cache_t 結構體也是小記憶體物件，所以也應該有 slab 分配器來分配的，但這樣就出現 “ 雞蛋和雞誰先出現 ” 的問題。在系統初始化的時候， slab 分配器還沒有初始化，所以並不能使用 slab 分配器來分配一個 kmem_cache_t 物件，這時候只能通過定義一個 kmem_cache_t 型別的靜態變數來來管理 slab 分配器了，所以 cache_cache 靜態變數就是用來管理 slab 分配器的。

從上面的程式碼可知， cache_cache 的 objsize 欄位被設定為 sizeof(kmem_cache_t) 的大小，所以這個物件主要是用來分配不同型別的 kmem_cache_t 物件的。

kmem_cache_init() 函式呼叫了 kmem_cache_estimate() 函式來計算一個 slab 能夠儲存多少個大小為 cache_cache.objsize 的物件，並儲存到 cache_cache.num 欄位中。一個 slab 中不可能全部都用來分配物件的，舉個例子：一個 4096 位元組大小的 slab 用來分配大小為 22 位元組的物件，可以劃分為 186 個，但還剩餘 4 位元組不能使用的，所以這部分記憶體用來作為著色區。著色區的作用是為了錯開不同的 slab ，讓 CPU 更有效的快取 slab 。當然這屬於優化部分，對 slab 分配演算法沒有多大的影響。就是說就算不對 slab 進行著色操作， slab 分配演算法還是可以工作起來的。

kmem_cache_t物件申請

kmem_cache_t 是用來管理和分配物件的，所以要使用 slab 分配器時，必須先申請一個 kmem_cache_t 物件，申請 kmem_cache_t 物件由 kmem_cache_create() 函式進行：

1. kmem_cache_t *kmem_cache_create (

2. const char *name,

3. size_t size,

4. size_t offset,

5. unsigned long flags,

6. void (*ctor)( void *, kmem_cache_t *, unsigned long ),

7. void (*dtor)( void *, kmem_cache_t *, unsigned long )

8. ) {

9. ...

10. cachep = (kmem_cache_t *) kmem_cache_alloc(&cache_cache, SLAB_KERNEL);

11. if (!cachep)

12. goto opps;

13. memset(cachep, 0 , sizeof(kmem_cache_t));

14. ...

15. do {

16. unsigned int break_flag = 0 ;

17. cal_wastage:

18. kmem_cache_estimate(cachep->gfporder, size, flags,

19. &left_over, &cachep->num);

20. if (break_flag)

21. break ;

22. if (cachep->gfporder >= MAX_GFP_ORDER)

23. break ;

24. if (!cachep->num)

25. goto next;

26. if (flags & CFLGS_OFF_SLAB && cachep->num > offslab_limit) {

27. /* Oops, this num of objs will cause problems. */

28. cachep->gfporder--;

29. break_flag++;

30. goto cal_wastage;

31. }

32.

33. if (cachep->gfporder >= slab_break_gfp_order)

34. break ;

35.

36. if ((left_over* 8 ) <= (PAGE_SIZE<<cachep->gfporder))

37. break ; /* Acceptable internal fragmentation. */

38. next:

39. cachep->gfporder++;

40. } while ( 1 );

41.

42. if (flags & CFLGS_OFF_SLAB && left_over >= slab_size) {

43. flags &= ~CFLGS_OFF_SLAB;

44. left_over -= slab_size;

45. }

46.

47. /* Offset must be a multiple of the alignment. */

48. offset += (align- 1 );

49. offset &= ~(align- 1 );

50. if (!offset)

51. offset = L1_CACHE_BYTES;

52. cachep->colour_off = offset;

53. cachep->colour = left_over/offset;

54.

55. cachep->flags = flags;

56. cachep->gfpflags = 0 ;

57. if (flags & SLAB_CACHE_DMA)

58. cachep->gfpflags |= GFP_DMA;

59. spin_lock_init(&cachep->spinlock);

60. cachep->objsize = size;

61. INIT_LIST_HEAD(&cachep->slabs_full);

62. INIT_LIST_HEAD(&cachep->slabs_partial);

63. INIT_LIST_HEAD(&cachep->slabs_free);

64.

65. if (flags & CFLGS_OFF_SLAB)

66. cachep->slabp_cache = kmem_find_general_cachep(slab_size, 0 );

67. cachep->ctor = ctor;

68. cachep->dtor = dtor;

69. strcpy(cachep->name, name);

70.

71. down(&cache_chain_sem);

72. {

73. struct list_head *p;

74.

75. list_for_each(p, &cache_chain) {

76. kmem_cache_t *pc = list_entry(p, kmem_cache_t, next);

77. }

78. }

79.

80. list_add(&cachep->next, &cache_chain);

81. up(&cache_chain_sem);

82. opps:

83. return cachep;

84. }

kmem_cache_create() 函式比較長，所以上面程式碼去掉了一些不那麼重要的地方，使程式碼更清晰的體現其原理。

在 kmem_cache_create() 函式中，首先呼叫 kmem_cache_alloc() 函式申請一個 kmem_cache_t 物件，我們看到呼叫 kmem_cache_alloc() 時，傳入的就是 cache_cache 變數。申請完 kmem_cache_t 物件後需要對其進行初始化操作，主要是對 kmem_cache_t 物件的所有欄位進行初始化： 1) 計算需要多少個頁面來作為 slab 的大小。 2) 計算一個 slab 能夠分配多少個物件。 3) 計算著色區資訊。 4) 初始化 slab_full / slab_partial / slab_free 連結串列。 5) 把申請的 kmem_cache_t 物件儲存到 cache_chain 連結串列中。

物件分配

申請完 kmem_cache_t 物件後，就使用通過呼叫 kmem_cache_alloc() 函式來申請指定的物件。 kmem_cache_alloc() 函式程式碼如下：

1. static inline void *

2. kmem_cache_alloc_one_tail (kmem_cache_t *cachep, slab_t *slabp)

3. {

4. void *objp;

6. slabp->inuse++;

7. objp = slabp->s_mem + slabp->free*cachep->objsize;

8. slabp->free = slab_bufctl(slabp)[slabp->free];

10. if (unlikely(slabp->free == BUFCTL_END)) {

11. list_del(&slabp->list);

12. list_add(&slabp->list, &cachep->slabs_full);

13. }

14. return objp;

15. }

16.

17. static inline void *

18. __kmem_cache_alloc(kmem_cache_t *cachep, int flags)

19. {

20. unsigned long save_flags;

21. void * objp;

22. struct list_head * slabs_partial, * entry;

23. slab_t *slabp;

24.

25. kmem_cache_alloc_head(cachep, flags);

26. try_again:

27. local_irq_save(save_flags);

28.

29. slabs_partial = &(cachep)->slabs_partial;

30. entry = slabs_partial->next;

31.

32. if (unlikely(entry == slabs_partial)) {

33. struct list_head * slabs_free;

34. slabs_free = &(cachep)->slabs_free;

35. entry = slabs_free->next;

36. if (unlikely(entry == slabs_free))

37. goto alloc_new_slab;

38. list_del(entry);

39. list_add(entry, slabs_partial);

40. }

41.

42. slabp = list_entry(entry, slab_t, list);

43. objp = kmem_cache_alloc_one_tail(cachep, slabp);

44.

45. local_irq_restore(save_flags);

46. return objp;

47.

48. alloc_new_slab:

49. local_irq_restore(save_flags);

50. if (kmem_cache_grow(cachep, flags))

51. goto try_again;

52. return NULL;

53. }

kmem_cache_alloc() 函式被我展開之後如上程式碼， kmem_cache_alloc() 函式的主要步驟是： 1) 從 kmem_cache_t 物件的 slab_partial 列表中查詢是否有 slab 可用，如果有就直接從 slab 中分配一個物件。 2) 如果 slab_partial 列表中沒有可用的 slab ，那麼就從 slab_free 列表中查詢可用的 slab ，如果有可用 slab ，就從 slab 分配一個物件，並且把此 slab 放置到 slab_partial 列表中。 3) 如果 slab_free 列表中沒有可用的 slab ，那麼就呼叫 kmem_cache_grow() 函式申請新的 slab 來進行物件的分配。

一個 slab 的結構如下圖：

灰色部分是著色區，綠色部分是 slab 管理結構，黃色部分是空閒物件連結串列的索引，紅色部分是物件的實體。我們可以看到 slab 結構的 s_mem 欄位指向了物件實體列表的起始地址。

分配物件的時候就是先通過 slab 結構的 free 欄位檢視是否有空閒的物件可用， free 欄位儲存了空閒物件連結串列的首節點索引。

物件釋放

物件的釋放比較簡單，主要通過呼叫 kmem_cache_free() 函式完成，而 kmem_cache_free() 函式最終會呼叫 kmem_cache_free_one() 函式，程式碼如下：

1. static inline void

2. kmem_cache_free_one(kmem_cache_t *cachep, void *objp)

3. {

4. slab_t* slabp;

6. {

7. unsigned int objnr = (objp-slabp->s_mem)/cachep->objsize;

8. slab_bufctl(slabp)[objnr] = slabp->free;

9. slabp->free = objnr;

10. }

11.

12. /* fixup slab chains */

13. {

14. int inuse = slabp->inuse;

15. if (unlikely(!--slabp->inuse)) {

16. /* Was partial or full, now empty. */

17. list_del(&slabp->list);

18. list_add(&slabp->list, &cachep->slabs_free);

19. } else if (unlikely(inuse == cachep->num)) {

20. /* Was full. */

21. list_del(&slabp->list);

22. list_add(&slabp->list, &cachep->slabs_partial);

23. }

24. }

25. }

物件釋放的時候首先會把物件的索引新增到 slab 的空閒物件連結串列中，然後根據 slab 的使用情況移動 slab 到合適的列表中。 1) 如果 slab 所有物件都被釋放完時，把 slab 放置到 slab_free 列表中。 2) 如果物件所在的 slab 原來在 slab_full 中，那麼就把 slab 移動到 slab_partial 中。

Linux 記憶體管理：slab 分配器

您可能也會喜歡…