--- ray/src/hd/rholo3.c	1998/07/08 17:59:58	3.22
+++ ray/src/hd/rholo3.c	2004/06/08 19:48:30	3.42
@@ -1,32 +1,91 @@
+#ifndef lint
+static const char	RCSid[] = "$Id: rholo3.c,v 3.42 2004/06/08 19:48:30 greg Exp $";
+#endif
 /*
  * Routines for tracking beam compuatations
  */
 
 #include "rholo.h"
 
+#ifndef NFRAG2CHUNK
+#define NFRAG2CHUNK	4096	/* number of fragments to start chunking */
+#endif
+
+#ifndef abs
 #define abs(x)		((x) > 0 ? (x) : -(x))
+#endif
+#ifndef sgn
 #define sgn(x)		((x) > 0 ? 1 : (x) < 0 ? -1 : 0)
+#endif
 
+#define rchunk(n)	(((n)+(RPACKSIZ/2))/RPACKSIZ)
+
+int	chunkycmp = 0;		/* clump beams together on disk */
+
 static PACKHEAD	*complist=NULL;	/* list of beams to compute */
 static int	complen=0;	/* length of complist */
 static int	listpos=0;	/* current list position for next_packet */
 static int	lastin= -1;	/* last ordered position in list */
 
+static void sortcomplist(void);
+static void mergeclists(PACKHEAD *cdest, PACKHEAD *cl1, int n1, PACKHEAD *cl2, int n2);
+static void view_list(FILE	*fp);
+static void ambient_list(void);
+static double beamvolume(HOLO	*hp, int	bi);
+static void dispbeam(BEAM	*b, HDBEAMI	*hb);
 
-int
-beamcmp(b0, b1)			/* comparison for descending compute order */
+
+
+static int
+beamcmp(b0, b1)				/* comparison for compute order */
 register PACKHEAD	*b0, *b1;
 {
-	return(	b1->nr*(b0->nc+1) - b0->nr*(b1->nc+1) );
+	BEAMI	*bip0, *bip1;
+	register long	c;
+					/* first check desired quantities */
+	if (chunkycmp)
+		c = rchunk(b1->nr)*(rchunk(b0->nc)+1L) -
+				rchunk(b0->nr)*(rchunk(b1->nc)+1L);
+	else
+		c = b1->nr*(b0->nc+1L) - b0->nr*(b1->nc+1L);
+	if (c > 0) return(1);
+	if (c < 0) return(-1);
+				/* only one file, so skip the following: */
+#if 0
+					/* next, check file descriptors */
+	c = hdlist[b0->hd]->fd - hdlist[b1->hd]->fd;
+	if (c) return(c);
+#endif
+					/* finally, check file positions */
+	bip0 = &hdlist[b0->hd]->bi[b0->bi];
+	bip1 = &hdlist[b1->hd]->bi[b1->bi];
+					/* put diskless beams last */
+	if (!bip0->nrd)
+		return(bip1->nrd > 0);
+	if (!bip1->nrd)
+		return(-1);
+	c = bip0->fo - bip1->fo;
+	return(c < 0 ? -1 : c > 0);
 }
 
 
 int
-dispbeam(b, hp, bi)			/* display a holodeck beam */
-register BEAM	*b;
-HOLO	*hp;
-int	bi;
+beamidcmp(b0, b1)			/* comparison for beam searching */
+register PACKHEAD	*b0, *b1;
 {
+	register int	c = b0->hd - b1->hd;
+
+	if (c) return(c);
+	return(b0->bi - b1->bi);
+}
+
+
+static void
+dispbeam(				/* display a holodeck beam */
+	register BEAM	*b,
+	register HDBEAMI	*hb
+)
+{
 	static int	n = 0;
 	static PACKHEAD	*p = NULL;
 
@@ -35,87 +94,103 @@ int	bi;
 	if (b->nrm > n) {		/* (re)allocate packet holder */
 		n = b->nrm;
 		if (p == NULL) p = (PACKHEAD *)malloc(packsiz(n));
-		else p = (PACKHEAD *)realloc((char *)p, packsiz(n));
-		if (p == NULL)
-			error(SYSTEM, "out of memory in dispbeam");
+		else p = (PACKHEAD *)realloc((void *)p, packsiz(n));
+		CHECK(p==NULL, SYSTEM, "out of memory in dispbeam");
 	}
 					/* assign packet fields */
-	bcopy((char *)hdbray(b), (char *)packra(p), b->nrm*sizeof(RAYVAL));
+	memcpy((void *)packra(p), (void *)hdbray(b), b->nrm*sizeof(RAYVAL));
 	p->nr = p->nc = b->nrm;
-	for (p->hd = 0; hdlist[p->hd] != hp; p->hd++)
+	for (p->hd = 0; hdlist[p->hd] != hb->h; p->hd++)
 		if (hdlist[p->hd] == NULL)
 			error(CONSISTENCY, "unregistered holodeck in dispbeam");
-	p->bi = bi;
+	p->bi = hb->b;
 	disp_packet(p);			/* display it */
+	if (n >= 1024) {		/* free ridiculous packets */
+		free((void *)p);
+		p = NULL; n = 0;
+	}
 }
 
 
