ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rholo.c
Revision: 3.30
Committed: Fri Dec 19 10:41:42 1997 UTC (26 years, 3 months ago) by gregl
Content type: text/plain
Branch: MAIN
Changes since 3.29: +10 -9 lines
Log Message:
fixed another bug in idle logic of rholo()

File Contents

# User Rev Content
1 gregl 3.1 /* Copyright (c) 1997 Silicon Graphics, Inc. */
2    
3     #ifndef lint
4     static char SCCSid[] = "$SunId$ SGI";
5     #endif
6    
7     /*
8     * Radiance holodeck generation controller
9     */
10    
11     #include "rholo.h"
12 gregl 3.14 #include "random.h"
13 gregl 3.12 #include <signal.h>
14 gregl 3.1 #include <sys/types.h>
15 gregl 3.12 #include <sys/stat.h>
16 gregl 3.1
17     /* the following must be consistent with rholo.h */
18     int NVARS = NRHVARS; /* total number of variables */
19    
20     VARIABLE vv[] = RHVINIT; /* variable-value pairs */
21    
22     char *progname; /* our program name */
23     char *hdkfile; /* holodeck file name */
24 gregl 3.22 char froot[256]; /* root file name */
25 gregl 3.1
26     int nowarn = 0; /* turn warnings off? */
27    
28     int ncprocs = 0; /* desired number of compute processes */
29    
30     char *outdev = NULL; /* output device name */
31    
32 gregl 3.17 int readinp = 0; /* read commands from stdin */
33    
34 gregl 3.20 int force = 0; /* allow overwrite of holodeck */
35    
36 gregl 3.1 time_t starttime; /* time we got started */
37     time_t endtime; /* time we should end by */
38     time_t reporttime; /* time for next report */
39    
40 gregl 3.8 long maxdisk; /* maximum file space (bytes) */
41    
42 gregl 3.1 int rtargc = 1; /* rtrace command */
43     char *rtargv[128] = {"rtrace", NULL};
44    
45 gregl 3.12 int orig_mode = -1; /* original file mode (-1 if unchanged) */
46    
47 gregl 3.1 long nraysdone = 0L; /* number of rays done */
48     long npacksdone = 0L; /* number of packets done */
49    
50     PACKET *freepacks; /* available packets */
51    
52 gregl 3.12 char *sigerr[NSIG]; /* signal error messages */
53    
54 gregl 3.1 extern time_t time();
55    
56    
57     main(argc, argv)
58     int argc;
59     char *argv[];
60     {
61     int i;
62 gregl 3.3 /* mark start time */
63     starttime = time(NULL);
64 gregl 3.18 initurand(16384); /* initialize urand */
65 gregl 3.1 progname = argv[0]; /* get arguments */
66     for (i = 1; i < argc && argv[i][0] == '-'; i++)
67     switch (argv[i][1]) {
68     case 'w': /* turn off warnings */
69     nowarn++;
70     break;
71     case 'f': /* force overwrite */
72     force++;
73     break;
74 gregl 3.17 case 'i': /* read input from stdin */
75     readinp++;
76     break;
77 gregl 3.1 case 'n': /* compute processes */
78     if (i >= argc-2)
79     goto userr;
80     ncprocs = atoi(argv[++i]);
81     break;
82     case 'o': /* output display */
83     if (i >= argc-2)
84     goto userr;
85     outdev = argv[++i];
86     break;
87     default:
88     goto userr;
89     }
90     /* get root file name */
91     rootname(froot, hdkfile=argv[i++]);
92 gregl 3.27 /* load variables? */
93     if (i < argc)
94     if (argv[i][0] != '-' && argv[i][0] != '+')
95     loadvars(argv[i]); /* load variables from file */
96    
97     if (i >= argc || argv[i][0] == '+')
98     loadholo(); /* load existing holodeck */
99    
100     while (++i < argc) /* get command line settings */
101     if (setvariable(argv[i], matchvar) < 0) {
102     sprintf(errmsg, "unknown variable: %s", argv[i]);
103     error(USER, errmsg);
104     }
105     /* check settings */
106     checkvalues();
107     /* load RIF if any */
108     getradfile();
109    
110 gregl 3.28 if (hdlist[0] == NULL) { /* create new holodeck */
111 gregl 3.29 HDGRID hdg[HDMAX];
112 gregl 3.1 /* set defaults */
113 gregl 3.29 setdefaults(hdg);
114 gregl 3.1 /* holodeck exists? */
115     if (!force && access(hdkfile, R_OK|W_OK) == 0)
116     error(USER,
117     "holodeck file exists -- use -f to overwrite");
118     /* create holodeck */
119 gregl 3.29 creatholo(hdg);
120 gregl 3.27 } else /* else just set defaults */
121 gregl 3.15 setdefaults(NULL);
122 gregl 3.1 /* initialize */
123     initrholo();
124 gregl 3.15 /* main loop */
125 gregl 3.1 while (rholo())
126     ;
127     /* done */
128     quit(0);
129     userr:
130     fprintf(stderr,
131 gregl 3.27 "Usage: %s [-n nprocs][-o disp][-w][-f] output.hdk [control.hif|+|- [VAR=val ..]]\n",
132 gregl 3.1 progname);
133     quit(1);
134     }
135    
136    
137 gregl 3.12 onsig(signo) /* fatal signal */
138     int signo;
139     {
140     static int gotsig = 0;
141    
142     if (gotsig++) /* two signals and we're gone! */
143     _exit(signo);
144    
145 gregl 3.28 alarm(60); /* allow 60 seconds to clean up */
146 gregl 3.12 signal(SIGALRM, SIG_DFL); /* make certain we do die */
147     eputs("signal - ");
148     eputs(sigerr[signo]);
149     eputs("\n");
150     quit(3);
151     }
152    
153    
154     sigdie(signo, msg) /* set fatal signal */
155     int signo;
156     char *msg;
157     {
158     if (signal(signo, onsig) == SIG_IGN)
159     signal(signo, SIG_IGN);
160     sigerr[signo] = msg;
161     }
162    
163    
164     int
165     resfmode(fd, mod) /* restrict open file access mode */
166     int fd, mod;
167     {
168     struct stat stbuf;
169     /* get original mode */
170     if (fstat(fd, &stbuf) < 0)
171     error(SYSTEM, "cannot stat open holodeck file");
172     mod &= stbuf.st_mode; /* always more restrictive */
173     if (mod == stbuf.st_mode)
174     return(-1); /* already set */
175     /* else change it */
176     if (fchmod(fd, mod) < 0) {
177     error(WARNING, "cannot change holodeck file access mode");
178     return(-1);
179     }
180     return(stbuf.st_mode); /* return original mode */
181     }
182    
183    
184 gregl 3.1 initrholo() /* get our holodeck running */
185     {
186     extern int global_packet();
187     register int i;
188 gregl 3.17 /* close holodeck on exec() */
189     fcntl(hdlist[0]->fd, F_SETFD, FD_CLOEXEC);
190 gregl 3.4
191     if (outdev != NULL) /* open output device */
192     disp_open(outdev);
193 gregl 3.1 else if (ncprocs > 0) /* else use global ray feed */
194     init_global();
195 gregl 3.8 /* record disk space limit */
196     if (!vdef(DISKSPACE))
197     maxdisk = 0;
198     else
199 gregl 3.9 maxdisk = 1024.*1024.*vflt(DISKSPACE);
200 gregl 3.3 /* record end time */
201 gregl 3.1 if (!vdef(TIME) || vflt(TIME) <= FTINY)
202     endtime = 0;
203     else
204 gregl 3.23 endtime = starttime + vflt(TIME)*3600. + .5;
205 gregl 3.1 /* set up memory cache */
206 gregl 3.5 if (outdev == NULL)
207     hdcachesize = 0; /* manual flushing */
208     else if (vdef(CACHE))
209     hdcachesize = 1024.*1024.*vflt(CACHE);
210 gregl 3.1 /* open report file */
211     if (vdef(REPORT)) {
212     register char *s = sskip2(vval(REPORT), 1);
213     if (*s && freopen(s, "a", stderr) == NULL)
214     quit(2);
215     }
216     /* start rtrace */
217     if (ncprocs > 0) {
218     i = start_rtrace();
219     if (i < 1)
220 gregl 3.20 error(USER, "cannot start rtrace process(es)");
221 gregl 3.1 if (vdef(REPORT)) { /* make first report */
222     printargs(rtargc, rtargv, stderr);
223     report(0);
224     }
225     /* allocate packets */
226     freepacks = (PACKET *)bmalloc(i*sizeof(PACKET));
227     if (freepacks == NULL)
228     goto memerr;
229     freepacks[--i].nr = 0;
230     freepacks[i].next = NULL;
231 gregl 3.25 if (!vdef(OBSTRUCTIONS) || !vbool(OBSTRUCTIONS)) {
232 gregl 3.1 freepacks[i].offset = (float *)bmalloc(
233     RPACKSIZ*sizeof(float)*(i+1) );
234     if (freepacks[i].offset == NULL)
235     goto memerr;
236     } else
237     freepacks[i].offset = NULL;
238     while (i--) {
239     freepacks[i].nr = 0;
240     freepacks[i].offset = freepacks[i+1].offset == NULL ?
241     NULL : freepacks[i+1].offset+RPACKSIZ ;
242     freepacks[i].next = &freepacks[i+1];
243     }
244     }
245 gregl 3.12 /* set up signal handling */
246     sigdie(SIGINT, "Interrupt");
247     sigdie(SIGHUP, "Hangup");
248     sigdie(SIGTERM, "Terminate");
249     sigdie(SIGPIPE, "Broken pipe");
250     sigdie(SIGALRM, "Alarm clock");
251     #ifdef SIGXCPU
252     sigdie(SIGXCPU, "CPU limit exceeded");
253     sigdie(SIGXFSZ, "File size exceeded");
254     #endif
255     /* protect holodeck file */
256     orig_mode = resfmode(hdlist[0]->fd, ncprocs>0 ? 0 : 0444);
257 gregl 3.1 return;
258     memerr:
259     error(SYSTEM, "out of memory in initrholo");
260     }
261    
262    
263     rholo() /* holodeck main loop */
264     {
265 gregl 3.30 static int idle = 0;
266 gregl 3.1 PACKET *pl = NULL, *plend;
267     register PACKET *p;
268     time_t t;
269     long l;
270 gregl 3.30 /* check display */
271     if (nprocs <= 0)
272     idle = 1;
273     if (outdev != NULL) {
274 gregl 3.4 if (!disp_check(idle))
275 gregl 3.30 return(0); /* quit request */
276     if (nprocs <= 0)
277     return(1);
278     } else if (idle)
279     return(0); /* all done */
280 gregl 3.1 /* check file size */
281 gregl 3.9 if (maxdisk > 0 && hdfilen(hdlist[0]->fd) >= maxdisk) {
282 gregl 3.8 error(WARNING, "file limit exceeded");
283 gregl 3.21 done_rtrace();
284     return(1); /* comes back */
285 gregl 3.8 }
286 gregl 3.1 /* check time */
287 gregl 3.3 if (endtime > 0 || reporttime > 0)
288 gregl 3.1 t = time(NULL);
289 gregl 3.8 if (endtime > 0 && t >= endtime) {
290     error(WARNING, "time limit exceeded");
291 gregl 3.21 done_rtrace();
292     return(1); /* comes back */
293 gregl 3.8 }
294 gregl 3.3 if (reporttime > 0 && t >= reporttime)
295 gregl 3.1 report(t);
296 gregl 3.28 idle = 0; /* get packets to process */
297 gregl 3.1 while (freepacks != NULL) {
298     p = freepacks; freepacks = p->next; p->next = NULL;
299     if (!next_packet(p)) {
300     p->next = freepacks; freepacks = p;
301 gregl 3.21 idle = 1;
302 gregl 3.1 break;
303     }
304     if (pl == NULL) pl = p;
305     else plend->next = p;
306     plend = p;
307     }
308 gregl 3.21 /* process packets */
309 gregl 3.1 done_packets(do_packets(pl));
310     return(1); /* and continue */
311     }
312    
313    
314     setdefaults(gp) /* set default values */
315     register HDGRID *gp;
316     {
317     extern char *atos();
318     register int i;
319 gregl 3.29 int n;
320 gregl 3.1 double len[3], maxlen, d;
321     char buf[64];
322    
323     if (!vdef(SECTION)) {
324     sprintf(errmsg, "%s must be defined", vnam(SECTION));
325     error(USER, errmsg);
326     }
327     if (!vdef(OCTREE)) {
328     if ((vval(OCTREE) = bmalloc(strlen(froot)+5)) == NULL)
329     error(SYSTEM, "out of memory");
330     sprintf(vval(OCTREE), "%s.oct", froot);
331     vdef(OCTREE)++;
332 gregl 3.14 }
333     if (!vdef(VDIST)) {
334     vval(VDIST) = "F";
335     vdef(VDIST)++;
336 gregl 3.1 }
337     /* append rendering options */
338     if (vdef(RENDER))
339     rtargc += wordstring(rtargv+rtargc, vval(RENDER));
340 gregl 3.15
341     if (gp == NULL) /* already initialized? */
342     return;
343     /* set grid parameters */
344 gregl 3.29 for (n = 0; n < vdef(SECTION); n++, gp++) {
345     gp->grid[0] = gp->grid[1] = gp->grid[2] = 0;
346     if (sscanf(nvalue(SECTION, n),
347 gregl 3.16 "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %hd %hd %hd",
348 gregl 3.29 &gp->orig[0], &gp->orig[1], &gp->orig[2],
349     &gp->xv[0][0], &gp->xv[0][1], &gp->xv[0][2],
350     &gp->xv[1][0], &gp->xv[1][1], &gp->xv[1][2],
351     &gp->xv[2][0], &gp->xv[2][1], &gp->xv[2][2],
352     &gp->grid[0], &gp->grid[1], &gp->grid[2]) < 12)
353     badvalue(SECTION);
354     maxlen = 0.;
355     for (i = 0; i < 3; i++)
356     if ((len[i] = VLEN(gp->xv[i])) > maxlen)
357     maxlen = len[i];
358     if (!vdef(GRID))
359     d = 0.125*maxlen;
360     else if ((d = vflt(GRID)) <= FTINY)
361     badvalue(GRID);
362     for (i = 0; i < 3; i++)
363     if (gp->grid[i] <= 0)
364     gp->grid[i] = len[i]/d + (1.-FTINY);
365 gregl 3.15 }
366 gregl 3.1 }
367    
368    
369     creatholo(gp) /* create a holodeck output file */
370     HDGRID *gp;
371     {
372 gregl 3.12 extern char VersionID[];
373 gregl 3.29 int4 lastloc, nextloc;
374     int n;
375 gregl 3.10 int fd;
376 gregl 3.1 FILE *fp;
377     /* open & truncate file */
378     if ((fp = fopen(hdkfile, "w+")) == NULL) {
379     sprintf(errmsg, "cannot open \"%s\" for writing", hdkfile);
380     error(SYSTEM, errmsg);
381     }
382     /* write information header */
383     newheader("RADIANCE", fp);
384 gregl 3.12 fprintf(fp, "SOFTWARE= %s\n", VersionID);
385 gregl 3.1 printvars(fp);
386     fputformat(HOLOFMT, fp);
387     fputc('\n', fp);
388 gregl 3.29 putw(HOLOMAGIC, fp); /* put magic number */
389 gregl 3.10 fd = dup(fileno(fp));
390     fclose(fp); /* flush and close stdio stream */
391 gregl 3.29 lastloc = lseek(fd, 0L, 2);
392     for (n = vdef(SECTION); n--; gp++) { /* initialize each section */
393     nextloc = 0L;
394     write(fd, (char *)&nextloc, sizeof(nextloc));
395     hdinit(fd, gp); /* writes beam index */
396     if (!n)
397     break;
398     nextloc = hdfilen(fd); /* write section pointer */
399     if (lseek(fd, (long)lastloc, 0) < 0)
400     error(SYSTEM,
401     "cannot seek on holodeck file in creatholo");
402     write(fd, (char *)&nextloc, sizeof(nextloc));
403     lseek(fd, (long)(lastloc=nextloc), 0);
404     }
405 gregl 3.1 }
406    
407    
408     headline(s) /* process information header line */
409     char *s;
410     {
411     extern char FMTSTR[];
412     register char *cp;
413     char fmt[32];
414    
415 gregl 3.2 if (formatval(fmt, s)) {
416 gregl 3.1 if (strcmp(fmt, HOLOFMT)) {
417     sprintf(errmsg, "%s file \"%s\" has %s%s",
418     HOLOFMT, hdkfile, FMTSTR, fmt);
419     error(USER, errmsg);
420     }
421     return;
422     }
423     for (cp = s; *cp; cp++) /* take off any comments */
424     if (*cp == '#') {
425     *cp = '\0';
426     break;
427     }
428     setvariable(s, matchvar); /* don't flag errors */
429     }
430    
431    
432     loadholo() /* start loading a holodeck from fname */
433     {
434 gregl 3.10 extern long ftell();
435 gregl 3.1 FILE *fp;
436 gregl 3.10 int fd;
437 gregl 3.29 int n;
438     int4 nextloc;
439 gregl 3.4 /* open holodeck file */
440     if ((fp = fopen(hdkfile, ncprocs>0 ? "r+" : "r")) == NULL) {
441     sprintf(errmsg, "cannot open \"%s\" for %s", hdkfile,
442     ncprocs>0 ? "appending" : "reading");
443 gregl 3.1 error(SYSTEM, errmsg);
444     }
445     /* load variables from header */
446     getheader(fp, headline, NULL);
447     /* check magic number */
448     if (getw(fp) != HOLOMAGIC) {
449     sprintf(errmsg, "bad magic number in holodeck file \"%s\"",
450     hdkfile);
451     error(USER, errmsg);
452     }
453 gregl 3.29 nextloc = ftell(fp); /* get stdio position */
454 gregl 3.10 fd = dup(fileno(fp));
455     fclose(fp); /* done with stdio */
456 gregl 3.29 for (n = 0; nextloc > 0L; n++) { /* initialize each section */
457     lseek(fd, (long)nextloc, 0);
458     read(fd, (char *)&nextloc, sizeof(nextloc));
459     hdinit(fd, NULL);
460     }
461     if (n != vdef(SECTION)) {
462     sprintf(errmsg, "number of sections does not match %s setting",
463     vnam(SECTION));
464     error(WARNING, errmsg);
465     }
466 gregl 3.1 }
467    
468    
469     done_packets(pl) /* handle finished packets */
470     PACKET *pl;
471     {
472 gregl 3.13 static int n2flush = 0;
473 gregl 3.1 register PACKET *p;
474    
475     while (pl != NULL) {
476     p = pl; pl = p->next; p->next = NULL;
477     if (p->nr > 0) { /* add to holodeck */
478     bcopy((char *)p->ra,
479     (char *)hdnewrays(hdlist[p->hd],p->bi,p->nr),
480     p->nr*sizeof(RAYVAL));
481     if (outdev != NULL) /* display it */
482 gregl 3.7 disp_packet((PACKHEAD *)p);
483 gregl 3.13 if (hdcachesize <= 0) /* manual flushing */
484     n2flush += p->nr;
485 gregl 3.6 nraysdone += p->nr;
486     npacksdone++;
487 gregl 3.1 }
488     p->nr = 0; /* push onto free list */
489     p->next = freepacks;
490     freepacks = p;
491 gregl 3.5 }
492 gregl 3.19 if (n2flush > 512*RPACKSIZ*nprocs) {
493 gregl 3.5 hdflush(NULL); /* flush holodeck buffers */
494 gregl 3.13 n2flush = 0;
495 gregl 3.1 }
496     }
497    
498    
499     rootname(rn, fn) /* remove tail from end of fn */
500     register char *rn, *fn;
501     {
502     char *tp, *dp;
503    
504     for (tp = NULL, dp = rn; *rn = *fn++; rn++)
505 gregl 3.22 if (*rn == '/')
506 gregl 3.1 dp = rn;
507     else if (*rn == '.')
508     tp = rn;
509     if (tp != NULL && tp > dp)
510     *tp = '\0';
511     }
512    
513    
514     badvalue(vc) /* report bad variable value and exit */
515     int vc;
516     {
517     sprintf(errmsg, "bad value for variable '%s'", vnam(vc));
518     error(USER, errmsg);
519     }
520    
521    
522     eputs(s) /* put error message to stderr */
523     register char *s;
524     {
525     static int midline = 0;
526    
527     if (!*s)
528     return;
529     if (!midline++) { /* prepend line with program name */
530     fputs(progname, stderr);
531     fputs(": ", stderr);
532     }
533     fputs(s, stderr);
534     if (s[strlen(s)-1] == '\n') {
535     fflush(stderr);
536     midline = 0;
537     }
538     }
539    
540    
541     wputs(s) /* put warning string to stderr */
542     char *s;
543     {
544     if (!nowarn)
545     eputs(s);
546     }
547    
548    
549     quit(ec) /* exit program gracefully */
550     int ec;
551     {
552     int status = 0;
553    
554 gregl 3.24 if (hdlist[0] != NULL) { /* close holodeck */
555 gregl 3.21 if (nprocs > 0)
556 gregl 3.24 status = done_rtrace(); /* calls hdsync() */
557 gregl 3.19 if (ncprocs > 0 && vdef(REPORT)) {
558     long fsiz, fuse;
559     fsiz = hdfilen(hdlist[0]->fd);
560     fuse = hdfiluse(hdlist[0]->fd, 1);
561     fprintf(stderr,
562 gregl 3.3 "%s: %.1f Mbyte holodeck file, %.1f%% fragmentation\n",
563 gregl 3.19 hdkfile, fsiz/(1024.*1024.),
564     100.*(fsiz-fuse)/fsiz);
565     }
566 gregl 3.1 }
567 gregl 3.12 if (orig_mode >= 0) /* reset holodeck access mode */
568     fchmod(hdlist[0]->fd, orig_mode);
569 gregl 3.11 if (outdev != NULL) /* close display */
570     disp_close();
571 gregl 3.1 exit(ec ? ec : status); /* exit */
572     }