ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rholo.c
Revision: 3.39
Committed: Thu May 14 13:05:27 1998 UTC (25 years, 10 months ago) by gwlarson
Content type: text/plain
Branch: MAIN
Changes since 3.38: +2 -2 lines
Log Message:
changed error message in loadholo()

File Contents

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