brk和sbrk函数

sbrk/brk： brk和sbrk主要的工作是实现虚拟内存到内存的映射.在GNUC中,内存分配是这样的:

每个进程可访问的虚拟内存空间为3G，但在程序编译时，不可能也没必要为程序分配这么大的空间，只分配并不大的数据段空间，程序中动态分配的空间就是从这一块分配的。如果这块空间不够，malloc函数族（realloc，calloc等）就调用sbrk函数将数据段的下界移动，sbrk函数在内核的管理下将虚拟地址空间映射到内存，供malloc函数使用。（参见linux内核情景分析）

sbrk不是系统调用，是C库函数。系统调用通常提供一种最小功能，而库函数通常提供比较复杂的功能。sbrk/brk是从堆中分配空间，本质是移动一个位置，向后移就是分配空间，向前移就是释放空间，sbrk用相对的整数值确定位置，如果这个整数是正数，会从当前位置向后移若干字节，如果为负数就向前若干字节。在任何情况下，返回值永远是移动之前的位置

在LINUX中sbrk(0)能返回比较精确的虚拟内存使用情况，比如squid用它来计算内存的使用！在SOLARIS/HP中sbrk(0)返回以页为单位的虚拟内存使用情况。使用sbrk(0)来返回程式当前使用了多少内存。

1. main(){  
2.        int start,end;  
3.        start = sbrk(0);  
4.        ....  
5.       malloc(***);  
6.       ....  
7.       end = sbrk(0);  
8.       printf("hello I used %d vmemory",end - start);  
9. }  

brk用绝对的地址指定移到哪个位置。

1. #include <stdio.h>   
2. #include <unistd.h>   
3. int main()  
4. {  
5.       void* p = sbrk(0);  
6.      int* p1 = p;  
7.      brk(p1+4);//分配了16个字节的空间   
8.      p1[0] = 10;  
9.      p1[1] = 20;  
10.      p1[2] = 30;  
11.      p1[3] = 40;  
12.      p1[4] = 50;  
13.      int* p2 = sbrk(4);  
14.      printf("*p2=%d\n", *p2);  
15.      brk(p1+1024);//分配整个页面的空间   
16.      brk(p1+512);//释放一半空间   
17.      brk(p1);//释放所有空间   
18. } 
    

sbrk:

 参数>0 向后移动当前位置，相当分配内存空间

 参数<0 向前移动当前位置，相当释放内存空间

 参数＝＝0 当前位置不动

 >0 <0 ==0  返回总是移动前的位置

 brk(void* ptr);

 将当前位置移动到ptr的位置

 ptr的位置一般通过sbrk(0)获取首地址，然后再计算得出、

一些sbrk实例：

[cpp]

1. #include <stdio.h>   
2. #include <unistd.h>   
3. int main()  
4. {  
5.  /*分配10个字节的空间，返回该空间的首地址*/  
6.  void* p = sbrk(12);  
7.  void* p2 = sbrk(4);  
8.  void* p3 = sbrk(4);  
9.  void* p4 = sbrk(4);  
10.  printf("p=%p\n", p);  
11.  printf("p2=%p\n", p2);  
12.  printf("p3=%p\n", p3);  
13.  printf("p4=%p\n", p4);  
14.  /*用参数为0来获取未分配空间的开始位置*/  
15.  void* p0 = sbrk(0);  
16.  printf("p0=%p\n", p0);  
17.  void* p5 = sbrk(-4);  
18.  printf("p5=%p\n", p5);  
19.  printf("pid=%d\n", getpid());  
20.  sleep(10);  
21.  /*当释放到一个页面的开始位置时，整个页面会被操作系统回收*/  
22.  sbrk(-20);  
23.    
24.  /* 
25.  int* pi = p; 
26.  *pi = 10; 
27.  *(pi+1) = 20; 
28.  *(pi+2) = 30; 
29.  *(pi+1023) = 1023; 
30.   *(pi+1024) = 1024; 
31.  */  
32.   
33.  while(1);  
34. }  
35.    
36. #include <stdio.h>   
37. #include <unistd.h>   
38. int main()  
39. {  
40.  printf("pid=%d\n", getpid());  
41.  void* p = sbrk(0);  
42.  int* p1 = sbrk(4);  
43.  sleep(10);  
44.  int* p2 = sbrk(1023*4+1);  
45.  sleep(10);  
46.  sbrk(-1);  
47.  while(1);  
48. }