ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/malloc.c
(Generate patch)

Comparing ray/src/common/malloc.c (file contents):
Revision 1.3 by greg, Wed Sep 26 06:23:10 1990 UTC vs.
Revision 1.4 by greg, Wed Sep 26 08:26:11 1990 UTC

# Line 7 | Line 7 | static char SCCSid[] = "$SunId$ LBL";
7   /*
8   * Fast malloc for memory hogs and VM environments.
9   * Performs a minimum of searching through free lists.
10 – * bmalloc() doesn't keep track of free lists -- it's basically
11 – *      just a buffered call to sbrk(2).  However, bmalloc will
12 – *      call mscrounge() if sbrk fails.
13 – * bfree() puts memory from any source into malloc free lists.
10   * malloc(), realloc() and free() use buckets
11   *      containing blocks in powers of two, similar to CIT routines.
12 + * bfree() puts memory from any source into malloc free lists.
13 + * bmalloc() doesn't keep track of free lists -- it's usually
14 + *      just a buffered call to sbrk(2).  However, bmalloc will
15 + *      call mscrounge() if sbrk fails.
16   * mscrounge() returns whatever memory it can find to satisfy the
17   *      request along with the number of bytes (modified).
18   *
# Line 45 | Line 45 | static M_HEAD  *free_list[NBUCKETS];
45  
46  
47   char *
48 < mscrounge(np)           /* search free lists trying to satisfy request */
48 > mscrounge(np)           /* search free lists to satisfy request */
49   register unsigned       *np;
50   {
51          char    *p;
# Line 96 | Line 96 | register unsigned  n;
96                  } else
97                          thisamnt = amnt;
98                  p = sbrk(thisamnt);
99 <                if ((int)p == -1) {                     /* uh-oh */
99 >                if ((int)p == -1) {                     /* uh-oh, ENOMEM */
100                          thisamnt = n;                   /* search free lists */
101                          p = mscrounge(&thisamnt);
102                          if (p == NULL)                  /* we're really out */
103                                  return(NULL);
104                  }
105                  if (p != bpos+nrem) {                   /* not an increment */
106 <                        bfree(bpos, nrem);
106 >                        bfree(bpos, nrem);              /* free what we have */
107                          bpos = p;
108                          nrem = thisamnt;
109 <                } else
109 >                } else                                  /* otherwise tack on */
110                          nrem += thisamnt;
111          }
112          p = bpos;
# Line 122 | Line 122 | register unsigned  n;
122   {
123          register int    bucket;
124          register unsigned       bsiz;
125 <                                        /* find largest bucket */
126 <        bucket = 0;
127 <        for (bsiz = 1; bsiz+sizeof(M_HEAD) <= n; bsiz <<= 1)
128 <                bucket++;
129 <        while (bucket > FIRSTBUCKET) {
130 <                bsiz >>= 1;
131 <                bucket--;
132 <                if (n < bsiz+sizeof(M_HEAD))    /* nothing for this bucket */
133 <                        continue;
134 <                ((M_HEAD *)p)->next = free_list[bucket];
135 <                free_list[bucket] = (M_HEAD *)p;
136 <                p += bsiz+sizeof(M_HEAD);
137 <                n -= bsiz+sizeof(M_HEAD);
125 >                                        /* align pointer */
126 >        bsiz = BYTES_WORD - ((unsigned)p&~(BYTES_WORD-1));
127 >        if (bsiz < BYTES_WORD) {
128 >                p += bsiz;
129 >                n -= bsiz;
130          }
131 +                                        /* fill big buckets first */
132 +        for (bucket = NBUCKETS-1, bsiz = 1<<(NBUCKETS-1);
133 +                        bucket >= FIRSTBUCKET; bucket--, bsiz >>= 1)
134 +                if (n >= bsiz+sizeof(M_HEAD)) {
135 +                        ((M_HEAD *)p)->next = free_list[bucket];
136 +                        free_list[bucket] = (M_HEAD *)p;
137 +                        p += bsiz+sizeof(M_HEAD);
138 +                        n -= bsiz+sizeof(M_HEAD);
139 +                }
140   }
141  
142  
# Line 153 | Line 154 | unsigned       n;
154          bucket = FIRSTBUCKET;
155          for (bsiz = 1<<FIRSTBUCKET; bsiz < n; bsiz <<= 1)
156                  bucket++;
157 <        if (free_list[bucket] == NULL) {
157 >        if (free_list[bucket] == NULL) {        /* need more core */
158                  mp = (M_HEAD *)bmalloc(bsiz+sizeof(M_HEAD));
159                  if (mp == NULL)
160                          return(NULL);
161 <        } else {
161 >        } else {                                /* got it */
162                  mp = free_list[bucket];
163                  free_list[bucket] = mp->next;
164          }
165 <        mp->bucket = bucket;
165 >        mp->bucket = bucket;                    /* tag block */
166          return((char *)(mp+1));
167   }
168  
# Line 171 | Line 172 | realloc(op, n)                 /* reallocate memory using malloc() *
172   char    *op;
173   unsigned        n;
174   {
175 +        extern char     *memcpy();
176          register char   *p;
177          register unsigned       on;
178  
179 <        if (op != NULL)
180 <                on = 1 << ((M_HEAD *)op-1)->bucket;
181 <        else
182 <                on = 0;
183 <        if (n <= on && n > on>>1)
182 <                return(op);             /* same bucket */
183 <        p = malloc(n);
184 <        if (p != NULL)
179 >        free(op);                       /* free it first */
180 >        p = malloc(n);                  /* p==op if same bucket */
181 >        if (p == NULL)
182 >                return(NULL);
183 >        if (p != op)                    /* different bucket, do copy */
184   #ifdef  BSD
185                  bcopy(op, p, n>on ? on : n);
186   #else
187                  (void)memcpy(p, op, n>on ? on : n);
188   #endif
190 –        free(op);
189          return(p);
190   }
191  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines