Linux Slab分配器(四)--分配對象

從一個緩存中分配對象總是遵循下面的原則：

1.本地高速緩存中是否有空閒對象，如果有的話則從其中獲取對象，這時分配的對象是最“熱”的；

2.如果本地高速緩存中沒有對象，則從kmem_list3中的slab鏈表中尋找空閒對象並填充到本地高速緩存再分配；

3.如果所有的slab中都沒有空閒對象了，那麼就要創建新的slab,再分配 。

函數kmem_cache_alloc用於從特定的緩存獲取對象，kmalloc用於從普通緩存中獲取對象，它們的執行流程如下圖所示

實質性的工作是從____cache_alloc()開始的，因此從這個函數作為入口來分析

1. static inline void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)  
2. {  
3.     void *objp;  
4.     struct array_cache *ac;  
5.   
6.     check_irq_off();  
7.   
8.     /*獲取緩存的本地高速緩存的描述符array_cache*/  
9.     ac = cpu_cache_get(cachep);  
10.   
11.     /*如果本地高速緩存中還有空閒對象可以分配則從本地高速緩存中分配*/  
12.     if (likely(ac->avail)) {  
13.         STATS_INC_ALLOCHIT(cachep);  
14.         ac->touched = 1;  
15.         /*先將avail的值減1，這樣avail對應的空閒對象是最熱的，即最近釋放出來的， 
16.           更有可能駐留在CPU高速緩存中*/  
17.         objp = ac->entry[--ac->avail];  
18.     } else {/*否則需要填充本地高速緩存*/  
19.         STATS_INC_ALLOCMISS(cachep);  
20.         objp = cache_alloc_refill(cachep, flags);  
21.     }  
22.     /* 
23.      * To avoid a false negative, if an object that is in one of the 
24.      * per-CPU caches is leaked, we need to make sure kmemleak doesn't 
25.      * treat the array pointers as a reference to the object. 
26.      */  
27.     kmemleak_erase(&ac->entry[ac->avail]);  
28.     return objp;  
29. }  

1. static void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags)  
2. {  
3.     int batchcount;  
4.     struct kmem_list3 *l3;  
5.     struct array_cache *ac;  
6.     int node;  
7.   
8. retry:  
9.     check_irq_off();  
10.     node = numa_node_id();  
11.     ac = cpu_cache_get(cachep);  
12.     batchcount = ac->batchcount;  /*獲取批量轉移的數目*/  
13.     if (!ac->touched && batchcount > BATCHREFILL_LIMIT) {  
14.         /* 
15.          * If there was little recent activity on this cache, then 
16.          * perform only a partial refill.  Otherwise we could generate 
17.          * refill bouncing. 
18.          */  
19.         batchcount = BATCHREFILL_LIMIT;  
20.     }  
21.     /*獲取kmem_list3*/  
22.     l3 = cachep->nodelists[node];  
23.   
24.     BUG_ON(ac->avail > 0 || !l3);  
25.     spin_lock(&l3->list_lock);  
26.   
27.     /* See if we can refill from the shared array */  
28.     /*如果有共享本地高速緩存，則從共享本地高速緩存填充*/  
29.     if (l3->shared && transfer_objects(ac, l3->shared, batchcount))  
30.         goto alloc_done;  
31.   
32.     while (batchcount > 0) {  
33.         struct list_head *entry;  
34.         struct slab *slabp;  
35.         /* Get slab alloc is to come from. */  
36.         /*掃描slab鏈表，先從partial鏈表開始，如果整個partial鏈表都無法找到batchcount個空閒對象， 
37.         再掃描free鏈表*/  
38.         entry = l3->slabs_partial.next;  
39.   
40.         /*entry回到表頭說明partial鏈表已經掃描完畢，開始掃描free鏈表*/  
41.         if (entry == &l3->slabs_partial) {  
42.             l3->free_touched = 1;  
43.             entry = l3->slabs_free.next;  
44.             if (entry == &l3->slabs_free)  
45.                 goto must_grow;  
46.         }  
47.   
48.         /*由鏈表項得到slab描述符*/  
49.         slabp = list_entry(entry, struct slab, list);  
50.         check_slabp(cachep, slabp);  
51.         check_spinlock_acquired(cachep);  
52.   
53.         /* 
54.          * The slab was either on partial or free list so 
55.          * there must be at least one object available for 
56.          * allocation. 
57.          */  
58.         BUG_ON(slabp->inuse >= cachep->num);  
59.   
60.         /*如果slabp中還存在空閒對象並且還需要繼續填充對象到本地高速緩存*/  
61.         while (slabp->inuse < cachep->num && batchcount--) {  
62.             STATS_INC_ALLOCED(cachep);  
63.             STATS_INC_ACTIVE(cachep);  
64.             STATS_SET_HIGH(cachep);  
65.   
66.             /*填充的本質就是用ac後面的void*數組元素指向一個空閒對象*/  
67.             ac->entry[ac->avail++] = slab_get_obj(cachep, slabp,  
68.                                 node);  
69.         }  
70.         check_slabp(cachep, slabp);  
71.   
72.         /* move slabp to correct slabp list: */  
73.         /*由於從slab中分配出去了對象，因此有可能需要將slab移到其他鏈表中去*/  
74.         list_del(&slabp->list);  
75.         /*free等於BUFCTL_END表示空閒對象已耗盡，將slab插入full鏈表*/  
76.         if (slabp->free == BUFCTL_END)  
77.             list_add(&slabp->list, &l3->slabs_full);  
78.         else/*否則肯定是插入partial鏈表*/  
79.             list_add(&slabp->list, &l3->slabs_partial);  
80.     }  
81.   
82. must_grow:  
83.     l3->free_objects -= ac->avail;/*刷新kmem_list3中的空閒對象*/  
84. alloc_done:  
85.     spin_unlock(&l3->list_lock);  
86.   
87.     /*avail為0表示kmem_list3中的slab全部處於full狀態或者沒有slab,則要為緩存分配slab*/  
88.     if (unlikely(!ac->avail)) {  
89.         int x;  
90.         x = cache_grow(cachep, flags | GFP_THISNODE, node, NULL);  
91.   
92.         /* cache_grow can reenable interrupts, then ac could change. */  
93.         ac = cpu_cache_get(cachep);  
94.         if (!x && ac->avail == 0)    /* no objects in sight? abort */  
95.             return NULL;  
96.   
97.         if (!ac->avail)      /* objects refilled by interrupt? */  
98.             goto retry;  
99.     }  
100.     ac->touched = 1;  
101.     /*返回最後一個末端的對象*/  
102.     return ac->entry[--ac->avail];  
103. }  

對於所有slab都空閒對象的情況，需要調用cache_grow()來增加cache的容量，這個函數在後面分析slab的分配時再做介紹。

相關閱讀：

Linux Slab分配器(一)--概述 http://www.linuxidc.com/Linux/2012-06/62965.htm
Linux Slab分配器(二)--初始化 http://www.linuxidc.com/Linux/2012-06/62966.htm
Linux Slab分配器(三)--創建緩存 http://www.linuxidc.com/Linux/2012-06/63109.htm
Linux Slab分配器(五)--釋放對象 http://www.linuxidc.com/Linux/2012-06/63167.htm