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

Comparing ray/src/rt/rc3.c (file contents):
Revision 2.19 by greg, Fri Aug 21 18:21:05 2015 UTC vs.
Revision 2.21 by greg, Fri Mar 4 02:48:14 2016 UTC

# Line 23 | Line 23 | typedef struct s_binq {
23   static BINQ     *out_bq = NULL;         /* output bin queue */
24   static BINQ     *free_bq = NULL;        /* free queue entries */
25  
26 + static SUBPROC  kidpr[MAXPROCESS];      /* our child processes */
27 +
28   static struct {
29          RNUMBER r1;                     /* assigned ray starting index */
28 –        SUBPROC pr;                     /* PID, i/o descriptors */
30          FILE    *infp;                  /* file pointer to read from process */
31          int     nr;                     /* number of rays to sum (0 if free) */
32 < } kida[MAXPROCESS];             /* our child processes */
32 > } kida[MAXPROCESS];             /* our child process i/o */
33  
34  
35   /* Get new bin queue entry */
# Line 265 | Line 266 | set_stdout(const LUENT *le, void *p)
266   }
267  
268  
269 < /* Start child processes if we can */
269 > /* Start child processes if we can (call only once in parent!) */
270   int
271   in_rchild()
272   {
# Line 273 | Line 274 | in_rchild()
274  
275          while (nchild < nproc) {        /* fork until target reached */
276                  errno = 0;
277 <                rval = open_process(&kida[nchild].pr, NULL);
277 >                rval = open_process(&kidpr[nchild], NULL);
278                  if (rval < 0)
279                          error(SYSTEM, "open_process() call failed");
280                  if (rval == 0) {        /* if in child, set up & return true */
281                          lu_doall(&modconttab, &set_stdout, NULL);
282                          lu_done(&ofiletab);
283                          while (nchild--) {      /* don't share other pipes */
284 <                                close(kida[nchild].pr.w);
284 >                                close(kidpr[nchild].w);
285                                  fclose(kida[nchild].infp);
286                          }
287                          inpfmt = (sizeof(RREAL)==sizeof(double)) ? 'd' : 'f';
# Line 300 | Line 301 | in_rchild()
301                  if (rval != PIPE_BUF)
302                          error(CONSISTENCY, "bad value from open_process()");
303                                          /* connect to child's output */
304 <                kida[nchild].infp = fdopen(kida[nchild].pr.r, "rb");
304 >                kida[nchild].infp = fdopen(kidpr[nchild].r, "rb");
305                  if (kida[nchild].infp == NULL)
306                          error(SYSTEM, "out of memory in in_rchild()");
306 – #if 0
307 –                flockfile(kida[nchild].infp);   /* avoid mutex overhead */
308 – #endif
307                  kida[nchild++].nr = 0;  /* mark as available */
308          }
309 + #ifdef getc_unlocked
310 +        for (rval = nchild; rval--; )   /* avoid mutex overhead */
311 +                flockfile(kida[rval].infp);
312 + #endif
313          return(0);                      /* return "false" in parent */
314   }
315  
# Line 316 | Line 318 | in_rchild()
318   void
319   end_children(int immed)
320   {
321 <        int     status;
322 <        
323 <        while (nchild > 0) {
324 <                nchild--;
325 < #ifdef SIGKILL
324 <                if (immed)              /* error mode -- quick exit */
325 <                        kill(kida[nchild].pr.pid, SIGKILL);
321 >        int     i;
322 >
323 > #ifdef SIGKILL                          /* error mode -- quick exit */
324 >        for (i = nchild*immed; i-- > 0; )
325 >                kill(kidpr[nchild].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);
327 >        if ((i = close_processes(kidpr, nchild)) > 0 && !immed) {
328 >                sprintf(errmsg, "rendering process returned bad status (%d)",
329 >                                        i);
330                          error(WARNING, errmsg);
332 –                }
333 –                fclose(kida[nchild].infp);
331          }
332 +        while (nchild-- > 0)
333 +                fclose(kida[nchild].infp);
334   }
335  
336  
# Line 365 | Line 364 | tryagain:                              /* catch up with output? */
364          n = nr = 0;
365          for (i = nchild; i--; ) {
366                  if (kida[i].nr) {
367 <                        FD_SET(kida[i].pr.r, &readset);
367 >                        FD_SET(kidpr[i].r, &readset);
368                          ++nr;
369                  }
370 <                FD_SET(kida[i].pr.r, &errset);
371 <                if (kida[i].pr.r >= n)
372 <                        n = kida[i].pr.r + 1;
370 >                FD_SET(kidpr[i].r, &errset);
371 >                if (kidpr[i].r >= n)
372 >                        n = kidpr[i].r + 1;
373          }
374          if (!nr)                        /* nothing to wait for? */
375                  return(-1);
# Line 387 | Line 386 | tryagain:                              /* catch up with output? */
386                  FD_ZERO(&errset);
387          n = -1;                         /* read results from child(ren) */
388          for (i = nchild; i--; ) {
389 <                if (FD_ISSET(kida[i].pr.r, &errset))
389 >                if (FD_ISSET(kidpr[i].r, &errset))
390                          error(USER, "rendering process died");
391 <                if (FD_ISSET(kida[i].pr.r, &readset))
391 >                if (FD_ISSET(kidpr[i].r, &readset))
392                          queue_results(n = i);
393          }
394          return(n);                      /* first available child */
# Line 421 | Line 420 | parental_loop()
420                          if (accumulate > 1)             /* need terminator? */
421                                  memset(orgdir[2*n++], 0, sizeof(FVECT)*2);
422                          n *= sizeof(FVECT)*2;           /* send assignment */
423 <                        if (writebuf(kida[i].pr.w, (char *)orgdir, n) != n)
423 >                        if (writebuf(kidpr[i].w, (char *)orgdir, n) != n)
424                                  error(SYSTEM, "pipe write error");
425                          kida[i].r1 = lastray+1;
426                          lastray += kida[i].nr = ninq;   /* mark as busy */
# Line 474 | Line 473 | next_child_ready()
473          FD_ZERO(&writeset); FD_ZERO(&errset);
474          n = 0;
475          for (i = nchild; i--; ) {
476 <                FD_SET(kida[i].pr.w, &writeset);
477 <                FD_SET(kida[i].pr.r, &errset);
478 <                if (kida[i].pr.w >= n)
479 <                        n = kida[i].pr.w + 1;
480 <                if (kida[i].pr.r >= n)
481 <                        n = kida[i].pr.r + 1;
476 >                FD_SET(kidpr[i].w, &writeset);
477 >                FD_SET(kidpr[i].r, &errset);
478 >                if (kidpr[i].w >= n)
479 >                        n = kidpr[i].w + 1;
480 >                if (kidpr[i].r >= n)
481 >                        n = kidpr[i].r + 1;
482          }
483          errno = 0;
484          n = select(n, NULL, &writeset, &errset, NULL);
# Line 487 | Line 486 | next_child_ready()
486                  error(SYSTEM, "select() error in next_child_ready()");
487          n = -1;                         /* identify waiting child */
488          for (i = nchild; i--; ) {
489 <                if (FD_ISSET(kida[i].pr.r, &errset))
489 >                if (FD_ISSET(kidpr[i].r, &errset))
490                          error(USER, "rendering process died");
491 <                if (FD_ISSET(kida[i].pr.w, &writeset))
491 >                if (FD_ISSET(kidpr[i].w, &writeset))
492                          kida[n = i].nr = 0;
493          }
494          return(n);                      /* first available child */
# Line 520 | Line 519 | feeder_loop()
519                  if (++ninq >= MAXIQ) {
520                          i = next_child_ready();         /* get eager child */
521                          n = sizeof(FVECT)*2 * ninq;     /* give assignment */
522 <                        if (writebuf(kida[i].pr.w, (char *)orgdir, n) != n)
522 >                        if (writebuf(kidpr[i].w, (char *)orgdir, n) != n)
523                                  error(SYSTEM, "pipe write error");
524                          kida[i].r1 = lastray+1;
525                          lastray += kida[i].nr = ninq;
# Line 534 | Line 533 | feeder_loop()
533          if (ninq) {                             /* polish off input */
534                  i = next_child_ready();
535                  n = sizeof(FVECT)*2 * ninq;
536 <                if (writebuf(kida[i].pr.w, (char *)orgdir, n) != n)
536 >                if (writebuf(kidpr[i].w, (char *)orgdir, n) != n)
537                          error(SYSTEM, "pipe write error");
538                  kida[i].r1 = lastray+1;
539                  lastray += kida[i].nr = ninq;
# Line 542 | Line 541 | feeder_loop()
541          }
542          memset(orgdir, 0, sizeof(FVECT)*2);     /* get results */
543          for (i = nchild; i--; ) {
544 <                writebuf(kida[i].pr.w, (char *)orgdir, sizeof(FVECT)*2);
544 >                writebuf(kidpr[i].w, (char *)orgdir, sizeof(FVECT)*2);
545                  queue_results(i);
546          }
547          if (recover)                            /* and from before? */

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines