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

Comparing ray/src/hd/rholo.c (file contents):
Revision 3.14 by gregl, Mon Dec 1 16:34:21 1997 UTC vs.
Revision 3.21 by gregl, Fri Dec 12 18:12:40 1997 UTC

# Line 26 | Line 26 | char   froot[MAXPATH];         /* root file name */
26  
27   int     nowarn = 0;             /* turn warnings off? */
28  
29 – double  expval = 1.;            /* global exposure value */
30 –
29   int     ncprocs = 0;            /* desired number of compute processes */
30  
31   char    *outdev = NULL;         /* output device name */
32  
33 + int     readinp = 0;            /* read commands from stdin */
34 +
35 + int     force = 0;              /* allow overwrite of holodeck */
36 +
37   time_t  starttime;              /* time we got started */
38   time_t  endtime;                /* time we should end by */
39   time_t  reporttime;             /* time for next report */
# Line 59 | Line 61 | char   *argv[];
61   {
62          HDGRID  hdg;
63          int     i;
62 –        int     force = 0;
64                                                  /* mark start time */
65          starttime = time(NULL);
66 <        initurand(10240);                       /* initialize urand */
66 >        initurand(16384);                       /* initialize urand */
67          progname = argv[0];                     /* get arguments */
68          for (i = 1; i < argc && argv[i][0] == '-'; i++)
69                  switch (argv[i][1]) {
# Line 72 | Line 73 | char   *argv[];
73                  case 'f':                       /* force overwrite */
74                          force++;
75                          break;
76 +                case 'i':                       /* read input from stdin */
77 +                        readinp++;
78 +                        break;
79                  case 'n':                       /* compute processes */
80                          if (i >= argc-2)
81                                  goto userr;
# Line 115 | Line 119 | char   *argv[];
119                  creatholo(&hdg);
120          } else {                                /* else load holodeck */
121                  loadholo();
122 <                if (vdef(RIF))                          /* load RIF if any */
122 >                                                        /* check settings */
123 >                checkvalues();
124 >                                                        /* load RIF if any */
125 >                if (vdef(RIF))
126                          getradfile(vval(RIF));
127 +                                                        /* set defaults */
128 +                setdefaults(NULL);
129          }
130                                                  /* initialize */
131          initrholo();
132 <                                                /* run */
132 >                                                /* main loop */
133          while (rholo())
134                  ;
135                                                  /* done */
# Line 184 | Line 193 | initrholo()                    /* get our holodeck running */
193   {
194          extern int      global_packet();
195          register int    i;
196 +                                                /* close holodeck on exec() */
197 +        fcntl(hdlist[0]->fd, F_SETFD, FD_CLOEXEC);
198  
199          if (outdev != NULL)                     /* open output device */
200                  disp_open(outdev);
# Line 214 | Line 225 | initrholo()                    /* get our holodeck running */
225          if (ncprocs > 0) {
226                  i = start_rtrace();
227                  if (i < 1)
228 <                        error(USER, "cannot start rtrace process");
228 >                        error(USER, "cannot start rtrace process(es)");
229                  if (vdef(REPORT)) {             /* make first report */
230                          printargs(rtargc, rtargv, stderr);
231                          report(0);
# Line 269 | Line 280 | rholo()                                /* holodeck main loop */
280                  if (!disp_check(idle))
281                          return(0);
282                                          /* display only? */
283 <        if (ncprocs <= 0)
284 <                return(1);
283 >        if (nprocs <= 0)
284 >                return(outdev != NULL);
285                                          /* check file size */
286          if (maxdisk > 0 && hdfilen(hdlist[0]->fd) >= maxdisk) {
287                  error(WARNING, "file limit exceeded");
288 <                return(0);
288 >                done_rtrace();
289 >                idle = 1;
290 >                return(1);      /* comes back */
291          }
292                                          /* check time */
293          if (endtime > 0 || reporttime > 0)
294                  t = time(NULL);
295          if (endtime > 0 && t >= endtime) {
296                  error(WARNING, "time limit exceeded");
297 <                return(0);
297 >                done_rtrace();
298 >                idle = 1;
299 >                return(1);      /* comes back */
300          }
301          if (reporttime > 0 && t >= reporttime)
302                  report(t);
# Line 290 | Line 305 | rholo()                                /* holodeck main loop */
305                  p = freepacks; freepacks = p->next; p->next = NULL;
306                  if (!next_packet(p)) {
307                          p->next = freepacks; freepacks = p;
308 +                        idle = 1;
309                          break;
310                  }
311                  if (pl == NULL) pl = p;
312                  else plend->next = p;
313                  plend = p;
314          }
315 <        idle = pl == NULL && freepacks != NULL;
300 <                                        /* are we out of stuff to do? */
301 <        if (idle && outdev == NULL)
302 <                return(0);
303 <                                        /* else process packets */
315 >                                        /* process packets */
316          done_packets(do_packets(pl));
317          return(1);                      /* and continue */
318   }
# Line 309 | Line 321 | rholo()                                /* holodeck main loop */
321   report(t)                       /* report progress so far */
322   time_t  t;
323   {
324 <        if (t == 0)
324 >        static time_t   seconds2go = 1000000;
325 >
326 >        if (t == 0L)
327                  t = time(NULL);
328 <        fprintf(stderr, "%s: %ld packets (%ld rays) done after %.2f hours\n",
329 <                        progname, npacksdone, nraysdone, (t-starttime)/3600.);
330 <        fflush(stderr);
331 <        if (vdef(REPORT))
332 <                reporttime = t + (time_t)(vflt(REPORT)*60.+.5);
328 >        sprintf(errmsg, "%ld packets (%ld rays) done after %.2f hours\n",
329 >                        npacksdone, nraysdone, (t-starttime)/3600.);
330 >        eputs(errmsg);
331 >        if (seconds2go == 1000000)
332 >                seconds2go = vdef(REPORT) ? (long)(vflt(REPORT)*60. + .5) : 0L;
333 >        if (seconds2go)
334 >                reporttime = t + seconds2go;
335   }
336  
337  
# Line 335 | Line 351 | register HDGRID        *gp;
351                  sprintf(errmsg, "ignoring all but first %s", vnam(SECTION));
352                  error(WARNING, errmsg);
353          }
338 –        if (sscanf(vval(SECTION),
339 –                        "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
340 –                        &gp->orig[0], &gp->orig[1], &gp->orig[2],
341 –                        &gp->xv[0][0], &gp->xv[0][1], &gp->xv[0][2],
342 –                        &gp->xv[1][0], &gp->xv[1][1], &gp->xv[1][2],
343 –                        &gp->xv[2][0], &gp->xv[2][1], &gp->xv[2][2]) != 12)
344 –                badvalue(SECTION);
345 –        maxlen = 0.;
346 –        for (i = 0; i < 3; i++)
347 –                if ((len[i] = VLEN(gp->xv[i])) > maxlen)
348 –                        maxlen = len[i];
349 –        if (!vdef(GRID)) {
350 –                sprintf(buf, "%.4f", maxlen/8.);
351 –                vval(GRID) = savqstr(buf);
352 –                vdef(GRID)++;
353 –        }
354 –        if ((d = vflt(GRID)) <= FTINY)
355 –                badvalue(GRID);
356 –        for (i = 0; i < 3; i++)
357 –                gp->grid[i] = len[i]/d + (1.-FTINY);
358 –        if (!vdef(EXPOSURE)) {
359 –                sprintf(errmsg, "%s must be defined", vnam(EXPOSURE));
360 –                error(USER, errmsg);
361 –        }
362 –        expval = vval(EXPOSURE)[0] == '-' || vval(EXPOSURE)[0] == '+' ?
363 –                        pow(2., vflt(EXPOSURE)) : vflt(EXPOSURE);
354          if (!vdef(OCTREE)) {
355                  if ((vval(OCTREE) = bmalloc(strlen(froot)+5)) == NULL)
356                          error(SYSTEM, "out of memory");
# Line 382 | Line 372 | register HDGRID        *gp;
372                                  /* append rendering options */
373          if (vdef(RENDER))
374                  rtargc += wordstring(rtargv+rtargc, vval(RENDER));
375 +        
376 +        if (gp == NULL)         /* already initialized? */
377 +                return;
378 +                                /* set grid parameters */
379 +        gp->grid[0] = gp->grid[1] = gp->grid[2] = 0;
380 +        if (sscanf(vval(SECTION),
381 +                "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %hd %hd %hd",
382 +                        &gp->orig[0], &gp->orig[1], &gp->orig[2],
383 +                        &gp->xv[0][0], &gp->xv[0][1], &gp->xv[0][2],
384 +                        &gp->xv[1][0], &gp->xv[1][1], &gp->xv[1][2],
385 +                        &gp->xv[2][0], &gp->xv[2][1], &gp->xv[2][2],
386 +                        &gp->grid[0], &gp->grid[1], &gp->grid[2]) < 12)
387 +                badvalue(SECTION);
388 +        maxlen = 0.;
389 +        for (i = 0; i < 3; i++)
390 +                if ((len[i] = VLEN(gp->xv[i])) > maxlen)
391 +                        maxlen = len[i];
392 +        if (!vdef(GRID)) {
393 +                sprintf(buf, "%.4f", maxlen/8.);
394 +                vval(GRID) = savqstr(buf);
395 +                vdef(GRID)++;
396 +        }
397 +        if ((d = vflt(GRID)) <= FTINY)
398 +                badvalue(GRID);
399 +        for (i = 0; i < 3; i++)
400 +                if (gp->grid[i] <= 0)
401 +                        gp->grid[i] = len[i]/d + (1.-FTINY);
402   }
403  
404  
# Line 489 | Line 506 | PACKET *pl;
506                  p->next = freepacks;
507                  freepacks = p;
508          }
509 <        if (n2flush > 512*RPACKSIZ*ncprocs) {
509 >        if (n2flush > 512*RPACKSIZ*nprocs) {
510                  hdflush(NULL);                  /* flush holodeck buffers */
511                  n2flush = 0;
512          }
513   }
514  
515  
516 + int
517 + done_rtrace()                   /* clean up and close rtrace calculation */
518 + {
519 +        int     status;
520 +                                        /* already closed? */
521 +        if (!nprocs)
522 +                return;
523 +                                        /* report activity */
524 +        wputs("closing rtrace process...\n");
525 +                                        /* flush beam queue */
526 +        done_packets(flush_queue());
527 +                                        /* close rtrace */
528 +        if ((status = end_rtrace()))
529 +                error(WARNING, "bad exit status from rtrace");
530 +        if (vdef(REPORT))               /* report time */
531 +                report(0);
532 +        return(status);                 /* return status */
533 + }
534 +
535 +
536 + new_rtrace()                    /* restart rtrace calculation */
537 + {
538 +        char    combuf[128];
539 +
540 +        if (nprocs > 0)                 /* already running? */
541 +                return;
542 +        wputs("restarting rtrace process...\n");
543 +        if (vdef(RIF)) {                /* rerun rad to update octree */
544 +                sprintf(combuf, "rad -v 0 -s -w %s", vval(RIF));
545 +                if (system(combuf))
546 +                        error(WARNING, "error running rad");
547 +        }
548 +        if (start_rtrace() < 1)         /* start rtrace */
549 +                error(WARNING, "cannot restart rtrace");
550 +        else if (vdef(REPORT))
551 +                report(0);
552 + }
553 +
554 +
555   getradfile(rfargs)              /* run rad and get needed variables */
556   char    *rfargs;
557   {
558 <        static short    mvar[] = {OCTREE,EXPOSURE,-1};
558 >        static short    mvar[] = {OCTREE,-1};
559          static char     tf1[] = TEMPLATE;
560          char    tf2[64];
561          char    combuf[256];
# Line 529 | Line 585 | char   *rfargs;
585          else
586                  sprintf(cp, ")[ \t]*=' > %s", tf2);
587          if (system(combuf)) {
532 –                error(SYSTEM, "cannot execute rad command");
588                  unlink(tf2);                    /* clean up */
589                  unlink(tf1);
590 <                quit(1);
590 >                error(SYSTEM, "cannot execute rad command");
591          }
592          if (pippt == NULL) {
593                  loadvars(tf2);                  /* load variables */
# Line 599 | Line 654 | int    ec;
654          int     status = 0;
655  
656          if (hdlist[0] != NULL) {        /* flush holodeck */
657 <                if (ncprocs > 0) {
658 <                        done_packets(flush_queue());
659 <                        status = end_rtrace();  /* close rtrace */
660 <                        hdflush(NULL);
661 <                        if (vdef(REPORT)) {
662 <                                long    fsiz, fuse;
663 <                                report(0);
664 <                                fsiz = hdfilen(hdlist[0]->fd);
610 <                                fuse = hdfiluse(hdlist[0]->fd, 1);
611 <                                fprintf(stderr,
657 >                if (nprocs > 0)
658 >                        status = done_rtrace();
659 >                hdflush(NULL);
660 >                if (ncprocs > 0 && vdef(REPORT)) {
661 >                        long    fsiz, fuse;
662 >                        fsiz = hdfilen(hdlist[0]->fd);
663 >                        fuse = hdfiluse(hdlist[0]->fd, 1);
664 >                        fprintf(stderr,
665                          "%s: %.1f Mbyte holodeck file, %.1f%% fragmentation\n",
666 <                                                hdkfile, fsiz/(1024.*1024.),
667 <                                                100.*(fsiz-fuse)/fsiz);
668 <                        }
616 <                } else
617 <                        hdflush(NULL);
666 >                                        hdkfile, fsiz/(1024.*1024.),
667 >                                        100.*(fsiz-fuse)/fsiz);
668 >                }
669          }
670          if (orig_mode >= 0)             /* reset holodeck access mode */
671                  fchmod(hdlist[0]->fd, orig_mode);

Diff Legend

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