复合内存管理系统

我不是女神ヾ 2022-08-06 05:28 203阅读 0赞

1.  Light TCP Proxy开发日志(1) [http://blog.chinaunix.net/uid-23629988-id-3390203.html][http_blog.chinaunix.net_uid-23629988-id-3390203.html]
2.  Light TCP Proxy开发日志(2)之伙伴内存管理系统 [http://blog.chinaunix.net/space.php?uid=24774106&do=blog&id=3395431][http_blog.chinaunix.net_space.php_uid_24774106_do_blog_id_3395431]
3.  Light TCP Proxy开发日志(3)之复合内存管理系统 [http://blog.chinaunix.net/uid-24774106-id-3419831.html][http_blog.chinaunix.net_uid-24774106-id-3419831.html]

本月初的时候实现了伙伴**内存管理系统**，这个作品我其实是很喜欢的，因为大约一年的这个时候，我在工作中曾有这种实现伙伴**内存系统**的需求，但是因为太底层，领导不同意动当时的**内存管理系统**，当时我也没有付诸行动。伙伴**管理系统**其实是很高效的，而且灵活，对**内存**的浪费也是有限的。  
  
    呵呵GFree\_Wind从需求出发，认为伙伴不能满足Light TCP Proxy的需求，因为伙伴虽然优美，但是没有任何先验的知识。 我们的Light TCP Proxy某些长度的**内存**分配会特别的频繁，这些个长度是1792，1024，512，256，128，64，其他的长度出现的比较少，GFree\_Wind希望对这些长度的**内存**分配有更高效的。  
  
    说来惭愧，最近心情不佳，所以一直没有做这个，愧对GFree\_Wind的信任。昨天下班后搞了搞，搞出了一个基本的实现：  
  
    1 为六种特殊长度的**内存**分配，建立UB **内存**池。  
    2 如果用户分配六种特殊长度中的某一种，先尝试UB**内存**池分配，失败的情况下去buddy分配。  
    3 free的时候首先判断是UB分配的还是buddy分配的。  
  
    这个多了个UB**内存系统**，UB是啥？单元块。 1792长度的UB，分配10240个，1024长度的UB分配10240个，依此类推。10K个UB要**管理**，不然怎么知道那个已经分配出去了，那个UB还是free的呢。 采用最原始的方法，双向链表freelist。如果是free的，那么挂在freelist上。如果已经分配出去了，从freelist中删除。用户试图分配，只需要将freelist的next摘下来，就可以用了。

1.  typedef struct UB\{  
    
2.      struct list\_head head;  
    
3.      int idx;  
    
4.  \}UB;  
    
5.    
    
6.  typedef struct UB\_pool  
    
7.  \{  
    
8.      struct list\_head freelist;  
    
9.      pthread\_mutex\_t fl\_lock;  
    
10.     int UB\_size;  
    
11.     char\* begin;  
    
12.     char\* end;  
    
13.     int total\_num;  
    
14.     int free\_num;  
    
15.   
    
16. \}UB\_pool;  
    
17.   
    
18.   
    
19. int UB\_size\[UB\_TYPES\] = \{1792,1024,512,256,128,64\} ;  
    
20. int UB\_num\[UB\_TYPES\] = \{10240,10240,10240,10240,10240,10240\};  
    
21. struct UB\_pool g\_UBPool\[UB\_TYPES\] = \{0\};  
    
22. struct UB\* p\_UB\[UB\_TYPES\] ;

先看下UB**内存**池的初始化：

1.  int init\_UB\_pool()  
    
2.  \{  
    
3.      int i = 0;  
    
4.      int j = 0;  
    
5.      memset(g\_UBPool,0,UB\_TYPES\*sizeof(struct UB\_pool));  
    
6.      memset(p\_UB,0,UB\_TYPES\*sizeof(struct UB\*));  
    
7.      for(i = 0;i<UB\_TYPES;i++)  
    
8.      \{  
    
9.           INIT\_LIST\_HEAD(&(g\_UBPool\[i\].freelist));  
    
10.          pthread\_mutex\_init(&g\_UBPool\[i\].fl\_lock,NULL);  
    
11.          g\_UBPool\[i\].UB\_size = UB\_size\[i\];  
    
12.          g\_UBPool\[i\].total\_num = UB\_num\[i\];  
    
13.          g\_UBPool\[i\].free\_num = UB\_num\[i\];  
    
14.          g\_UBPool\[i\].begin = (char\*)malloc(UB\_size\[i\]\*UB\_num\[i\]);   
    
15.          if(g\_UBPool\[i\].begin == NULL)  
    
16.          \{  
    
17.              goto err\_out;  
    
18.          \}  
    
19.          g\_UBPool\[i\].end = g\_UBPool\[i\].begin + UB\_size\[i\]\*UB\_num\[i\];  
    
20.          p\_UB\[i\] = (struct UB\*) malloc(UB\_num\[i\]\*sizeof(UB));  
    
21.          if(p\_UB\[i\] == NULL)  
    
22.          \{  
    
23.              goto err\_out;  
    
24.          \}  
    
25.   
    
26.          for(j = 0;j<UB\_num\[i\]; j++)  
    
27.          \{  
    
28.              list\_add\_tail(&(p\_UB\[i\]\[j\].head),&g\_UBPool\[i\].freelist);  
    
29.              p\_UB\[i\]\[j\].idx = j;  
    
30.          \}  
    
31.     \}  
    
32.     return 0;  
    
33. err\_out:  
    
34.     for(;i >= 0;i--)  
    
35.     \{  
    
36.         if(p\_UB\[i\])  
    
37.             free(p\_UB\[i\]);  
    
38.         if(g\_UBPool\[i\].begin)  
    
39.             free(g\_UBPool\[i\].begin);  
    
40.     \}  
    
41.     return -1;  
    
42. \}

六种型号，为每种长度分配一个**内存**池。 begin 和end是批发来的**内存**的起始位置和终止位置，将来free的时候，要靠这个来判断要释放的**内存**落在那个UB**内存**池内。分配10240个UB来**管理**10240个**内存**块，将他们都挂在freelist上，表示都可以用来分配。  
  
  
    看下malloc的逻辑。按照方案先判断是否是特殊长度的**内存**，是，走UB，否则走buddy。 如果UB失败了话，可以继续去buddy分配，buddy失败了，才是真的失败了。

1.  void \* MALLOC(int size)  
    
2.  \{  
    
3.      int idx = -1;  
    
4.      int j;  
    
5.      for(j = 0 ;j < UB\_TYPES;j++)  
    
6.      \{  
    
7.          if(size == UB\_size\[j\])  
    
8.          \{  
    
9.              idx = j;  
    
10.             break;  
    
11.         \}  
    
12.     \}  
    
13.     if(idx == -1)  
    
14.     \{  
    
15.         return (void \*) buddy\_malloc(g\_buddypool,size);  
    
16.     \}  
    
17.     else  
    
18.     \{  
    
19.         void\* ret\_ptr = UB\_malloc(size,idx);  
    
20.         if(ret\_ptr == NULL)  
    
21.         \{  
    
22.             return buddy\_malloc(g\_buddypool,size);  
    
23.         \}   
    
24.         else  
    
25.             return ret\_ptr;  
    
26.     \}  
    
27. \}

buddy**内存系统**上一篇博文讲过了，我们看下UB\_malloc

1.  void\* UB\_malloc(int size,int idx)  
    
2.  \{  
    
3.      assert(idx >= 0 && idx < UB\_TYPES);  
    
4.        
    
5.      pthread\_mutex\_lock(&g\_UBPool\[idx\].fl\_lock);  
    
6.        
    
7.      if(list\_empty(&(g\_UBPool\[idx\].freelist)))  
    
8.      \{  
    
9.          return NULL;  
    
10.     \}  
    
11.   
    
12.     struct UB\* ub =(UB\*) (g\_UBPool\[idx\].freelist.next);  
    
13.     list\_del\_init((g\_UBPool\[idx\].freelist.next));  
    
14.     g\_UBPool\[idx\].free\_num--;  
    
15.   
    
16.     pthread\_mutex\_unlock(&g\_UBPool\[idx\].fl\_lock);  
    
17.       
    
18.     int j = ub->idx;  
    
19.     assert(j >= 0 && j <UB\_num\[idx\]);  
    
20.   
    
21.     return g\_UBPool\[idx\].begin+j\*g\_UBPool\[idx\].UB\_size;  
    
22.   
    
23. \}

没啥好说的，UB里面有个idx，表示的是，我是该长度的第几个**内存**块，加上起始地址begin,就能确定出return的指针。  
  
     
    因为我们有两个**内存管理系统**，所以free的时候需要判断是那个**内存管理系统**分配的。办法就是看落在那个UB池的范围之内。如果都不是，就是buddy分配的。

1.  void FREE(void\* ptr)  
    
2.  \{  
    
3.      int idx = -1;  
    
4.      int j = 0;   
    
5.    
    
6.      assert(ptr != NULL);  
    
7.    
    
8.      for(j = 0;j<UB\_TYPES;j++)  
    
9.      \{  
    
10.         if((unsigned long)ptr >= (unsigned long)g\_UBPool\[j\].begin && (unsigned long)ptr < (unsigned long )g\_UBPool\[j\].end )  
    
11.         \{  
    
12.             idx = j;  
    
13.             break;  
    
14.         \}  
    
15.     \}  
    
16.     if(idx == -1)  
    
17.     \{  
    
18.         buddy\_free(g\_buddypool,ptr);  
    
19.     \}  
    
20.     else  
    
21.     \{  
    
22.         UB\_free(ptr,idx);  
    
23.     \}  
    
24. \}

1.  void UB\_free(void\* ptr,int idx)  
    
2.  \{  
    
3.      assert(idx >=0 && idx < UB\_TYPES);
4.      assert(((unsigned long)ptr -(unsigned long) g\_UBPool\[idx\].begin)%g\_UBPool\[idx\].UB\_size == 0);  
    
5.    
    
6.      int j = ((unsigned long)ptr -(unsigned long) g\_UBPool\[idx\].begin)/g\_UBPool\[idx\].UB\_size;  
    
7.      assert(j < UB\_num\[idx\]);  
    
8.    
    
9.      struct UB\* ub =&(p\_UB\[idx\]\[j\]);  
    
10.     pthread\_mutex\_lock(&g\_UBPool\[idx\].fl\_lock);  
    
11.     list\_add\_tail(&(ub->head),&g\_UBPool\[idx\].freelist);  
    
12.     g\_UBPool\[idx\].free\_num++;  
    
13.     pthread\_mutex\_unlock(&g\_UBPool\[idx\].fl\_lock);  
    
14.   
    
15. \}

代码中有很多的assert，为了就是异常情况出现的时候，能够及时的探知。另外提供了一个UB\_check的函数，来检查freelist的链表UB的个数与free\_num是否一致。

1.  int UB\_check()  
    
2.  \{  
    
3.    
    
4.      int count;  
    
5.      struct list\_head\* next = NULL;  
    
6.      int idx,j;  
    
7.      for(idx = 0; idx< UB\_TYPES;idx++)  
    
8.      \{  
    
9.          count = 0;  
    
10.           
    
11.         pthread\_mutex\_lock(&g\_UBPool\[idx\].fl\_lock);  
    
12.   
    
13.         next = g\_UBPool\[idx\].freelist.next;  
    
14.         while(next != &(g\_UBPool\[idx\].freelist))  
    
15.         \{  
    
16.             count++;  
    
17.             next = next->next;  
    
18.         \}  
    
19.   
    
20.         pthread\_mutex\_unlock(&g\_UBPool\[idx\].fl\_lock);  
    
21.         if(count != g\_UBPool\[idx\].free\_num)  
    
22.         \{  
    
23.            fprintf(stderr,"UB pool corrupted ,idx = %d\\n,free\_num = %d, but ub in free list is %d\\n",idx,g\_UBPool\[idx\].free\_num,count);  
    
24.         \}  
    
25.     \}  
    
26. \}

最后是测试用例的编写。比较长，我就不贴了。对代码感兴趣的筒子可以去https://github.com/manuscola/MM下down一份代码，自己慢慢看。

很不错的伙伴内存管理系统方案。

[http_blog.chinaunix.net_uid-23629988-id-3390203.html]: http://blog.chinaunix.net/uid-23629988-id-3390203.html
[http_blog.chinaunix.net_space.php_uid_24774106_do_blog_id_3395431]: http://blog.chinaunix.net/space.php?uid=24774106&do=blog&id=3395431
[http_blog.chinaunix.net_uid-24774106-id-3419831.html]: http://blog.chinaunix.net/uid-24774106-id-3419831.html