--- ray/src/rt/rc3.c	2012/06/12 17:20:44	2.6
+++ ray/src/rt/rc3.c	2023/11/15 18:02:53	2.25
@@ -1,16 +1,17 @@
 #ifndef lint
-static const char RCSid[] = "$Id: rc3.c,v 2.6 2012/06/12 17:20:44 greg Exp $";
+static const char RCSid[] = "$Id: rc3.c,v 2.25 2023/11/15 18:02:53 greg Exp $";
 #endif
 /*
  * Accumulate ray contributions for a set of materials
  * Controlling process for multiple children
  */
 
+#include <signal.h>
 #include "rcontrib.h"
-#include "platform.h"
-#include "rtprocess.h"
 #include "selcall.h"
 
+#define	MAXIQ		(int)(PIPE_BUF/(sizeof(FVECT)*2))
+
 /* Modifier contribution queue (results waiting to be output) */
 typedef struct s_binq {
 	RNUMBER		ndx;		/* index for this entry */
@@ -22,12 +23,13 @@ typedef struct s_binq {
 static BINQ	*out_bq = NULL;		/* output bin queue */
 static BINQ	*free_bq = NULL;	/* free queue entries */
 
+static SUBPROC	kidpr[MAXPROCESS];	/* our child processes */
+
 static struct {
 	RNUMBER	r1;			/* assigned ray starting index */
-	SUBPROC	pr;			/* PID, i/o descriptors */
 	FILE	*infp;			/* file pointer to read from process */
-	int	nr;			/* number rays to sum (0 if free) */
-} kida[MAXPROCESS];		/* our child processes */
+	int	nr;			/* number of rays to sum (0 if free) */
+} kida[MAXPROCESS];		/* our child process i/o */
 
 
 /* Get new bin queue entry */
@@ -50,12 +52,11 @@ new_binq()
 		goto memerr;
 	for (i = nmods; i--; ) {
 		MODCONT	*mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
-		bp->mca[i] = (MODCONT *)malloc(sizeof(MODCONT) +
-						sizeof(DCOLOR)*(mp->nbins-1));
+		bp->mca[i] = (MODCONT *)malloc(mcsize(mp->nbins));
 		if (bp->mca[i] == NULL)
 			goto memerr;
-		memcpy(bp->mca[i], mp, sizeof(MODCONT)-sizeof(DCOLOR));
-		/* memset(bp->mca[i]->cbin, 0, sizeof(DCOLOR)*mp->nbins); */
+		memcpy(bp->mca[i], mp, sizeof(MODCONT)-sizeof(DCOLORV));
+		/* memset(bp->mca[i]->cbin, 0, DCOLORSIZ*mp->nbins); */
 	}
 	bp->ndx = 0;
 	bp->nadded = 0;
@@ -85,8 +86,10 @@ free_binq(BINQ *bp)
 	}
 					/* clear sums for next use */
 /*	for (i = nmods; i--; )
-		memset(bp->mca[i]->cbin, 0, sizeof(DCOLOR)*bp->mca[i]->nbins);
+		memset(bp->mca[i]->cbin, 0, DCOLORSIZ*bp->mca[i]->nbins);
 */
+	if (bp->next != NULL)
+		error(CONSISTENCY, "free_binq() handed list");
 	bp->ndx = 0;
 	bp->next = free_bq;		/* push onto free list */
 	free_bq = bp;
@@ -94,11 +97,12 @@ free_binq(BINQ *bp)
 
 
 /* Add modifier values to accumulation record in queue and clear */
-void
+static void
 queue_modifiers()
 {
 	MODCONT	*mpin, *mpout;
-	int	i, j;
+	DCOLORV	*ssrc, *sdst;
+	int	i;
 
 	if ((accumulate > 0) | (out_bq == NULL))
 		error(CONSISTENCY, "bad call to queue_modifiers()");
@@ -106,9 +110,11 @@ queue_modifiers()
 	for (i = nmods; i--; ) {
 		mpin = (MODCONT *)lu_find(&modconttab,modname[i])->data;
 		mpout = out_bq->mca[i];
-		for (j = mpout->nbins; j--; )
-			addcolor(mpout->cbin[j], mpin->cbin[j]);
-		memset(mpin->cbin, 0, sizeof(DCOLOR)*mpin->nbins);
+		ssrc = mcbin(mpin, mpin->nbins);
+		sdst = mcbin(mpout, mpout->nbins);
+		while (sdst > mpout->cbin)
+			*--sdst += *--ssrc;
+		memset(mpin->cbin, 0, DCOLORSIZ*mpin->nbins);
 	}
 	out_bq->nadded++;
 }
