src/common/bmalloc.c

#ifndef lint
static const char       RCSid[] = "$Id: bmalloc.c,v 2.9 2004/10/23 18:55:52 schorsch Exp $";
#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.
 *
 *  External symbols declared in standard.h
 */

#include "copyright.h"

#include <stdlib.h>

#include "rtmisc.h"

#ifndef  ALIGNT
#define  ALIGNT         double          /* type for alignment */
#endif
#define  BYTES_WORD     sizeof(ALIGNT)

#ifndef  MBLKSIZ                        /* size of memory allocation block */
#define  MBLKSIZ        ((1<<15)-BYTES_WORD)
#endif
#define  WASTEFRAC      12              /* don't waste more than a fraction */

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

void *
bmalloc(                /* quickly allocate a block of n bytes */
size_t  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);
}

void
bfree(                  /* free some memory; anything in process space */
void    *pp,
size_t  n
)
{
        char *p = pp;
        size_t  bsiz;
                                        /* check alignment */
        bsiz = BYTES_WORD - ((size_t)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.10
Committed:	Sat Apr 12 01:43:53 2025 UTC (2 weeks, 6 days ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 2.9:	+15 -16 lines
Log Message:	perf: minor optimizations
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.10	static const char RCSid[] = "$Id: bmalloc.c,v 2.9 2004/10/23 18:55:52 schorsch Exp $";
3	greg	1.1	#endif
4			/*
5	greg	1.3	* Bmalloc provides basic memory allocation without overhead (no free lists).
6			* Use only to take the load off of malloc for all those
7			* piddling little requests that you never expect to free.
8			* Bmalloc defers to malloc for big requests.
9			* Bfree should hand memory to bmalloc, but it usually fails here.
10	greg	2.3	*
11			* External symbols declared in standard.h
12	greg	1.1	*/
13
14	greg	2.4	#include "copyright.h"
15	greg	2.3
16			#include <stdlib.h>
17	schorsch	2.5
18			#include "rtmisc.h"
19	greg	1.2
20	greg	2.3	#ifndef ALIGNT
21			#define ALIGNT double /* type for alignment */
22	greg	1.1	#endif
23	greg	2.3	#define BYTES_WORD sizeof(ALIGNT)
24	greg	1.1
25	greg	2.10	#ifndef MBLKSIZ /* size of memory allocation block */
26			#define MBLKSIZ ((1<<15)-BYTES_WORD)
27			#endif
28			#define WASTEFRAC 12 /* don't waste more than a fraction */
29
30	schorsch	2.8	static char *bposition = NULL;
31	schorsch	2.7	static size_t nremain = 0;
32	greg	1.3
33	schorsch	2.7	void *
34	greg	2.10	bmalloc( /* quickly allocate a block of n bytes */
35			size_t n
36	schorsch	2.6	)
37	greg	1.1	{
38	greg	2.10	if ((n > nremain) & ((n > MBLKSIZ) \| (nremain > MBLKSIZ/WASTEFRAC)))
39	greg	1.2	return(malloc(n)); /* too big */
40	greg	1.1
41	greg	2.10	n = (n+(BYTES_WORD-1)) & ~(BYTES_WORD-1); /* word align */
42	greg	1.1
43	schorsch	2.7	if (n > nremain && (bposition = malloc(nremain = MBLKSIZ)) == NULL) {
44	greg	2.2	nremain = 0;
45			return(NULL);
46	greg	1.1	}
47	greg	1.3	bposition += n;
48			nremain -= n;
49			return(bposition - n);
50	greg	1.1	}
51
52	greg	2.3	void
53	greg	2.10	bfree( /* free some memory; anything in process space */
54			void *pp,
55			size_t n
56	schorsch	2.6	)
57	greg	1.1	{
58	greg	2.10	char *p = pp;
59			size_t bsiz;
60	greg	1.3	/* check alignment */
61	schorsch	2.7	bsiz = BYTES_WORD - ((size_t)p&(BYTES_WORD-1));
62	greg	1.3	if (bsiz < BYTES_WORD) {
63			p += bsiz;
64			n -= bsiz;
65			}
66			if (p + n == bposition) { /* just allocated? */
67			bposition = p;
68			nremain += n;
69			return;
70			}
71			if (n > nremain) { /* better than what we've got? */
72			bposition = p;
73			nremain = n;
74			return;
75			}
76			/* just throw it away, then */
77	greg	1.1	}