丹尼斯.里奇的c语言教程malloc例子两个疑问

fedorayang

1. /**
   
2. QUESTION1: bp < p->s.ptr 什么时候出现,插入到哪里?
   
3. ANSWER1:
   
4. 
   
5. QUESTION2: join to lower, freep好像指向的位置比其他情况不一样,这会导致什么问题,会导致morecore多一次调用吗.
   
6. ANSWER2: 会导致循环开始位置不一样,不会导致morecore多一次调用,假如只能使用这次释放的内存块的话,
   
7.                  会循环过去,指到freep位置时,大小满足了,就拿到数据返回.
   
8.                  
   
9. QUESTION3: &base地址在ubuntu64bit上测试确实比sbrk获得的地址低,这依靠了系统相关特性,假如在相反的平台上程序是否可以正常运行.       
   
10. ANSWER3:                
    
11. */
    
12. #include <stdio.h>
    
13. 
    
14. typedef long Align; /* for alignment to long boundary */
    
15. union header { /* block header */
    
16.         struct {
    
17.                 union header *ptr; /* next block if on free list */
    
18.                 unsigned size; /* size of this block */
    
19.         } s;
    
20.         Align x; /* force alignment of blocks */
    
21. };
    
22. typedef union header Header;
    
23. 
    
24. static Header base; /* empty list to get started */
    
25. static Header *freep = NULL; /* start of free list */
    
26. 
    
27. /* free: put block ap(AccessPoint) in free list */
    
28. void free(void *ap)
    
29. {
    
30.         Header *bp, *p;
    
31.         bp = (Header *)ap - 1; /* point to block header */
    
32.         for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
    
33.         {               
    
34.                 if (p >= p->s.ptr && (bp > p || bp < p->s.ptr)) /* QUESTION1 */
    
35.                 {
    
36.                         break; /* freed block at start or end of arena */
    
37.                 }       
    
38.         }
    
39.                
    
40.         if (bp + bp->s.size == p->s.ptr) { /* join to upper(next) nbr */
    
41.                 bp->s.size += p->s.ptr->s.size;
    
42.                 bp->s.ptr = p->s.ptr->s.ptr;
    
43.         }
    
44.         else
    
45.                 bp->s.ptr = p->s.ptr;
    
46.        
    
47.         if (p + p->s.size == bp) { /* join to lower(prev) nbr */
    
48.                 p->s.size += bp->s.size;/* QUESTION2 */
    
49.                 p->s.ptr = bp->s.ptr;
    
50.         }
    
51.         else
    
52.                 p->s.ptr = bp;
    
53.        
    
54.         freep = p;
    
55. }
    
56. 
    
57. #define NALLOC 1024 /* minimum #units to request */
    
58. /* morecore: ask system for more memory */
    
59. static Header *morecore(unsigned nu)
    
60. {
    
61.         char *cp, *sbrk(int);
    
62.         Header *up;
    
63.         if (nu < NALLOC)
    
64.                 nu = NALLOC;       
    
65.         cp = sbrk(nu * sizeof(Header));
    
66.         if (cp == (char *)-1) /* no space at all */
    
67.                 return NULL;
    
68.         up = (Header *)cp;
    
69.         up->s.size = nu;
    
70.         free((void *)(up + 1));
    
71.         return freep;
    
72. }
    
73. 
    
74. /* malloc: general-purpose storage allocator */
    
75. void *malloc(unsigned nbytes)
    
76. {
    
77.         Header *p, *prevp;
    
78.         Header *moreroce(unsigned);
    
79.         unsigned nunits;
    
80.         nunits = (nbytes + sizeof(Header) - 1) / sizeof(Header) + 1;
    
81. 
    
82.         if ((prevp = freep) == NULL) { /* no free list yet */
    
83.                 base.s.ptr = freep = prevp = &base; /* QUESTION3 */
    
84.                 base.s.size = 0;
    
85.         }
    
86.         for (p = prevp->s.ptr;; prevp = p, p = p->s.ptr) {
    
87.                 if (p->s.size >= nunits) { /* big enough */
    
88.                         if (p->s.size == nunits) /* exactly */
    
89.                         {
    
90.                                 prevp->s.ptr = p->s.ptr;                       
    
91.                         }
    
92.                         else { /* allocate tail end */
    
93.                                 p->s.size -= nunits;
    
94.                                 p += p->s.size;
    
95.                                 p->s.size = nunits;                       
    
96.                         }
    
97.                         freep = prevp;
    
98.                        
    
99.                         return (void *)(p + 1);
    
100.                 }
     
101.                 if (p == freep) /* wrapped around free list */
     
102.                         if ((p = morecore(nunits)) == NULL)
     
103.                                 return NULL; /* none left */
     
104.         }
     
105. }
     
106. 
     
107. 
     
108. int main(int argc, char* argv[])
     
109. {
     
110.         char* p0=NULL;
     
111.         char* p1=NULL;
     
112.         char* p2=NULL;
     
113.         char* p3=NULL;
     
114.         char* p4=NULL;       
     
115.                
     
116.         p0=malloc(4096);
     
117.         if(NULL!=p0)
     
118.         {               
     
119.                 free(p0);       
     
120.         }
     
121.        
     
122.         p1=malloc(1024);
     
123.         p2=malloc(1024);
     
124.         p3=malloc(1024);
     
125.         p4=malloc(1024);       
     
126.        
     
127.         if(NULL!=p1)
     
128.         {               
     
129.                 free(p1);               
     
130.         }
     
131.        
     
132.         if(NULL!=p2)
     
133.         {               
     
134.                 free(p2);               
     
135.         }
     
136. 
     
137.         if(NULL!=p3)
     
138.         {               
     
139.                 free(p3);       
     
140.         }
     
141. 
     
142.         if(NULL!=p4)
     
143.         {
     
144.                 free(p4);       
     
145.         }       
     
146.         return 0;
     
147. }
     

复制代码