-bundle_set(op, clist, nents)	/* bundle set operation */
-int	op;
-register PACKHEAD	*clist;
-int	nents;
+extern void
+bundle_set(	/* bundle set operation */
+	int	op,
+	PACKHEAD	*clist,
+	int	nents
+)
 {
-	int	oldnr;
-	register HDBEAMI	*hb;
-	register int	i, n;
-				/* look for common members */
-	for (n = 0; n < nents; n++) {
-		for (i = 0; i < complen; i++)
-			if (clist[n].bi == complist[i].bi &&
-					clist[n].hd == complist[i].hd) {
-				oldnr = complist[i].nr;
-				clist[n].nc = complist[i].nc;
-				switch (op) {
-				case BS_ADD:		/* add to count */
-					complist[i].nr += clist[n].nr;
-					clist[n].nr = 0;
-					break;
-				case BS_ADJ:		/* reset count */
-					complist[i].nr = clist[n].nr;
-					clist[n].nr = 0;
-					break;
-				case BS_DEL:		/* delete count */
-					if (clist[n].nr == 0 ||
-						clist[n].nr >= complist[i].nr)
-						complist[i].nr = 0;
-					else
-						complist[i].nr -= clist[n].nr;
-					break;
-				}
-				if (complist[i].nr != oldnr)
-					lastin = -1;	/* flag sort */
-				break;
-			}
-		if (i >= complen)
-			clist[n].nc = bnrays(hdlist[clist[n].hd], clist[n].bi);
+	int	oldnr, n;
+	HDBEAMI	*hbarr;
+	register PACKHEAD	*csm;
+	register int	i;
+					/* search for common members */
+	for (csm = clist+nents; csm-- > clist; )
+		csm->nc = -1;
+	qsort((void *)clist, nents, sizeof(PACKHEAD), beamidcmp);
+	for (i = 0; i < complen; i++) {
+		csm = (PACKHEAD *)bsearch((void *)(complist+i), (void *)clist,
+				nents, sizeof(PACKHEAD), beamidcmp);
+		if (csm == NULL)
+			continue;
+		oldnr = complist[i].nr;
+		csm->nc = complist[i].nc;
+		switch (op) {
+		case BS_ADD:		/* add to count */
+			complist[i].nr += csm->nr;
+			csm->nr = 0;
+			break;
+		case BS_MAX:		/* maximum of counts */
+			if (csm->nr > complist[i].nr)
+				complist[i].nr = csm->nr;
+			csm->nr = 0;
+			break;
+		case BS_ADJ:		/* reset count */
+			complist[i].nr = csm->nr;
+			csm->nr = 0;
+			break;
+		case BS_DEL:		/* delete count */
+			if (csm->nr == 0 || csm->nr >= complist[i].nr)
+				complist[i].nr = 0;
+			else
+				complist[i].nr -= csm->nr;
+			break;
+		}
+		if (complist[i].nr != oldnr)
+			lastin = -1;	/* flag sort */
 	}
+				/* record computed rays for uncommon beams */
+	for (csm = clist+nents; csm-- > clist; )
+		if (csm->nc < 0)
+			csm->nc = bnrays(hdlist[csm->hd], csm->bi);
 				/* complete list operations */
 	switch (op) {
 	case BS_NEW:			/* new computation set */
 		listpos = 0; lastin = -1;
 		if (complen)		/* free old list */
-			free((char *)complist);
+			free((void *)complist);
 		complist = NULL;
 		if (!(complen = nents))
 			return;
 		complist = (PACKHEAD *)malloc(nents*sizeof(PACKHEAD));
 		if (complist == NULL)
 			goto memerr;
-		bcopy((char *)clist, (char *)complist, nents*sizeof(PACKHEAD));
+		memcpy((void *)complist, (void *)clist, nents*sizeof(PACKHEAD));
 		break;
 	case BS_ADD:			/* add to computation set */
+	case BS_MAX:			/* maximum of quantities */
 	case BS_ADJ:			/* adjust set quantities */
 		if (nents <= 0)
 			return;
 		sortcomplist();		/* sort updated list & new entries */
-		qsort((char *)clist, nents, sizeof(PACKHEAD), beamcmp);
+		qsort((void *)clist, nents, sizeof(PACKHEAD), beamcmp);
 					/* what can't we satisfy? */
-		for (n = 0; n < nents && clist[n].nr > clist[n].nc; n++)
+		for (i = nents, csm = clist; i-- && csm->nr > csm->nc; csm++)
 			;
-		if (op == BS_ADJ) {	/* don't regenerate adjusted beams */
-			for (i = n; i < nents && clist[i].nr > 0; i++)
+		n = csm - clist;
+		if (op != BS_ADD) {	/* don't regenerate adjusted beams */
+			for (++i; i-- && csm->nr > 0; csm++)
 				;
-			nents = i;
+			nents = csm - clist;
 		}
 		if (n) {		/* allocate space for merged list */
 			PACKHEAD	*newlist;
@@ -126,7 +201,7 @@ int	nents;
 						/* merge lists */
 			mergeclists(newlist, clist, n, complist, complen);
 			if (complen)
-				free((char *)complist);
+				free((void *)complist);
 			complist = newlist;
 			complen += n;
 		}
@@ -138,30 +213,35 @@ int	nents;
 	default:
 		error(CONSISTENCY, "bundle_set called with unknown operation");
 	}
-	if (outdev == NULL)		/* nothing to display? */
+	if (outdev == NULL || !nents)	/* nothing to display? */
 		return;
 					/* load and display beams we have */
-	hb = (HDBEAMI *)malloc(nents*sizeof(HDBEAMI));
-	for (i = 0; i < nents; i++) {
-		hb[i].h = hdlist[clist[i].hd];
-		hb[i].b = clist[i].bi;
+	hbarr = (HDBEAMI *)malloc(nents*sizeof(HDBEAMI));
+	for (i = nents; i--; ) {
+		hbarr[i].h = hdlist[clist[i].hd];
+		hbarr[i].b = clist[i].bi;
 	}
-	hdloadbeams(hb, nents, dispbeam);
-	free((char *)hb);
+	hdloadbeams(hbarr, nents, dispbeam);
+	free((void *)hbarr);
+	if (hdfragflags&FF_READ) {
+		listpos = 0;
+		lastin = -1;		/* need to re-sort list */
+	}
 	return;
 memerr:
 	error(SYSTEM, "out of memory in bundle_set");
 }
 
 
-double
-beamvolume(hp, bi)	/* compute approximate volume of a beam */
-HOLO	*hp;
-int	bi;
+static double
+beamvolume(	/* compute approximate volume of a beam */
+	HOLO	*hp,
+	int	bi
+)
 {
 	GCOORD	gc[2];
 	FVECT	cp[4], edgeA, edgeB, cent[2];
-	FVECT	v, crossp[2], diffv;
+	FVECT	crossp[2], diffv;
 	double	vol[2];
 	register int	i;
 					/* get grid coordinates */
@@ -187,26 +267,21 @@ int	bi;
 }
 
 
-init_global()			/* initialize global ray computation */
+static void
+ambient_list(void)			/* compute ambient beam list */
 {
-	long	wtotal = 0;
+	int32	wtotal, minrt;
 	double	frac;
 	int	i;
 	register int	j, k;
-					/* free old list and empty queue */
-	if (complen > 0) {
-		free((char *)complist);
-		done_packets(flush_queue());
-	}
-					/* allocate beam list */
+
 	complen = 0;
 	for (j = 0; hdlist[j] != NULL; j++)
 		complen += nbeams(hdlist[j]);
 	complist = (PACKHEAD *)malloc(complen*sizeof(PACKHEAD));
-	if (complist == NULL)
-		error(SYSTEM, "out of memory in init_global");
+	CHECK(complist==NULL, SYSTEM, "out of memory in ambient_list");
 					/* compute beam weights */
-	k = 0;
+	k = 0; wtotal = 0;
 	for (j = 0; hdlist[j] != NULL; j++) {
 		frac = 512. * VLEN(hdlist[j]->wg[0]) *
 				VLEN(hdlist[j]->wg[1]) *
@@ -219,23 +294,76 @@ init_global()			/* initialize global ray computation *
 			wtotal += complist[k++].nr;
 		}
 	}
-					/* adjust weights */
+					/* adjust sample weights */
 	if (vdef(DISKSPACE))
 		frac = 1024.*1024.*vflt(DISKSPACE) / (wtotal*sizeof(RAYVAL));
 	else
-		frac = 1024.*1024.*16384. / (wtotal*sizeof(RAYVAL));
-	while (k--)
-		complist[k].nr = frac * complist[k].nr;
-	listpos = 0; lastin = -1;	/* perform initial sort */
-	sortcomplist();
+		frac = 1024.*1024.*2048. / (wtotal*sizeof(RAYVAL));
+	minrt = .02*frac*wtotal/complen + .5;	/* heuristic mimimum */
+	if (minrt > RPACKSIZ)
+		minrt = RPACKSIZ;
+	for (k = complen; k--; )
+		if ((complist[k].nr = frac*complist[k].nr + 0.5) < minrt)
+			complist[k].nr = minrt;
+	listpos = 0; lastin = -1;	/* flag initial sort */
 }
 
 
-mergeclists(cdest, cl1, n1, cl2, n2)	/* merge two sorted lists */
-register PACKHEAD	*cdest;
-register PACKHEAD	*cl1, *cl2;
-int	n1, n2;
+static void
+view_list(			/* assign beam priority from view list */
+	FILE	*fp
+)
 {
+	double	pa = 1.;
+	VIEW	curview;
+	int	xr, yr;
+	char	*err;
+	BEAMLIST	blist;
+
+	curview = stdview;
+	while (nextview(&curview, fp) != EOF) {
+		if ((err = setview(&curview)) != NULL) {
+			error(WARNING, err);
+			continue;
+		}
+		xr = yr = 1024;
+		normaspect(viewaspect(&curview), &pa, &xr, &yr);
+		viewbeams(&curview, xr, yr, &blist);
+		bundle_set(BS_MAX, blist.bl, blist.nb);
+		free((void *)blist.bl);
+	}
+}
+
+
+extern void
+init_global(void)			/* initialize global ray computation */
+{
+					/* free old list and empty queue */
+	if (complen > 0) {
+		free((void *)complist);
+		done_packets(flush_queue());
+	}
+					/* reseed random number generator */
+	srandom(time(NULL));
+					/* allocate beam list */
+	if (readinp)
+		view_list(stdin);
+	else
+		ambient_list();
+					/* no view vicinity */
+	myeye.rng = 0;
+}
+
+
+static void
+mergeclists(	/* merge two sorted lists */
+	register PACKHEAD	*cdest,
+	register PACKHEAD	*cl1,
+	int	n1,
+	register PACKHEAD	*cl2,
+	int	n2
+)
+{
 	register int	cmp;
 
 	while (n1 | n2) {
@@ -243,10 +371,10 @@ int	n1, n2;
 		else if (!n2) cmp = -1;
 		else cmp = beamcmp(cl1, cl2);
 		if (cmp > 0) {
-			copystruct(cdest, cl2);
+			*cdest = *cl2;
 			cl2++; n2--;
 		} else {
-			copystruct(cdest, cl1);
+			*cdest = *cl1;
 			cl1++; n1--;
 		}
 		cdest++;
@@ -254,39 +382,51 @@ int	n1, n2;
 }
 
 
-sortcomplist()			/* fix our list order */
+static void
+sortcomplist(void)			/* fix our list order */
 {
 	PACKHEAD	*list2;
+	int	listlen;
 	register int	i;
 
 	if (complen <= 0)	/* check to see if there is even a list */
 		return;
+	if (!chunkycmp)		/* check to see if fragment list is full */
+		if (!hdfragOK(hdlist[0]->fd, &listlen, NULL)
+#if NFRAG2CHUNK
+				|| listlen >= NFRAG2CHUNK
+#endif
+				) {
+			chunkycmp++;	/* use "chunky" comparison */
+			lastin = -1;	/* need to re-sort list */
+#ifdef DEBUG
+			error(WARNING, "using chunky comparison mode");
+#endif
+		}
 	if (lastin < 0 || listpos*4 >= complen*3)
-		qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
+		qsort((void *)complist, complen, sizeof(PACKHEAD), beamcmp);
 	else if (listpos) {	/* else sort and merge sublist */
 		list2 = (PACKHEAD *)malloc(listpos*sizeof(PACKHEAD));
-		if (list2 == NULL)
-			error(SYSTEM, "out of memory in sortcomplist");
-		bcopy((char *)complist,(char *)list2,listpos*sizeof(PACKHEAD));
-		qsort((char *)list2, listpos, sizeof(PACKHEAD), beamcmp);
+		CHECK(list2==NULL, SYSTEM, "out of memory in sortcomplist");
+		memcpy((void *)list2,(void *)complist,listpos*sizeof(PACKHEAD));
+		qsort((void *)list2, listpos, sizeof(PACKHEAD), beamcmp);
 		mergeclists(complist, list2, listpos,
 				complist+listpos, complen-listpos);
-		free((char *)list2);
+		free((void *)list2);
 	}
 					/* drop satisfied requests */
 	for (i = complen; i-- && complist[i].nr <= complist[i].nc; )
 		;
 	if (i < 0) {
-		free((char *)complist);
+		free((void *)complist);
 		complist = NULL;
 		complen = 0;
 	} else if (i < complen-1) {
-		list2 = (PACKHEAD *)realloc((char *)complist,
+		list2 = (PACKHEAD *)realloc((void *)complist,
 				(i+1)*sizeof(PACKHEAD));
-		if (list2 != NULL) {
+		if (list2 != NULL)
 			complist = list2;
-			complen = i+1;
-		}
+		complen = i+1;
 	}
 	listpos = 0; lastin = i;
 }
@@ -297,16 +437,16 @@ sortcomplist()			/* fix our list order */
  * more or less evenly distributed, such that computing a packet causes
  * a given bundle to move way down in the computation order.  We keep
  * track of where the computed bundle with the highest priority would end
- * up, and if we get further in our compute list than this, we resort the
+ * up, and if we get further in our compute list than this, we re-sort the
  * list and start again from the beginning.  Since
  * a merge sort is used, the sorting costs are minimal.
  */
-next_packet(p, n)		/* prepare packet for computation */
-register PACKET	*p;
-int	n;
+extern int
+next_packet(		/* prepare packet for computation */
+	register PACKET	*p,
+	int	n
+)
 {
-	register int	i;
-
 	if (listpos > lastin)		/* time to sort the list */
 		sortcomplist();
 	if (complen <= 0)
@@ -317,13 +457,13 @@ int	n;
 	p->nr = complist[listpos].nr - p->nc;
 	if (p->nr <= 0)
 		return(0);
-#ifdef DEBUG
-	if (n < 1 | n > RPACKSIZ)
-		error(CONSISTENCY, "next_packet called with bad n value");
-#endif
+	DCHECK(n < 1 | n > RPACKSIZ,
+			CONSISTENCY, "next_packet called with bad n value");
 	if (p->nr > n)
 		p->nr = n;
 	complist[listpos].nc += p->nr;	/* find where this one would go */
+	if (hdgetbeam(hdlist[p->hd], p->bi) != NULL)
+		hdfreefrag(hdlist[p->hd], p->bi);
 	while (lastin > listpos && 
 			beamcmp(complist+lastin, complist+listpos) > 0)
 		lastin--;