@@ -118,13 +124,17 @@ queue_modifiers()
 static void
 add_modbin(BINQ *dst, BINQ *src)
 {
-	int	i, j;
-	
+	MODCONT	*mpin, *mpout;
+	DCOLORV	*ssrc, *sdst;
+	int	i;
+
 	for (i = nmods; i--; ) {
-		MODCONT	*mpin = src->mca[i];
-		MODCONT	*mpout = dst->mca[i];
-		for (j = mpout->nbins; j--; )
-			addcolor(mpout->cbin[j], mpin->cbin[j]);
+		mpin = src->mca[i];
+		mpout = dst->mca[i];
+		ssrc = mcbin(mpin, mpin->nbins);
+		sdst = mcbin(mpout, mpout->nbins);
+		while (sdst > mpout->cbin)
+			*--sdst += *--ssrc;
 	}
 	dst->nadded += src->nadded;
 }
@@ -146,7 +156,7 @@ queue_output(BINQ *bp)
 		}
 		return;
 	}
-	b_last = NULL;			/* else insert in output queue */
+	b_last = NULL;			/* insert in output queue */
 	for (b_cur = out_bq; b_cur != NULL && b_cur->ndx < bp->ndx;
 				b_cur = b_cur->next)
 		b_last = b_cur;
@@ -184,9 +194,6 @@ queue_ready()
 	int	nready = 0;
 	BINQ	*bp;
 
-	if (accumulate <= 0)		/* just accumulating? */
-		return(0);
-
 	for (bp = out_bq; bp != NULL && bp->nadded >= accumulate &&
 				bp->ndx == lastdone+nready*accumulate+1;
 				bp = bp->next)
@@ -203,10 +210,7 @@ output_catchup(int nmax)
 	int	nout = 0;
 	BINQ	*bp;
 	int	i;
