src/common/bmalloc.c

/* Copyright (c) 1991 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 * Bmalloc provides basic memory allocation without overhead (no free lists).
 * Use only to take the load off of malloc for all those
 * piddling little requests that you never expect to free.
 * Bmalloc defers to malloc for big requests.
 * Bfree should hand memory to bmalloc, but it usually fails here.
 */

#define  NULL           0

#ifndef  MBLKSIZ
#define  MBLKSIZ        16376           /* size of memory allocation block */
#endif
#define  WASTEFRAC      12              /* don't waste more than a fraction */
#ifndef  ALIGN
#define  ALIGN          int             /* type for alignment */
#endif
#define  BYTES_WORD     sizeof(ALIGN)

extern char  *malloc();

static char  *bposition = NULL;
static unsigned  nremain = 0;


char *
bmalloc(n)              /* allocate a block of n bytes */
register unsigned  n;
{
        if (n > nremain && (n > MBLKSIZ || nremain > MBLKSIZ/WASTEFRAC))
                return(malloc(n));                      /* too big */

        n = (n+(BYTES_WORD-1))&~(BYTES_WORD-1);         /* word align */

        if (n > nremain && (bposition = malloc(nremain = MBLKSIZ)) == NULL) {
                nremain = 0;
                return(NULL);
        }
        bposition += n;
        nremain -= n;
        return(bposition - n);
}


bfree(p, n)                     /* free random memory */
register char   *p;
register unsigned       n;
{
        register unsigned       bsiz;
                                        /* check alignment */
        bsiz = BYTES_WORD - ((unsigned)p&(BYTES_WORD-1));
        if (bsiz < BYTES_WORD) {
                p += bsiz;
                n -= bsiz;
        }
        if (p + n == bposition) {       /* just allocated? */
                bposition = p;
                nremain += n;
                return;
        }
        if (n > nremain) {              /* better than what we've got? */
                bposition = p;
                nremain = n;
                return;
        }
                                /* just throw it away, then */
}
Revision:	2.2
Committed:	Tue Mar 10 15:32:00 1992 UTC (32 years, 1 month ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.1:	+4 -7 lines
Log Message:	minor optimization
#	User	Rev	Content
1	greg	1.3	/* Copyright (c) 1991 Regents of the University of California */
2	greg	1.1
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8	greg	1.3	* Bmalloc provides basic memory allocation without overhead (no free lists).
9			* Use only to take the load off of malloc for all those
10			* piddling little requests that you never expect to free.
11			* Bmalloc defers to malloc for big requests.
12			* Bfree should hand memory to bmalloc, but it usually fails here.
13	greg	1.1	*/
14
15	greg	1.2	#define NULL 0
16
17	greg	1.1	#ifndef MBLKSIZ
18			#define MBLKSIZ 16376 /* size of memory allocation block */
19			#endif
20	greg	1.3	#define WASTEFRAC 12 /* don't waste more than a fraction */
21	greg	1.1	#ifndef ALIGN
22			#define ALIGN int /* type for alignment */
23			#endif
24			#define BYTES_WORD sizeof(ALIGN)
25
26	greg	1.3	extern char *malloc();
27	greg	1.1
28	greg	1.3	static char *bposition = NULL;
29			static unsigned nremain = 0;
30
31
32	greg	1.1	char *
33	greg	2.2	bmalloc(n) /* allocate a block of n bytes */
34	greg	1.1	register unsigned n;
35			{
36	greg	1.3	if (n > nremain && (n > MBLKSIZ \|\| nremain > MBLKSIZ/WASTEFRAC))
37	greg	1.2	return(malloc(n)); /* too big */
38	greg	1.1
39			n = (n+(BYTES_WORD-1))&~(BYTES_WORD-1); /* word align */
40
41	greg	2.2	if (n > nremain && (bposition = malloc(nremain = MBLKSIZ)) == NULL) {
42			nremain = 0;
43			return(NULL);
44	greg	1.1	}
45	greg	1.3	bposition += n;
46			nremain -= n;
47			return(bposition - n);
48	greg	1.1	}
49
50
51			bfree(p, n) /* free random memory */
52	greg	1.3	register char *p;
53			register unsigned n;
54	greg	1.1	{
55	greg	1.3	register unsigned bsiz;
56			/* check alignment */
57			bsiz = BYTES_WORD - ((unsigned)p&(BYTES_WORD-1));
58			if (bsiz < BYTES_WORD) {
59			p += bsiz;
60			n -= bsiz;
61			}
62			if (p + n == bposition) { /* just allocated? */
63			bposition = p;
64			nremain += n;
65			return;
66			}
67			if (n > nremain) { /* better than what we've got? */
68			bposition = p;
69			nremain = n;
70			return;
71			}
72			/* just throw it away, then */
73	greg	1.1	}