Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
New module: mmalloc (mapped malloc)
[simgrid.git] / src / xbt / mmalloc / mmalloc.c
1 /* Memory allocator `malloc'.
2    Copyright 1990, 1991, 1992 Free Software Foundation
3
4    Written May 1989 by Mike Haertel.
5    Heavily modified Mar 1992 by Fred Fish for mmap'd version.
6
7 The GNU C Library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Library General Public License as
9 published by the Free Software Foundation; either version 2 of the
10 License, or (at your option) any later version.
11
12 The GNU C Library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 Library General Public License for more details.
16
17 You should have received a copy of the GNU Library General Public
18 License along with the GNU C Library; see the file COPYING.LIB.  If
19 not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
21
22    The author may be reached (Email) at the address mike@ai.mit.edu,
23    or (US mail) as Mike Haertel c/o Free Software Foundation. */
24
25 #include <string.h>     /* Prototypes for memcpy, memmove, memset, etc */
26 #include <stdio.h>
27 #include "mmprivate.h"
28
29 /* Prototypes for local functions */
30
31 static int initialize PARAMS ((struct mdesc *));
32 static PTR morecore PARAMS ((struct mdesc *, size_t));
33 static PTR align PARAMS ((struct mdesc *, size_t));
34
35 /* Aligned allocation.  */
36
37 static PTR
38 align (mdp, size)
39   struct mdesc *mdp;
40   size_t size;
41 {
42   PTR result;
43   unsigned long int adj;
44
45   result = mdp -> morecore (mdp, size);
46   adj = RESIDUAL (result, BLOCKSIZE);
47   if (adj != 0)
48     {
49       adj = BLOCKSIZE - adj;
50       mdp -> morecore (mdp, adj);
51       result = (PTR) result + adj;
52     }
53   return (result);
54 }
55
56 /* Set everything up and remember that we have.  */
57
58 static int
59 initialize (mdp)
60   struct mdesc *mdp;
61 {
62   mdp -> heapsize = HEAP / BLOCKSIZE;
63   mdp -> heapinfo = (malloc_info *) 
64     align (mdp, mdp -> heapsize * sizeof (malloc_info));
65   if (mdp -> heapinfo == NULL)
66     {
67       return (0);
68     }
69   memset ((PTR)mdp -> heapinfo, 0, mdp -> heapsize * sizeof (malloc_info));
70   mdp -> heapinfo[0].free.size = 0;
71   mdp -> heapinfo[0].free.next = mdp -> heapinfo[0].free.prev = 0;
72   mdp -> heapindex = 0;
73   mdp -> heapbase = (PTR) mdp -> heapinfo;
74   mdp -> flags |= MMALLOC_INITIALIZED;
75   return (1);
76 }
77
78 /* Get neatly aligned memory, initializing or
79    growing the heap info table as necessary. */
80
81 static PTR
82 morecore (mdp, size)
83   struct mdesc *mdp;
84   size_t size;
85 {
86   PTR result;
87   malloc_info *newinfo, *oldinfo;
88   size_t newsize;
89
90   result = align (mdp, size);
91   if (result == NULL)
92     {
93       return (NULL);
94     }
95
96   /* Check if we need to grow the info table.  */
97   if ((size_t) BLOCK ((PTR) result + size) > mdp -> heapsize)
98     {
99       newsize = mdp -> heapsize;
100       while ((size_t) BLOCK ((PTR) result + size) > newsize)
101         {
102           newsize *= 2;
103         }
104       newinfo = (malloc_info *) align (mdp, newsize * sizeof (malloc_info));
105       if (newinfo == NULL)
106         {
107           mdp -> morecore (mdp, -size);
108           return (NULL);
109         }
110       memset ((PTR) newinfo, 0, newsize * sizeof (malloc_info));
111       memcpy ((PTR) newinfo, (PTR) mdp -> heapinfo,
112               mdp -> heapsize * sizeof (malloc_info));
113       oldinfo = mdp -> heapinfo;
114       newinfo[BLOCK (oldinfo)].busy.type = 0;
115       newinfo[BLOCK (oldinfo)].busy.info.size
116         = BLOCKIFY (mdp -> heapsize * sizeof (malloc_info));
117       mdp -> heapinfo = newinfo;
118       __mmalloc_free (mdp, (PTR)oldinfo);
119       mdp -> heapsize = newsize;
120     }
121
122   mdp -> heaplimit = BLOCK ((PTR) result + size);
123   return (result);
124 }
125
126 /* Allocate memory from the heap.  */
127
128 PTR
129 mmalloc (md, size)
130   PTR md;
131   size_t size;
132 {
133   struct mdesc *mdp;
134   PTR result;
135   size_t block, blocks, lastblocks, start;
136   register size_t i;
137   struct list *next;
138   register size_t log;
139
140   if (size == 0)
141     {
142       return (NULL);
143     }
144
145   mdp = MD_TO_MDP (md);
146       
147   if (mdp -> mmalloc_hook != NULL)
148     {
149       return ((*mdp -> mmalloc_hook) (md, size));
150     }
151
152   if (!(mdp -> flags & MMALLOC_INITIALIZED))
153     {
154       if (!initialize (mdp))
155         {
156           return (NULL);
157         }
158     }
159
160   if (size < sizeof (struct list))
161     {
162       size = sizeof (struct list);
163     }
164
165   /* Determine the allocation policy based on the request size.  */
166   if (size <= BLOCKSIZE / 2)
167     {
168       /* Small allocation to receive a fragment of a block.
169          Determine the logarithm to base two of the fragment size. */
170       log = 1;
171       --size;
172       while ((size /= 2) != 0)
173         {
174           ++log;
175         }
176
177       /* Look in the fragment lists for a
178          free fragment of the desired size. */
179       next = mdp -> fraghead[log].next;
180       if (next != NULL)
181         {
182           /* There are free fragments of this size.
183              Pop a fragment out of the fragment list and return it.
184              Update the block's nfree and first counters. */
185           result = (PTR) next;
186           next -> prev -> next = next -> next;
187           if (next -> next != NULL)
188             {
189               next -> next -> prev = next -> prev;
190             }
191           block = BLOCK (result);
192           if (--mdp -> heapinfo[block].busy.info.frag.nfree != 0)
193             {
194               mdp -> heapinfo[block].busy.info.frag.first =
195                 RESIDUAL (next -> next, BLOCKSIZE) >> log;
196             }
197
198           /* Update the statistics.  */
199           mdp -> heapstats.chunks_used++;
200           mdp -> heapstats.bytes_used += 1 << log;
201           mdp -> heapstats.chunks_free--;
202           mdp -> heapstats.bytes_free -= 1 << log;
203         }
204       else
205         {
206           /* No free fragments of the desired size, so get a new block
207              and break it into fragments, returning the first.  */
208           result = mmalloc (md, BLOCKSIZE);
209           if (result == NULL)
210             {
211               return (NULL);
212             }
213
214           /* Link all fragments but the first into the free list.  */
215           for (i = 1; i < (size_t) (BLOCKSIZE >> log); ++i)
216             {
217               next = (struct list *) ((PTR) result + (i << log));
218               next -> next = mdp -> fraghead[log].next;
219               next -> prev = &mdp -> fraghead[log];
220               next -> prev -> next = next;
221               if (next -> next != NULL)
222                 {
223                   next -> next -> prev = next;
224                 }
225             }
226
227           /* Initialize the nfree and first counters for this block.  */
228           block = BLOCK (result);
229           mdp -> heapinfo[block].busy.type = log;
230           mdp -> heapinfo[block].busy.info.frag.nfree = i - 1;
231           mdp -> heapinfo[block].busy.info.frag.first = i - 1;
232
233           mdp -> heapstats.chunks_free += (BLOCKSIZE >> log) - 1;
234           mdp -> heapstats.bytes_free += BLOCKSIZE - (1 << log);
235           mdp -> heapstats.bytes_used -= BLOCKSIZE - (1 << log);
236         }
237     }
238   else
239     {
240       /* Large allocation to receive one or more blocks.
241          Search the free list in a circle starting at the last place visited.
242          If we loop completely around without finding a large enough
243          space we will have to get more memory from the system.  */
244       blocks = BLOCKIFY(size);
245       start = block = MALLOC_SEARCH_START;
246       while (mdp -> heapinfo[block].free.size < blocks)
247         {
248           block = mdp -> heapinfo[block].free.next;
249           if (block == start)
250             {
251               /* Need to get more from the system.  Check to see if
252                  the new core will be contiguous with the final free
253                  block; if so we don't need to get as much.  */
254               block = mdp -> heapinfo[0].free.prev;
255               lastblocks = mdp -> heapinfo[block].free.size;
256               if (mdp -> heaplimit != 0 &&
257                   block + lastblocks == mdp -> heaplimit &&
258                   mdp -> morecore (mdp, 0) == ADDRESS(block + lastblocks) &&
259                   (morecore (mdp, (blocks - lastblocks) * BLOCKSIZE)) != NULL)
260                 {
261                   /* Which block we are extending (the `final free
262                      block' referred to above) might have changed, if
263                      it got combined with a freed info table.  */
264                   block = mdp -> heapinfo[0].free.prev;
265
266                   mdp -> heapinfo[block].free.size += (blocks - lastblocks);
267                   mdp -> heapstats.bytes_free +=
268                       (blocks - lastblocks) * BLOCKSIZE;
269                   continue;
270                 }
271               result = morecore(mdp, blocks * BLOCKSIZE);
272               if (result == NULL)
273                 {
274                   return (NULL);
275                 }
276               block = BLOCK (result);
277               mdp -> heapinfo[block].busy.type = 0;
278               mdp -> heapinfo[block].busy.info.size = blocks;
279               mdp -> heapstats.chunks_used++;
280               mdp -> heapstats.bytes_used += blocks * BLOCKSIZE;
281               return (result);
282             }
283         }
284
285       /* At this point we have found a suitable free list entry.
286          Figure out how to remove what we need from the list. */
287       result = ADDRESS(block);
288       if (mdp -> heapinfo[block].free.size > blocks)
289         {
290           /* The block we found has a bit left over,
291              so relink the tail end back into the free list. */
292           mdp -> heapinfo[block + blocks].free.size
293             = mdp -> heapinfo[block].free.size - blocks;
294           mdp -> heapinfo[block + blocks].free.next
295             = mdp -> heapinfo[block].free.next;
296           mdp -> heapinfo[block + blocks].free.prev
297             = mdp -> heapinfo[block].free.prev;
298           mdp -> heapinfo[mdp -> heapinfo[block].free.prev].free.next
299             = mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.prev
300               = mdp -> heapindex = block + blocks;
301         }
302       else
303         {
304           /* The block exactly matches our requirements,
305              so just remove it from the list. */
306           mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.prev
307             = mdp -> heapinfo[block].free.prev;
308           mdp -> heapinfo[mdp -> heapinfo[block].free.prev].free.next
309             = mdp -> heapindex = mdp -> heapinfo[block].free.next;
310           mdp -> heapstats.chunks_free--;
311         }
312
313       mdp -> heapinfo[block].busy.type = 0;
314       mdp -> heapinfo[block].busy.info.size = blocks;
315       mdp -> heapstats.chunks_used++;
316       mdp -> heapstats.bytes_used += blocks * BLOCKSIZE;
317       mdp -> heapstats.bytes_free -= blocks * BLOCKSIZE;
318     }
319
320   return (result);
321 }
322
323 /* When using this package, provide a version of malloc/realloc/free built
324    on top of it, so that if we use the default sbrk() region we will not
325    collide with another malloc package trying to do the same thing, if
326    the application contains any "hidden" calls to malloc/realloc/free (such
327    as inside a system library). */
328
329 PTR
330 malloc (size)
331   size_t size;
332 {
333   PTR result;
334   result = mmalloc ((PTR) NULL, size);
335   return (result);
336 }