ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/rc3.c

Comparing ray/src/rt/rc3.c (file contents):
Revision 2.9 by greg, Thu Jun 14 05:13:25 2012 UTC vs.
Revision 2.16 by greg, Fri Jun 22 21:58:45 2012 UTC

#	Line 6 | Line 6 | static const char RCSid[] = "$Id$";
6		* Controlling process for multiple children
7		*/
8
9	+	#include <signal.h>
10		#include "rcontrib.h"
10	–	#include "platform.h"
11	–	#include "rtprocess.h"
11		#include "selcall.h"
12
13	+	#define MAXIQ           (int)(PIPE_BUF/(sizeof(FVECT)*2))
14	+
15		/* Modifier contribution queue (results waiting to be output) */
16		typedef struct s_binq {
17		RNUMBER         ndx;            /* index for this entry */
#	Line 26 | Line 27 | static struct {
27		RNUMBER r1;                     /* assigned ray starting index */
28		SUBPROC pr;                     /* PID, i/o descriptors */
29		FILE    *infp;                  /* file pointer to read from process */
30	<	int     nr;                     /* number rays to sum (0 if free) */
30	>	int     nr;                     /* number of rays to sum (0 if free) */
31		} kida[MAXPROCESS];             /* our child processes */
32
33
#	Line 94 | Line 95 | free_binq(BINQ *bp)
95
96
97		/* Add modifier values to accumulation record in queue and clear */
98	<	void
98	>	static void
99		queue_modifiers()
100		{
101		MODCONT *mpin, *mpout;
#	Line 146 | Line 147 | queue_output(BINQ *bp)
147		}
148		return;
149		}
150	<	b_last = NULL;                  /* else insert in output queue */
150	>	b_last = NULL;                  /* insert in output queue */
151		for (b_cur = out_bq; b_cur != NULL && b_cur->ndx < bp->ndx;
152		b_cur = b_cur->next)
153		b_last = b_cur;
#	Line 184 | Line 185 | queue_ready()
185		int     nready = 0;
186		BINQ    *bp;
187
187	–	if (accumulate <= 0)            /* just accumulating? */
188	–	return(0);
189	–
188		for (bp = out_bq; bp != NULL && bp->nadded >= accumulate &&
189		bp->ndx == lastdone+nready*accumulate+1;
190		bp = bp->next)
#	Line 203 | Line 201 | output_catchup(int nmax)
201		int     nout = 0;
202		BINQ    *bp;
203		int     i;
204	<
207	<	if (accumulate <= 0)            /* just accumulating? */
208	<	return(0);
209	<	/* else output ready results */
204	>	/* output ready results */
205		while (out_bq != NULL && out_bq->nadded >= accumulate
206		&& out_bq->ndx == lastdone+1) {
207		if ((nmax > 0) & (nout >= nmax))
#	Line 319 | Line 314 | in_rchild()
314
315		/* Close child processes */
316		void
317	<	end_children()
317	>	end_children(int immed)
318		{
319		int     status;
320
321		while (nchild > 0) {
322		nchild--;
323	<	if ((status = close_process(&kida[nchild].pr)) > 0) {
323	>	#ifdef SIGKILL
324	>	if (immed)              /* error mode -- quick exit */
325	>	kill(kida[nchild].pr.pid, SIGKILL);
326	>	#endif
327	>	if ((status = close_process(&kida[nchild].pr)) > 0 && !immed) {
328		sprintf(errmsg,
329		"rendering process returned bad status (%d)",
330		status);
#	Line 401 | Line 400 | tryagain:                              /* catch up with output? */
400		void
401		parental_loop()
402		{
404	–	#define MAXIQ           (int)(PIPE_BUF/(sizeof(FVECT)*2))
403		static int      ignore_warning_given = 0;
404		int             qlimit = (accumulate == 1) ? 1 : MAXIQ-1;
405		int             ninq = 0;
#	Line 427 | Line 425 | parental_loop()
425		if ((yres <= 0) | (xres <= 0))
426		waitflush = 1;          /* flush next */
427		put_zero_record(++lastray);
428	<	} else if (++ninq >= qlimit || accumulate > 1 &&
428	>	} else if (++ninq >= qlimit ||
429		lastray/accumulate != (lastray+ninq)/accumulate) {
430		i = next_child_nq(0);           /* manages output */
431		n = ninq;
#	Line 450 | Line 448 | parental_loop()
448		}
449		while (next_child_nq(1) >= 0)           /* empty results queue */
450		;
451	<	/* output accumulated record */
452	<	if (accumulate <= 0 || account < accumulate) {
453	<	end_children();                 /* frees up file descriptors */
456	<	if (account < accumulate) {
457	<	error(WARNING, "partial accumulation in final record");
458	<	accumulate -= account;
459	<	}
460	<	for (i = 0; i < nmods; i++)
461	<	mod_output(out_bq->mca[i]);
462	<	end_record();
463	<	free_binq(out_bq);
451	>	if (account < accumulate) {
452	>	error(WARNING, "partial accumulation in final record");
453	>	free_binq(out_bq);              /* XXX just ignore it */
454		out_bq = NULL;
455		}
456	+	free_binq(NULL);                        /* clean up */
457	+	lu_done(&ofiletab);
458		if (raysleft)
459		error(USER, "unexpected EOF on input");
460	<	free_binq(NULL);                        /* clean up */
460	>	}
461	>
462	>
463	>	/* Wait for the next available child by monitoring "to" pipes */
464	>	static int
465	>	next_child_ready()
466	>	{
467	>	fd_set                  writeset, errset;
468	>	int                     i, n;
469	>
470	>	for (i = nchild; i--; )         /* see if there's one free first */
471	>	if (!kida[i].nr)
472	>	return(i);
473	>	/* prepare select() call */
474	>	FD_ZERO(&writeset); FD_ZERO(&errset);
475	>	n = 0;
476	>	for (i = nchild; i--; ) {
477	>	FD_SET(kida[i].pr.w, &writeset);
478	>	FD_SET(kida[i].pr.r, &errset);
479	>	if (kida[i].pr.w >= n)
480	>	n = kida[i].pr.w + 1;
481	>	if (kida[i].pr.r >= n)
482	>	n = kida[i].pr.r + 1;
483	>	}
484	>	errno = 0;
485	>	n = select(n, NULL, &writeset, &errset, NULL);
486	>	if (n < 0)
487	>	error(SYSTEM, "select() error in next_child_ready()");
488	>	n = -1;                         /* identify waiting child */
489	>	for (i = nchild; i--; ) {
490	>	if (FD_ISSET(kida[i].pr.r, &errset))
491	>	error(USER, "rendering process died");
492	>	if (FD_ISSET(kida[i].pr.w, &writeset))
493	>	kida[n = i].nr = 0;
494	>	}
495	>	return(n);                      /* first available child */
496	>	}
497	>
498	>
499	>	/* Modified parental loop for full accumulation mode (-c 0) */
500	>	void
501	>	feeder_loop()
502	>	{
503	>	static int      ignore_warning_given = 0;
504	>	int             ninq = 0;
505	>	FVECT           orgdir[2*MAXIQ];
506	>	int             i, n;
507	>	/* load rays from stdin & process */
508	>	#ifdef getc_unlocked
509	>	flockfile(stdin);               /* avoid lock/unlock overhead */
510	>	#endif
511	>	while (getvec(orgdir[2*ninq]) == 0 && getvec(orgdir[2*ninq+1]) == 0) {
512	>	if (orgdir[2*ninq+1][0] == 0.0 &&       /* asking for flush? */
513	>	(orgdir[2*ninq+1][1] == 0.0) &
514	>	(orgdir[2*ninq+1][2] == 0.0)) {
515	>	if (!ignore_warning_given++)
516	>	error(WARNING,
517	>	"dummy ray(s) ignored during accumulation\n");
518	>	continue;
519	>	}
520	>	if (++ninq >= MAXIQ) {
521	>	i = next_child_ready();         /* get eager child */
522	>	n = sizeof(FVECT)*2 * ninq;     /* give assignment */
523	>	if (writebuf(kida[i].pr.w, (char *)orgdir, n) != n)
524	>	error(SYSTEM, "pipe write error");
525	>	kida[i].r1 = lastray+1;
526	>	lastray += kida[i].nr = ninq;
527	>	ninq = 0;
528	>	if (lastray < lastdone)         /* RNUMBER wrapped? */
529	>	lastdone = lastray = 0;
530	>	}
531	>	if (raysleft && !--raysleft)
532	>	break;                          /* preemptive EOI */
533	>	}
534	>	if (ninq) {                             /* polish off input */
535	>	i = next_child_ready();
536	>	n = sizeof(FVECT)*2 * ninq;
537	>	if (writebuf(kida[i].pr.w, (char *)orgdir, n) != n)
538	>	error(SYSTEM, "pipe write error");
539	>	kida[i].r1 = lastray+1;
540	>	lastray += kida[i].nr = ninq;
541	>	ninq = 0;
542	>	}
543	>	memset(orgdir, 0, sizeof(FVECT)*2);     /* get results */
544	>	for (i = nchild; i--; ) {
545	>	writebuf(kida[i].pr.w, (char *)orgdir, sizeof(FVECT)*2);
546	>	queue_results(i);
547	>	}
548	>	if (recover)                            /* and from before? */
549	>	queue_modifiers();
550	>	end_children(0);                        /* free up file descriptors */
551	>	for (i = 0; i < nmods; i++)
552	>	mod_output(out_bq->mca[i]);     /* output accumulated record */
553	>	end_record();
554	>	free_binq(out_bq);                      /* clean up */
555	>	out_bq = NULL;
556	>	free_binq(NULL);
557		lu_done(&ofiletab);
558	<	#undef MAXIQ
558	>	if (raysleft)
559	>	error(USER, "unexpected EOF on input");
560		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)