ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rholo.c
Revision: 3.24
Committed: Fri Dec 12 19:52:31 1997 UTC (26 years, 3 months ago) by gregl
Content type: text/plain
Branch: MAIN
Changes since 3.23: +2 -3 lines
Log Message:
modified hdsync() to optionally sync all unflushed beams

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