ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/malloc.c

Comparing ray/src/common/malloc.c (file contents):
Revision 1.2 by greg, Tue Sep 25 18:56:37 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 */
#	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 */

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)