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.1 by greg, Tue Sep 25 17:14:04 1990 UTC vs.
Revision 1.3 by greg, Wed Sep 26 06:23:10 1990 UTC

# Line 8 | Line 8 | static char SCCSid[] = "$SunId$ LBL";
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().
12 < * bfree() puts memory from any source into malloc() free lists.
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.
14   * malloc(), realloc() and free() use buckets
15   *      containing blocks in powers of two, similar to CIT routines.
16 + * mscrounge() returns whatever memory it can find to satisfy the
17 + *      request along with the number of bytes (modified).
18   *
19   *      Greg Ward       Lawrence Berkeley Laboratory
20   */
# Line 23 | Line 26 | static char SCCSid[] = "$SunId$ LBL";
26   #endif
27   #define  BYTES_WORD     sizeof(ALIGN)
28  
29 + #define  MAXINCR        (1<<18)                 /* largest sbrk(2) increment */
30 +
31   #ifdef  NOVMEM
32   #define  getpagesize()  BYTES_WORD
33   #endif
29 –
34                                          /* malloc free lists */
35   typedef union m_head {
36          union m_head    *next;
# Line 41 | Line 45 | static M_HEAD  *free_list[NBUCKETS];
45  
46  
47   char *
48 + mscrounge(np)           /* search free lists trying to satisfy request */
49 + register unsigned       *np;
50 + {
51 +        char    *p;
52 +        register int    bucket;
53 +        register unsigned       bsiz;
54 +
55 +        for (bucket = FIRSTBUCKET, bsiz = 1<<FIRSTBUCKET;
56 +                        bucket < NBUCKETS; bucket++, bsiz <<= 1)
57 +                if (free_list[bucket] != NULL && bsiz+sizeof(M_HEAD) >= *np) {
58 +                        *np = bsiz+sizeof(M_HEAD);
59 +                        p = (char *)free_list[bucket];
60 +                        free_list[bucket] = free_list[bucket]->next;
61 +                        return(p);
62 +                }
63 +        *np = 0;
64 +        return(NULL);
65 + }
66 +
67 +
68 + char *
69   bmalloc(n)              /* allocate a block of n bytes, sans header */
70   register unsigned  n;
71   {
72          extern char  *sbrk();
73 <        static int  pagesz = 0;
74 <        static int  amnt;
73 >        static unsigned  pagesz = 0;
74 >        static unsigned  amnt;
75          static char  *bpos;
76 <        static int  nrem;
76 >        static unsigned  nrem;
77 >        unsigned  thisamnt;
78          register char   *p;
79  
80          if (pagesz == 0) {                              /* initialize */
81 <                amnt = pagesz = getpagesize();
81 >                pagesz = amnt = getpagesize();
82                  nrem = (int)sbrk(0);                    /* page align break */
83                  nrem = pagesz - (nrem&(pagesz-1));
84                  bpos = sbrk(nrem);                      /* word aligned! */
# Line 63 | Line 89 | register unsigned  n;
89          n = (n+(BYTES_WORD-1))&~(BYTES_WORD-1);         /* word align rqst. */
90  
91          if (n > nrem) {                                 /* need more core */
92 <                if (n > amnt)                   /* increase amount */
93 <                        amnt = (n+(pagesz-1))&~(pagesz-1);
94 <                p = sbrk(amnt);
95 <                if ((int)p == -1)
96 <                        return(NULL);
97 <                if (p != bpos+nrem) {           /* someone called sbrk()! */
92 >                if (n > amnt) {                         /* big chunk */
93 >                        thisamnt = (n+(pagesz-1))&~(pagesz-1);
94 >                        if (thisamnt <= MAXINCR)        /* increase amnt */
95 >                                amnt = thisamnt;
96 >                } else
97 >                        thisamnt = amnt;
98 >                p = sbrk(thisamnt);
99 >                if ((int)p == -1) {                     /* uh-oh */
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);
107                          bpos = p;
108 <                        nrem = amnt;
108 >                        nrem = thisamnt;
109                  } else
110 <                        nrem += amnt;
110 >                        nrem += thisamnt;
111          }
112          p = bpos;
113          bpos += n;                                      /* advance */
# Line 83 | Line 117 | register unsigned  n;
117  
118  
119   bfree(p, n)                     /* free n bytes of random memory */
120 < char  *p;
121 < unsigned  n;
120 > register char  *p;
121 > register unsigned  n;
122   {
89 –        register M_HEAD *mp;
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++;
96 –        mp = (M_HEAD *)p;
129          while (bucket > FIRSTBUCKET) {
130                  bsiz >>= 1;
131                  bucket--;
132                  if (n < bsiz+sizeof(M_HEAD))    /* nothing for this bucket */
133                          continue;
134 <                mp->next = free_list[bucket];
135 <                free_list[bucket] = mp;
136 <                (char *)mp += bsiz+sizeof(M_HEAD);
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);
138          }
139   }
# Line 115 | Line 147 | unsigned       n;
147          register int    bucket;
148          register unsigned       bsiz;
149  
150 +        if (n == 0)
151 +                return(NULL);
152 +                                        /* find first bucket that fits */
153          bucket = FIRSTBUCKET;
154          for (bsiz = 1<<FIRSTBUCKET; bsiz < n; bsiz <<= 1)
155                  bucket++;
# Line 146 | Line 181 | unsigned       n;
181          if (n <= on && n > on>>1)
182                  return(op);             /* same bucket */
183          p = malloc(n);
184 <        if (p == NULL)
150 <                return(NULL);
184 >        if (p != NULL)
185   #ifdef  BSD
186 <        bcopy(op, p, n>on ? on : n);
186 >                bcopy(op, p, n>on ? on : n);
187   #else
188 <        (void)memcpy(p, op, n>on ? on : n);
188 >                (void)memcpy(p, op, n>on ? on : n);
189   #endif
190          free(op);
191          return(p);
# Line 164 | Line 198 | char   *p;
198          register M_HEAD *mp;
199          register int    bucket;
200  
201 +        if (p == NULL)
202 +                return;
203          mp = (M_HEAD *)p - 1;
204          bucket = mp->bucket;
205          mp->next = free_list[bucket];

Diff Legend

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