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.3 by greg, Sun Jun 10 05:25:42 2012 UTC vs.
Revision 2.5 by greg, Tue Jun 12 01:06:59 2012 UTC

# Line 14 | Line 14 | static const char RCSid[] = "$Id$";
14   /* Modifier contribution queue (results waiting to be output) */
15   typedef struct s_binq {
16          int             ndx;            /* index for this entry */
17 <        int             n2add;          /* number left to add */
17 >        int             nadded;         /* accumulated so far */
18          struct s_binq   *next;          /* next in queue */
19          MODCONT         *mca[1];        /* contrib. array (extends struct) */
20   } BINQ;
# Line 26 | Line 26 | static SUBPROC kida[MAXPROCESS];       /* child processes */
26   static FILE     *inq_fp[MAXPROCESS];    /* input streams */
27  
28  
29 < /* Get new (empty) bin queue entry */
29 > /* Get new bin queue entry */
30   static BINQ *
31   new_binq()
32   {
33 <        BINQ    *bp = free_bq;
33 >        BINQ    *bp;
34          int     i;
35  
36 <        if (bp != NULL) {               /* something already available? */
36 >        if (free_bq != NULL) {          /* something already available? */
37 >                bp = free_bq;
38                  free_bq = bp->next;
39                  bp->next = NULL;
40 <                bp->n2add = accumulate-1;
40 >                bp->nadded = 1;
41                  return(bp);
42          }
43                                          /* else allocate fresh */
44 <        bp = (BINQ *)malloc(sizeof(BINQ)+(nmods-1)*sizeof(MODCONT *));
44 >        bp = (BINQ *)malloc(sizeof(BINQ) + sizeof(MODCONT *)*(nmods-1));
45          if (bp == NULL)
46                  goto memerr;
47          for (i = nmods; i--; ) {
# Line 53 | Line 54 | new_binq()
54                  /* memset(bp->mca[i]->cbin, 0, sizeof(DCOLOR)*mp->nbins); */
55          }
56          bp->ndx = 0;
57 <        bp->n2add = accumulate-1;
57 >        bp->nadded = 1;
58          bp->next = NULL;
59          return(bp);
60   memerr:
# Line 105 | Line 106 | queue_modifiers()
106                          addcolor(mpout->cbin[j], mpin->cbin[j]);
107                  memset(mpin->cbin, 0, sizeof(DCOLOR)*mpin->nbins);
108          }
109 +        out_bq->nadded++;
110   }
111  
112  
113 < /* Sum one modifier record into another (doesn't update n2add) */
113 > /* Sum one modifier record into another (updates nadded) */
114   static void
115   add_modbin(BINQ *dst, BINQ *src)
116   {
# Line 120 | Line 122 | add_modbin(BINQ *dst, BINQ *src)
122                  for (j = mpout->nbins; j--; )
123                          addcolor(mpout->cbin[j], mpin->cbin[j]);
124          }
125 +        dst->nadded += src->nadded;
126   }
127  
128  
# Line 143 | Line 146 | queue_output(BINQ *bp)
146          for (b_cur = out_bq; b_cur != NULL && b_cur->ndx < bp->ndx;
147                                  b_cur = b_cur->next)
148                  b_last = b_cur;
149 +
150          if (b_last != NULL) {
151                  bp->next = b_cur;
152                  b_last->next = bp;
# Line 154 | Line 158 | queue_output(BINQ *bp)
158                  return;
159          b_cur = out_bq;                 /* else merge accumulation entries */
160          while (b_cur->next != NULL) {
161 <                if (b_cur->n2add <= 0 ||
161 >                if (b_cur->nadded >= accumulate ||
162                                  (b_cur->ndx-1)/accumulate !=
163                                  (b_cur->next->ndx-1)/accumulate) {
164                          b_cur = b_cur->next;
165                          continue;
166                  }
167                  add_modbin(b_cur, b_cur->next);
164 –                b_cur->n2add--;
168                  b_last = b_cur->next;
169                  b_cur->next = b_last->next;
170                  b_last->next = NULL;
# Line 170 | Line 173 | queue_output(BINQ *bp)
173   }
174  
175  
176 < /* Get current with output queue by producing ready results */
176 > /* Count number of records ready for output */
177   static int
178 < output_catchup()
178 > queue_ready()
179   {
180 +        int     nready = 0;
181 +        BINQ    *bp;
182 +
183 +        if (accumulate <= 0)            /* just accumulating? */
184 +                return(0);
185 +
186 +        for (bp = out_bq; bp != NULL && bp->nadded >= accumulate &&
187 +                                bp->ndx == lastdone+nready*accumulate+1;
188 +                                bp = bp->next)
189 +                ++nready;
190 +
191 +        return(nready);
192 + }
193 +
194 +
195 + /* Catch up with output queue by producing ready results */
196 + static int
197 + output_catchup(int nmax)
198 + {
199          int     nout = 0;
200          BINQ    *bp;
201          int     i;
# Line 181 | Line 203 | output_catchup()
203          if (accumulate <= 0)            /* just accumulating? */
204                  return(0);
205                                          /* else output ready results */
206 <        while (out_bq != NULL && (out_bq->ndx == lastdone+1) & !out_bq->n2add) {
206 >        while (out_bq != NULL && out_bq->nadded >= accumulate
207 >                                && out_bq->ndx == lastdone+1) {
208 >                if ((nmax > 0) & (nout >= nmax))
209 >                        break;
210                  bp = out_bq;                    /* pop off first entry */
211                  out_bq = bp->next;
212                  bp->next = NULL;
# Line 207 | Line 232 | put_zero_record(int ndx)
232                  memset(bp->mca[i]->cbin, 0, sizeof(DCOLOR)*bp->mca[i]->nbins);
233          bp->ndx = ndx;
234          queue_output(bp);
235 <        output_catchup();
235 >        output_catchup(0);
236   }
237  
238  
# Line 240 | Line 265 | in_rchild()
265                  pid = fork();           /* fork parent process */
266                  if (pid == 0) {         /* if in child, set up & return true */
267                          close(p0[1]); close(p1[0]);
268 +                        lu_doall(&modconttab, set_stdout, NULL);
269 +                        lu_done(&ofiletab);
270 +                        while (nchild--) {      /* don't share other pipes */
271 +                                close(kida[nchild].w);
272 +                                fclose(inq_fp[nchild]);
273 +                        }
274                          dup2(p0[0], 0); close(p0[0]);
275                          dup2(p1[1], 1); close(p1[1]);
276                          inpfmt = (sizeof(RREAL)==sizeof(double)) ? 'd' : 'f';
# Line 249 | Line 280 | in_rchild()
280                          yres = 0;
281                          raysleft = 0;
282                          account = accumulate = 1;
252 –                        lu_doall(&modconttab, set_stdout, NULL);
253 –                        nchild = -1;
283                          return(1);      /* child return value */
284                  }
285                  if (pid < 0)
# Line 280 | Line 309 | end_children()
309   {
310          int     status;
311          
312 <        while (nchild-- > 0) {
312 >        while (nchild > 0) {
313 >                nchild--;
314                  kida[nchild].r = -1;    /* close(-1) error is ignored */
315                  if ((status = close_process(&kida[nchild])) > 0) {
316                          sprintf(errmsg,
# Line 293 | Line 323 | end_children()
323   }
324  
325  
326 < /* Wait for the next available child, managing output queue as well */
326 > /* Wait for the next available child, managing output queue simultaneously */
327   static int
328 < next_child_nq(int force_wait)
328 > next_child_nq(int flushing)
329   {
330          static struct timeval   polling;
331 <        struct timeval          *pmode = force_wait | (accumulate <= 0) ?
302 <                                        (struct timeval *)NULL : &polling;
331 >        struct timeval          *pmode;
332          fd_set                  readset, errset;
333 <        int                     i, j, n, nr;
333 >        int                     i, j, n, nr, nqr;
334  
335 <        if (!force_wait)                /* see if there's one free */
335 >        if (!flushing)                  /* see if there's one free */
336                  for (i = nchild; i--; )
337                          if (kida[i].running < 0)
338                                  return(i);
339 +
340 +        nqr = queue_ready();            /* choose blocking mode or polling */
341 +        if ((nqr > 0) & !flushing)
342 +                pmode = &polling;
343 +        else
344 +                pmode = NULL;
345 + tryagain:                               /* catch up with output? */
346 +        if (pmode == &polling) {
347 +                if (nqr > nchild)       /* don't get too far behind */
348 +                        nqr -= output_catchup(nqr-nchild);
349 +        } else if (nqr > 0)             /* clear output before blocking */
350 +                nqr -= output_catchup(0);
351                                          /* prepare select() call */
352          FD_ZERO(&readset); FD_ZERO(&errset);
353          n = nr = 0;
# Line 319 | Line 360 | next_child_nq(int force_wait)
360                  if (kida[i].r >= n)
361                          n = kida[i].r + 1;
362          }
322 – tryagain:
323 –        if (pmode == NULL)              /* catch up in case we block */
324 –                output_catchup();
363          if (!nr)                        /* nothing to wait for? */
364                  return(-1);
365          if ((nr > 1) | (pmode == &polling)) {
366                  errno = 0;
367 <                i = select(n, &readset, NULL, &errset, pmode);
368 <                if (!i) {
367 >                nr = select(n, &readset, NULL, &errset, pmode);
368 >                if (!nr) {
369                          pmode = NULL;   /* try again, blocking this time */
370                          goto tryagain;
371                  }
372 <                if (i < 0)
372 >                if (nr < 0)
373                          error(SYSTEM, "select() error in next_child_nq()");
374          } else
375                  FD_ZERO(&errset);
# Line 387 | Line 425 | parental_loop()
425                  }
426                  if (d == 0.0) {
427                          if ((yres <= 0) | (xres <= 0))
428 <                                waitflush = 1;          /* flush right after */
428 >                                waitflush = 1;          /* flush next */
429                          put_zero_record(++lastray);
430                  } else {                                /* else assign ray */
431 <                        i = next_child_nq(0);
431 >                        i = next_child_nq(0);           /* manages output */
432                          if (writebuf(kida[i].w, (char *)orgdir,
433                                          sizeof(orgdir)) != sizeof(orgdir))
434                                  error(SYSTEM, "pipe write error");
435 <                        kida[i].running = ++lastray;
435 >                        kida[i].running = ++lastray;    /* busy now */
436                  }
437                  if (raysleft && !--raysleft)
438                          break;                          /* preemptive EOI */
# Line 403 | Line 441 | parental_loop()
441                  ;
442                                                  /* output accumulated record */
443          if (accumulate <= 0 || account < accumulate) {
444 +                end_children();                 /* frees up file descriptors */
445                  if (account < accumulate) {
446                          error(WARNING, "partial accumulation in final record");
447                          accumulate -= account;

Diff Legend

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