ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/raypcalls.c
(Generate patch)

Comparing ray/src/rt/raypcalls.c (file contents):
Revision 2.13 by greg, Tue Dec 20 20:36:44 2005 UTC vs.
Revision 2.20 by greg, Tue Dec 2 23:28:34 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 186 | Line 185 | ray_pinit(             /* initialize ray-tracing processes */
185  
186          ray_init(otnm);                 /* load the shared scene */
187  
189 –        preload_objs();                 /* preload auxiliary data */
190 –
191 –                                        /* set shared memory boundary */
192 –        shm_boundary = (char *)malloc(16);
193 –        strcpy(shm_boundary, "SHM_BOUNDARY");
194 –
188          r_send_next = 0;                /* set up queue */
189          r_recv_first = r_recv_next = RAYQLEN;
190  
# Line 245 | Line 238 | ray_psend(                     /* add a ray to our send queue */
238          if (sendq_full() && ray_pflush() <= 0)
239                  error(INTERNAL, "ray_pflush failed in ray_psend");
240  
241 <        r_queue[r_send_next] = *r;
249 <        r_send_next++;
241 >        r_queue[r_send_next++] = *r;
242   }
243  
244  
# Line 259 | Line 251 | ray_pqueue(                    /* queue a ray for computation */
251                  return(0);
252                                          /* check for full send queue */
253          if (sendq_full()) {
254 <                RAY     mySend;
263 <                int     rval;
264 <                mySend = *r;
254 >                RAY     mySend = *r;
255                                          /* wait for a result */
256 <                rval = ray_presult(r, 0);
256 >                if (ray_presult(r, 0) <= 0)
257 >                        return(-1);
258                                          /* put new ray in queue */
259 <                r_queue[r_send_next] = mySend;
260 <                r_send_next++;
261 <                return(rval);           /* done */
259 >                r_queue[r_send_next++] = mySend;
260 >                                /* XXX r_send_next may now be > RAYQLEN */
261 >                return(1);
262          }
263                                          /* else add ray to send queue */
264 <        r_queue[r_send_next] = *r;
274 <        r_send_next++;
264 >        r_queue[r_send_next++] = *r;
265                                          /* check for returned ray... */
266          if (r_recv_first >= r_recv_next)
267                  return(0);
268                                          /* ...one is sitting in queue */
269 <        *r = r_queue[r_recv_first];
280 <        r_recv_first++;
269 >        *r = r_queue[r_recv_first++];
270          return(1);
271   }
272  
# Line 297 | Line 286 | ray_presult(           /* check for a completed ray */
286                  return(0);
287                                          /* check queued results first */
288          if (r_recv_first < r_recv_next) {
289 <                *r = r_queue[r_recv_first];
301 <                r_recv_first++;
289 >                *r = r_queue[r_recv_first++];
290                  return(1);
291          }
292          n = ray_pnprocs - ray_pnidle;   /* pending before flush? */
# Line 312 | Line 300 | ray_presult(           /* check for a completed ray */
300                  n = ray_pnprocs - ray_pnidle;
301          if (n <= 0)                     /* return if nothing to await */
302                  return(0);
303 +        if (!poll && ray_pnprocs == 1)  /* one process -> skip select() */
304 +                FD_SET(r_proc[0].fd_recv, &readset);
305 +
306   getready:                               /* any children waiting for us? */
307          for (pn = ray_pnprocs; pn--; )
308                  if (FD_ISSET(r_proc[pn].fd_recv, &readset) ||
# Line 400 | Line 391 | ray_pchild(    /* process rays (never returns) */
391   {
392          int     n;
393          register int    i;
394 +                                        /* flag child process for quit() */
395 +        ray_pnprocs = -1;
396                                          /* read each ray request set */
397          while ((n = read(fd_in, (char *)r_queue, sizeof(r_queue))) > 0) {
398                  int     n2;
# Line 449 | Line 442 | ray_popen(                     /* open the specified # processes */
442          if (nadd <= 0)
443                  return;
444          ambsync();                      /* load any new ambient values */
445 +        if (shm_boundary == NULL) {     /* first child process? */
446 +                preload_objs();         /* preload auxiliary data */
447 +                                        /* set shared memory boundary */
448 +                shm_boundary = (char *)malloc(16);
449 +                strcpy(shm_boundary, "SHM_BOUNDARY");
450 +        }
451          fflush(NULL);                   /* clear pending output */
452          while (nadd--) {                /* fork each new process */
453                  int     p0[2], p1[2];
# 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
> Changed lines