--- ray/src/common/bmalloc.c	1990/09/25 18:56:04	1.1
+++ ray/src/common/bmalloc.c	2004/10/03 20:48:53	2.8
@@ -1,51 +1,77 @@
-/* Copyright (c) 1990 Regents of the University of California */
-
 #ifndef lint
-static char SCCSid[] = "$SunId$ LBL";
+static const char	RCSid[] = "$Id: bmalloc.c,v 2.8 2004/10/03 20:48:53 schorsch Exp $";
 #endif
-
 /*
- * Simple memory allocation without overhead
+ * 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  MBLKSIZ
 #define  MBLKSIZ	16376		/* size of memory allocation block */
 #endif
-#ifndef  ALIGN
-#define  ALIGN		int		/* type for alignment */
+#define  WASTEFRAC	12		/* don't waste more than a fraction */
+#ifndef  ALIGNT
+#define  ALIGNT		double		/* type for alignment */
 #endif
-#define  BYTES_WORD	sizeof(ALIGN)
+#define  BYTES_WORD	sizeof(ALIGNT)
 
+static char  *bposition = NULL;
+static size_t  nremain = 0;
 
-char *
-bmalloc(n)		/* allocate a block of n bytes, no refunds */
-register unsigned  n;
+
+void *
+bmalloc(		/* allocate a block of n bytes */
+register size_t  n
+)
 {
-	static char  *bpos = NULL;
-	static unsigned  nrem = 0;
+	if (n > nremain && (n > MBLKSIZ || nremain > MBLKSIZ/WASTEFRAC))
+		return(malloc(n));			/* too big */
 
-	if (n > MBLKSIZ/2)			/* too big for me */
-		return(malloc(n));
-
 	n = (n+(BYTES_WORD-1))&~(BYTES_WORD-1);		/* word align */
 
-	if (n > nrem) {
-		if ((bpos = malloc((unsigned)MBLKSIZ)) == NULL) {
-			nrem = 0;
-			return(NULL);
-		}
-		nrem = MBLKSIZ;
+	if (n > nremain && (bposition = malloc(nremain = MBLKSIZ)) == NULL) {
+		nremain = 0;
+		return(NULL);
 	}
-	bpos += n;
-	nrem -= n;
-	return(bpos - n);
+	bposition += n;
+	nremain -= n;
+	return(bposition - n);
 }
 
 
-bfree(p, n)			/* free random memory */
-char	*p;
-unsigned	n;
+void
+bfree(			/* free random memory */
+register void	*p,
+register size_t	n
+)
 {
-	/* not implemented */
+	register 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 */
 }