ViewVC Help

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

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

Comparing ray/src/rt/raypcalls.c (file contents):
Revision 2.13 by greg, Tue Dec 20 20:36:44 2005 UTC vs.
Revision 2.19 by greg, Wed Feb 20 05:21:29 2008 UTC

#	Line 30 | Line 30 | static const char      RCSid[] = "$Id$";
30		*  between processes.  Rays are then traced using a simple
31		*  queuing mechanism, explained below.
32		*
33	<	*  The ray queue holds at least RAYQLEN rays, up to
34	<	*  as many rays as there are rendering processes.
33	>	*  The ray queue buffers RAYQLEN rays before sending to
34	>	*  children, each of which may internally buffer RAYQLEN rays.
35	>	*
36		*  Rays are queued and returned by a single
37		*  ray_pqueue() call.  A ray_pqueue() return
38		*  value of 0 indicates that no rays are ready
#	Line 130 | Line 131 | static const char      RCSid[] = "$Id$";
131		*  process should not be compromised.
132		*/
133
133	–	#include <stdio.h>
134	–	#include <sys/types.h>
135	–	#include <sys/wait.h> /* XXX platform */
136	–
134		#include  "rtprocess.h"
135		#include  "ray.h"
136		#include  "ambient.h"
137	+	#include  <sys/types.h>
138	+	#include  <sys/wait.h>
139		#include  "selcall.h"
140
141		#ifndef RAYQLEN
#	Line 245 | Line 244 | ray_psend(                     /* add a ray to our send queue */
244		if (sendq_full() && ray_pflush() <= 0)
245		error(INTERNAL, "ray_pflush failed in ray_psend");
246
247	<	r_queue[r_send_next] = *r;
249	<	r_send_next++;
247	>	r_queue[r_send_next++] = *r;
248		}
249
250
#	Line 259 | Line 257 | ray_pqueue(                    /* queue a ray for computation */
257		return(0);
258		/* check for full send queue */
259		if (sendq_full()) {
260	<	RAY     mySend;
263	<	int     rval;
264	<	mySend = *r;
260	>	RAY     mySend = *r;
261		/* wait for a result */
262	<	rval = ray_presult(r, 0);
262	>	if (ray_presult(r, 0) <= 0)
263	>	return(-1);
264		/* put new ray in queue */
265	<	r_queue[r_send_next] = mySend;
266	<	r_send_next++;
267	<	return(rval);           /* done */
265	>	r_queue[r_send_next++] = mySend;
266	>	/* XXX r_send_next may now be > RAYQLEN */
267	>	return(1);
268		}
269		/* else add ray to send queue */
270	<	r_queue[r_send_next] = *r;
274	<	r_send_next++;
270	>	r_queue[r_send_next++] = *r;
271		/* check for returned ray... */
272		if (r_recv_first >= r_recv_next)
273		return(0);
274		/* ...one is sitting in queue */
275	<	*r = r_queue[r_recv_first];
280	<	r_recv_first++;
275	>	*r = r_queue[r_recv_first++];
276		return(1);
277		}
278
#	Line 297 | Line 292 | ray_presult(           /* check for a completed ray */
292		return(0);
293		/* check queued results first */
294		if (r_recv_first < r_recv_next) {
295	<	*r = r_queue[r_recv_first];
301	<	r_recv_first++;
295	>	*r = r_queue[r_recv_first++];
296		return(1);
297		}
298		n = ray_pnprocs - ray_pnidle;   /* pending before flush? */
#	Line 312 | Line 306 | ray_presult(           /* check for a completed ray */
306		n = ray_pnprocs - ray_pnidle;
307		if (n <= 0)                     /* return if nothing to await */
308		return(0);
309	+	if (!poll && ray_pnprocs == 1)  /* one process -> skip select() */
310	+	FD_SET(r_proc[0].fd_recv, &readset);
311	+
312		getready:                               /* any children waiting for us? */
313		for (pn = ray_pnprocs; pn--; )
314		if (FD_ISSET(r_proc[pn].fd_recv, &readset) ||
#	Line 400 | Line 397 | ray_pchild(    /* process rays (never returns) */
397		{
398		int     n;
399		register int    i;
400	+	/* flag child process for quit() */
401	+	ray_pnprocs = -1;
402		/* read each ray request set */
403		while ((n = read(fd_in, (char *)r_queue, sizeof(r_queue))) > 0) {
404		int     n2;
#	Line 523 | Line 522 | void
522		quit(ec)                        /* make sure exit is called */
523		int     ec;
524		{
525	+	if (ray_pnprocs > 0)    /* close children if any */
526	+	ray_pclose(0);
527		exit(ec);
528		}

Diff Legend

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