-
-	if (accumulate <= 0)		/* just accumulating? */
-		return(0);
-					/* else output ready results */
+					/* output ready results */
 	while (out_bq != NULL && out_bq->nadded >= accumulate
 				&& out_bq->ndx == lastdone+1) {
 		if ((nmax > 0) & (nout >= nmax))
@@ -233,7 +237,7 @@ put_zero_record(int ndx)
 	int	i;
 
 	for (i = nmods; i--; )
-		memset(bp->mca[i]->cbin, 0, sizeof(DCOLOR)*bp->mca[i]->nbins);
+		memset(bp->mca[i]->cbin, 0, DCOLORSIZ*bp->mca[i]->nbins);
 	bp->ndx = ndx;
 	bp->nadded = 1;
 	queue_output(bp);
@@ -252,7 +256,7 @@ queue_results(int k)
 	bq->nadded = kida[k].nr;
 					/* read from child */
 	for (j = 0; j < nmods; j++)
-		if (fread(bq->mca[j]->cbin, sizeof(DCOLOR), bq->mca[j]->nbins,
+		if (getbinary(bq->mca[j]->cbin, DCOLORSIZ, bq->mca[j]->nbins,
 					kida[k].infp) != bq->mca[j]->nbins)
 			error(SYSTEM, "read error from render process");
 			
@@ -270,34 +274,24 @@ set_stdout(const LUENT *le, void *p)
 }
 
 
-/* Start child processes if we can */
+/* Start child processes if we can (call only once in parent!) */
 int
 in_rchild()
 {
-#ifdef _WIN32
-	error(WARNING, "multiprocessing unsupported -- running solo");
-	nproc = 1;
-	return(1);
-#else
-					/* try to fork ourselves */
-	while (nchild < nproc) {
-		int	p0[2], p1[2];
-		int	pid;
-					/* prepare i/o pipes */
+	int	rval;
+
+	while (nchild < nproc) {	/* fork until target reached */
 		errno = 0;
-		if (pipe(p0) < 0 || pipe(p1) < 0)
-			error(SYSTEM, "pipe() call failed!");
-		pid = fork();		/* fork parent process */
-		if (pid == 0) {		/* if in child, set up & return true */
-			close(p0[1]); close(p1[0]);
-			lu_doall(&modconttab, set_stdout, NULL);
+		rval = open_process(&kidpr[nchild], NULL);
+		if (rval < 0)
+			error(SYSTEM, "open_process() call failed");
+		if (rval == 0) {	/* if in child, set up & return true */
+			lu_doall(&modconttab, &set_stdout, NULL);
 			lu_done(&ofiletab);
 			while (nchild--) {	/* don't share other pipes */
-				close(kida[nchild].pr.w);
+				close(kidpr[nchild].w);
 				fclose(kida[nchild].infp);
 			}
-			dup2(p0[0], 0); close(p0[0]);
-			dup2(p1[1], 1); close(p1[1]);
 			inpfmt = (sizeof(RREAL)==sizeof(double)) ? 'd' : 'f';
 			outfmt = 'd';
 			header = 0;
@@ -310,46 +304,41 @@ in_rchild()
 				waitflush = xres = 0;
 				account = accumulate = 0;
 			}
-			return(1);	/* child return value */
+			return(1);	/* return "true" in child */
 		}
-		if (pid < 0)
-			error(SYSTEM, "fork() call failed!");
-					/* connect parent's pipes */
-		close(p0[0]); close(p1[1]);
-		kida[nchild].pr.r = p1[0];
-		kida[nchild].pr.w = p0[1];
-		kida[nchild].pr.pid = pid;
-		kida[nchild].pr.running = 1;
-		kida[nchild].infp = fdopen(p1[0], "rb");
+		if (rval != PIPE_BUF)
+			error(CONSISTENCY, "bad value from open_process()");
+					/* connect to child's output */
+		kida[nchild].infp = fdopen(kidpr[nchild].r, "rb");
 		if (kida[nchild].infp == NULL)
 			error(SYSTEM, "out of memory in in_rchild()");
-#ifdef getc_unlocked
-		flockfile(kida[nchild].infp);	/* avoid mutex overhead */
-#endif
 		kida[nchild++].nr = 0;	/* mark as available */
 	}
-	return(0);			/* parent return value */
+#ifdef getc_unlocked
+	for (rval = nchild; rval--; )	/* avoid mutex overhead */
+		flockfile(kida[rval].infp);
 #endif
+	return(0);			/* return "false" in parent */
 }
 
 
 /* Close child processes */
 void
-end_children()
+end_children(int immed)
 {
-	int	status;
-	
-	while (nchild > 0) {
-		nchild--;
-		fclose(kida[nchild].infp);	
-		kida[nchild].pr.r = -1;		/* close(-1) error is ignored */
-		if ((status = close_process(&kida[nchild].pr)) > 0) {
-			sprintf(errmsg,
-				"rendering process returned bad status (%d)",
-					status);
+	int	i;
+
+#ifdef SIGKILL				/* error mode -- quick exit */
+	for (i = nchild*immed; i-- > 0; )
+		kill(kidpr[nchild].pid, SIGKILL);
+#endif
+	if ((i = close_processes(kidpr, nchild)) > 0 && !immed) {
+		sprintf(errmsg, "rendering process returned bad status (%d)",
+					i);
 			error(WARNING, errmsg);
-		}
 	}
+	while (nchild-- > 0)
+		fclose(kida[nchild].infp);
 }
 
 
@@ -383,12 +372,12 @@ tryagain:				/* catch up with output? */
 	n = nr = 0;
 	for (i = nchild; i--; ) {
 		if (kida[i].nr) {
-			FD_SET(kida[i].pr.r, &readset);
+			FD_SET(kidpr[i].r, &readset);
 			++nr;
 		}
-		FD_SET(kida[i].pr.r, &errset);
-		if (kida[i].pr.r >= n)
-			n = kida[i].pr.r + 1;
+		FD_SET(kidpr[i].r, &errset);
+		if (kidpr[i].r >= n)
+			n = kidpr[i].r + 1;
 	}
 	if (!nr)			/* nothing to wait for? */
 		return(-1);
@@ -405,9 +394,9 @@ tryagain:				/* catch up with output? */
 		FD_ZERO(&errset);
 	n = -1;				/* read results from child(ren) */
 	for (i = nchild; i--; ) {
-		if (FD_ISSET(kida[i].pr.r, &errset))
+		if (FD_ISSET(kidpr[i].r, &errset))
 			error(USER, "rendering process died");
-		if (FD_ISSET(kida[i].pr.r, &readset))
+		if (FD_ISSET(kidpr[i].r, &readset))
 			queue_results(n = i);
 	}
 	return(n);			/* first available child */
@@ -418,71 +407,161 @@ tryagain:				/* catch up with output? */
 void
 parental_loop()
 {
-#define	MAXIQ		(int)(PIPE_BUF/(sizeof(FVECT)*2))
-	static int	ignore_warning_given = 0;
-	int		qlimit = (accumulate == 1) ? 1 : MAXIQ-1;
+	const int	qlimit = (accumulate == 1) ? 1 : MAXIQ-1;
 	int		ninq = 0;
 	FVECT		orgdir[2*MAXIQ];
-	double		d;
 	int		i, n;
 					/* load rays from stdin & process */
 #ifdef getc_unlocked
 	flockfile(stdin);		/* avoid lock/unlock overhead */
 #endif
 	while (getvec(orgdir[2*ninq]) == 0 && getvec(orgdir[2*ninq+1]) == 0) {
-		d = normalize(orgdir[1]);
-		if (d == 0.0) {				/* asking for flush? */
-			if (accumulate != 1) {
-				if (!ignore_warning_given++)
-					error(WARNING,
-				"dummy ray(s) ignored during accumulation\n");
-				continue;
-			}
-			while (next_child_nq(1) >= 0)
-				;			/* clear the queue */
-			lastdone = lastray = 0;
-			if ((yres <= 0) | (xres <= 0))
-				waitflush = 1;		/* flush next */
-			put_zero_record(++lastray);
-		} else if (++ninq >= qlimit || accumulate > 1 &&
+		const int	zero_ray = orgdir[2*ninq+1][0] == 0.0 &&
+						(orgdir[2*ninq+1][1] == 0.0) &
+						(orgdir[2*ninq+1][2] == 0.0);
+		ninq += !zero_ray;
+				/* Zero ray cannot go in input queue */
+		if (zero_ray ? ninq : ninq >= qlimit ||
 			    lastray/accumulate != (lastray+ninq)/accumulate) {
 			i = next_child_nq(0);		/* manages output */
 			n = ninq;
-			if (accumulate != 1)		/* request flush? */
+			if (accumulate > 1)		/* need terminator? */
 				memset(orgdir[2*n++], 0, sizeof(FVECT)*2);
 			n *= sizeof(FVECT)*2;		/* send assignment */
-			if (writebuf(kida[i].pr.w, (char *)orgdir, n) != n)
+			if (writebuf(kidpr[i].w, (char *)orgdir, n) != n)
 				error(SYSTEM, "pipe write error");
 			kida[i].r1 = lastray+1;
 			lastray += kida[i].nr = ninq;	/* mark as busy */
-			ninq = 0;
 			if (lastray < lastdone) {	/* RNUMBER wrapped? */
 				while (next_child_nq(1) >= 0)
 					;
-				lastdone = lastray = 0;
+				lastray -= ninq;
+				lastdone = lastray %= accumulate;
 			}
+			ninq = 0;
 		}
-		if (raysleft && !--raysleft)
+		if (zero_ray) {				/* put bogus record? */
+			if ((yres <= 0) | (xres <= 1) &&
+					(lastray+1) % accumulate == 0) {
+				while (next_child_nq(1) >= 0)
+					;		/* clear the queue */
+				lastdone = lastray = accumulate-1;
+				waitflush = 1;		/* flush next */
+			}
+			put_zero_record(++lastray);
+		}
+		if (!morays())
 			break;				/* preemptive EOI */
 	}
 	while (next_child_nq(1) >= 0)		/* empty results queue */
 		;
-						/* output accumulated record */
-	if (accumulate <= 0 || account < accumulate) {
-		end_children();			/* frees up file descriptors */
-		if (account < accumulate) {
-			error(WARNING, "partial accumulation in final record");
-			accumulate -= account;
-		}
-		for (i = 0; i < nmods; i++)
-			mod_output(out_bq->mca[i]);
-		end_record();
-		free_binq(out_bq);
+	if (account < accumulate) {
+		error(WARNING, "partial accumulation in final record");
+		free_binq(out_bq);		/* XXX just ignore it */
 		out_bq = NULL;
 	}
+	free_binq(NULL);			/* clean up */
+	lu_done(&ofiletab);
 	if (raysleft)
 		error(USER, "unexpected EOF on input");
-	free_binq(NULL);			/* clean up */
+}
+
+
+/* Wait for the next available child by monitoring "to" pipes */
+static int
+next_child_ready()
+{
+	fd_set			writeset, errset;
+	int			i, n;
+
+	for (i = nchild; i--; )		/* see if there's one free first */
+		if (!kida[i].nr)
+			return(i);
+					/* prepare select() call */
+	FD_ZERO(&writeset); FD_ZERO(&errset);
+	n = 0;
+	for (i = nchild; i--; ) {
+		FD_SET(kidpr[i].w, &writeset);
+		FD_SET(kidpr[i].r, &errset);
+		if (kidpr[i].w >= n)
+			n = kidpr[i].w + 1;
+		if (kidpr[i].r >= n)
+			n = kidpr[i].r + 1;
+	}
+	errno = 0;
+	n = select(n, NULL, &writeset, &errset, NULL);
+	if (n < 0)
+		error(SYSTEM, "select() error in next_child_ready()");
+	n = -1;				/* identify waiting child */
+	for (i = nchild; i--; ) {
+		if (FD_ISSET(kidpr[i].r, &errset))
+			error(USER, "rendering process died");
+		if (FD_ISSET(kidpr[i].w, &writeset))
+			kida[n = i].nr = 0;
+	}
+	return(n);			/* first available child */
+}
+
+
+/* Modified parental loop for full accumulation mode (-c 0) */
+void
+feeder_loop()
+{
+	static int	ignore_warning_given = 0;
+	int		ninq = 0;
+	FVECT		orgdir[2*MAXIQ];
+	int		i, n;
+					/* load rays from stdin & process */
+#ifdef getc_unlocked
+	flockfile(stdin);		/* avoid lock/unlock overhead */
+#endif
+	while (getvec(orgdir[2*ninq]) == 0 && getvec(orgdir[2*ninq+1]) == 0) {
+		if (orgdir[2*ninq+1][0] == 0.0 &&	/* asking for flush? */
+				(orgdir[2*ninq+1][1] == 0.0) &
+				(orgdir[2*ninq+1][2] == 0.0)) {
+			if (!ignore_warning_given++)
+				error(WARNING,
+				"dummy ray(s) ignored during accumulation\n");
+			continue;
+		} 
+		if (++ninq >= MAXIQ) {
+			i = next_child_ready();		/* get eager child */
+			n = sizeof(FVECT)*2 * ninq;	/* give assignment */
+			if (writebuf(kidpr[i].w, (char *)orgdir, n) != n)
+				error(SYSTEM, "pipe write error");
+			kida[i].r1 = lastray+1;
+			lastray += kida[i].nr = ninq;
+			if (lastray < lastdone)		/* RNUMBER wrapped? */
+				lastdone = lastray = 0;
+			ninq = 0;
+		}
+		if (!morays())
+			break;				/* preemptive EOI */
+	}
+	if (ninq) {				/* polish off input */
+		i = next_child_ready();
+		n = sizeof(FVECT)*2 * ninq;
+		if (writebuf(kidpr[i].w, (char *)orgdir, n) != n)
+			error(SYSTEM, "pipe write error");
+		kida[i].r1 = lastray+1;
+		lastray += kida[i].nr = ninq;
+		ninq = 0;
+	}
+	memset(orgdir, 0, sizeof(FVECT)*2);	/* get results */
+	for (i = nchild; i--; ) {
+		writebuf(kidpr[i].w, (char *)orgdir, sizeof(FVECT)*2);
+		queue_results(i);
+	}
+	if (recover)				/* and from before? */
+		queue_modifiers();
+	end_children(0);			/* free up file descriptors */
+	for (i = 0; i < nmods; i++)
+		mod_output(out_bq->mca[i]);	/* output accumulated record */
+	end_record();
+	free_binq(out_bq);			/* clean up */
+	out_bq = NULL;
+	free_binq(NULL);
 	lu_done(&ofiletab);
-#undef MAXIQ
+	if (raysleft)
+		error(USER, "unexpected EOF on input");
 }