src/hd/rholo.c

/* Copyright (c) 1997 Silicon Graphics, Inc. */

#ifndef lint
static char SCCSid[] = "$SunId$ SGI";
#endif

/*
 * Radiance holodeck generation controller
 */

#include "rholo.h"
#include "random.h"
#include "paths.h"
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>

                        /* the following must be consistent with rholo.h */
int     NVARS = NRHVARS;                /* total number of variables */

VARIABLE        vv[] = RHVINIT;         /* variable-value pairs */

char    *progname;              /* our program name */
char    *hdkfile;               /* holodeck file name */
char    froot[MAXPATH];         /* root file name */

int     nowarn = 0;             /* turn warnings off? */

int     ncprocs = 0;            /* desired number of compute processes */

char    *outdev = NULL;         /* output device name */

int     readinp = 0;            /* read commands from stdin */

int     force = 0;              /* allow overwrite of holodeck */

time_t  starttime;              /* time we got started */
time_t  endtime;                /* time we should end by */
time_t  reporttime;             /* time for next report */

long    maxdisk;                /* maximum file space (bytes) */

int     rtargc = 1;             /* rtrace command */
char    *rtargv[128] = {"rtrace", NULL};

int     orig_mode = -1;         /* original file mode (-1 if unchanged) */

long    nraysdone = 0L;         /* number of rays done */
long    npacksdone = 0L;        /* number of packets done */

PACKET  *freepacks;             /* available packets */

char  *sigerr[NSIG];            /* signal error messages */

extern time_t   time();


main(argc, argv)
int     argc;
char    *argv[];
{
        HDGRID  hdg;
        int     i;
                                                /* mark start time */
        starttime = time(NULL);
        initurand(16384);                       /* initialize urand */
        progname = argv[0];                     /* get arguments */
        for (i = 1; i < argc && argv[i][0] == '-'; i++)
                switch (argv[i][1]) {
                case 'w':                       /* turn off warnings */
                        nowarn++;
                        break;
                case 'f':                       /* force overwrite */
                        force++;
                        break;
                case 'i':                       /* read input from stdin */
                        readinp++;
                        break;
                case 'n':                       /* compute processes */
                        if (i >= argc-2)
                                goto userr;
                        ncprocs = atoi(argv[++i]);
                        break;
                case 'o':                       /* output display */
                        if (i >= argc-2)
                                goto userr;
                        outdev = argv[++i];
                        break;
                default:
                        goto userr;
                }
                                                /* do we have a job? */
        if (outdev == NULL && ncprocs <= 0)
                goto userr;
                                                /* get root file name */
        rootname(froot, hdkfile=argv[i++]);
                                                /* load... */
        if (i < argc) {                         /* variables */
                loadvars(argv[i++]);
                                                        /* cmdline settings */
                for ( ; i < argc; i++)
                        if (setvariable(argv[i], matchvar) < 0) {
                                sprintf(errmsg, "unknown variable: %s",
                                                argv[i]);
                                error(USER, errmsg);
                        }
                                                        /* check settings */
                checkvalues();
                                                        /* load RIF if any */
                if (vdef(RIF))
                        getradfile(vval(RIF));
                                                        /* set defaults */
                setdefaults(&hdg);
                                                        /* holodeck exists? */
                if (!force && access(hdkfile, R_OK|W_OK) == 0)
                        error(USER,
                                "holodeck file exists -- use -f to overwrite");
                                                        /* create holodeck */
                creatholo(&hdg);
        } else {                                /* else load holodeck */
                loadholo();
                                                        /* check settings */
                checkvalues();
                                                        /* load RIF if any */
                if (vdef(RIF))
                        getradfile(vval(RIF));
                                                        /* set defaults */
                setdefaults(NULL);
        }
                                                /* initialize */
        initrholo();
                                                /* main loop */
        while (rholo())
                ;
                                                /* done */
        quit(0);
userr:
        fprintf(stderr,
"Usage: %s {-n nprocs|-o disp} [-w][-f] output.hdk [control.hif [VAR=val ..]]\n",
                        progname);
        quit(1);
}


onsig(signo)                            /* fatal signal */
int  signo;
{
        static int  gotsig = 0;

        if (gotsig++)                   /* two signals and we're gone! */
                _exit(signo);

        alarm(30);                      /* allow 30 seconds to clean up */
        signal(SIGALRM, SIG_DFL);       /* make certain we do die */
        eputs("signal - ");
        eputs(sigerr[signo]);
        eputs("\n");
        quit(3);
}


sigdie(signo, msg)                      /* set fatal signal */
int  signo;
char  *msg;
{
        if (signal(signo, onsig) == SIG_IGN)
                signal(signo, SIG_IGN);
        sigerr[signo] = msg;
}


int
resfmode(fd, mod)               /* restrict open file access mode */
int     fd, mod;
{
        struct stat     stbuf;
                                        /* get original mode */
        if (fstat(fd, &stbuf) < 0)
                error(SYSTEM, "cannot stat open holodeck file");
        mod &= stbuf.st_mode;           /* always more restrictive */
        if (mod == stbuf.st_mode)
                return(-1);             /* already set */
                                        /* else change it */
        if (fchmod(fd, mod) < 0) {
                error(WARNING, "cannot change holodeck file access mode");
                return(-1);
        }
        return(stbuf.st_mode);          /* return original mode */
}


initrholo()                     /* get our holodeck running */
{
        extern int      global_packet();
        register int    i;
                                                /* close holodeck on exec() */
        fcntl(hdlist[0]->fd, F_SETFD, FD_CLOEXEC);

        if (outdev != NULL)                     /* open output device */
                disp_open(outdev);
        else if (ncprocs > 0)                   /* else use global ray feed */
                init_global();
                                                /* record disk space limit */
        if (!vdef(DISKSPACE))
                maxdisk = 0;
        else
                maxdisk = 1024.*1024.*vflt(DISKSPACE);
                                                /* record end time */
        if (!vdef(TIME) || vflt(TIME) <= FTINY)
                endtime = 0;
        else
                endtime = starttime + vflt(TIME)*3600.;
                                                /* set up memory cache */
        if (outdev == NULL)
                hdcachesize = 0;        /* manual flushing */
        else if (vdef(CACHE))
                hdcachesize = 1024.*1024.*vflt(CACHE);
                                                /* open report file */
        if (vdef(REPORT)) {
                register char   *s = sskip2(vval(REPORT), 1);
                if (*s && freopen(s, "a", stderr) == NULL)
                        quit(2);
        }
                                                /* start rtrace */
        if (ncprocs > 0) {
                i = start_rtrace();
                if (i < 1)
                        error(USER, "cannot start rtrace process(es)");
                if (vdef(REPORT)) {             /* make first report */
                        printargs(rtargc, rtargv, stderr);
                        report(0);
                }
                                                /* allocate packets */
                freepacks = (PACKET *)bmalloc(i*sizeof(PACKET));
                if (freepacks == NULL)
                        goto memerr;
                freepacks[--i].nr = 0;
                freepacks[i].next = NULL;
                if (!vbool(OBSTRUCTIONS)) {
                        freepacks[i].offset = (float *)bmalloc(
                                        RPACKSIZ*sizeof(float)*(i+1) );
                        if (freepacks[i].offset == NULL)
                                goto memerr;
                } else
                        freepacks[i].offset = NULL;
                while (i--) {
                        freepacks[i].nr = 0;
                        freepacks[i].offset = freepacks[i+1].offset == NULL ?
                                        NULL : freepacks[i+1].offset+RPACKSIZ ;
                        freepacks[i].next = &freepacks[i+1];
                }
        }
                                        /* set up signal handling */
        sigdie(SIGINT, "Interrupt");
        sigdie(SIGHUP, "Hangup");
        sigdie(SIGTERM, "Terminate");
        sigdie(SIGPIPE, "Broken pipe");
        sigdie(SIGALRM, "Alarm clock");
#ifdef  SIGXCPU
        sigdie(SIGXCPU, "CPU limit exceeded");
        sigdie(SIGXFSZ, "File size exceeded");
#endif
                                                /* protect holodeck file */
        orig_mode = resfmode(hdlist[0]->fd, ncprocs>0 ? 0 : 0444);
        return;
memerr:
        error(SYSTEM, "out of memory in initrholo");
}


rholo()                         /* holodeck main loop */
{
        static int      idle = 1;
        PACKET  *pl = NULL, *plend;
        register PACKET *p;
        time_t  t;
        long    l;

        if (outdev != NULL)             /* check display */
                if (!disp_check(idle))
                        return(0);
                                        /* display only? */
        if (nprocs <= 0)
                return(outdev != NULL);
                                        /* check file size */
        if (maxdisk > 0 && hdfilen(hdlist[0]->fd) >= maxdisk) {
                error(WARNING, "file limit exceeded");
                done_rtrace();
                idle = 1;
                return(1);      /* comes back */
        }
                                        /* check time */
        if (endtime > 0 || reporttime > 0)
                t = time(NULL);
        if (endtime > 0 && t >= endtime) {
                error(WARNING, "time limit exceeded");
                done_rtrace();
                idle = 1;
                return(1);      /* comes back */
        }
        if (reporttime > 0 && t >= reporttime)
                report(t);
                                        /* get packets to process */
        while (freepacks != NULL) {
                p = freepacks; freepacks = p->next; p->next = NULL;
                if (!next_packet(p)) {
                        p->next = freepacks; freepacks = p;
                        idle = 1;
                        break;
                }
                if (pl == NULL) pl = p;
                else plend->next = p;
                plend = p;
        }
                                        /* process packets */
        done_packets(do_packets(pl));
        return(1);                      /* and continue */
}


report(t)                       /* report progress so far */
time_t  t;
{
        static time_t   seconds2go = 1000000;

        if (t == 0L)
                t = time(NULL);
        sprintf(errmsg, "%ld packets (%ld rays) done after %.2f hours\n",
                        npacksdone, nraysdone, (t-starttime)/3600.);
        eputs(errmsg);
        if (seconds2go == 1000000)
                seconds2go = vdef(REPORT) ? (long)(vflt(REPORT)*60. + .5) : 0L;
        if (seconds2go)
                reporttime = t + seconds2go;
}


setdefaults(gp)                 /* set default values */
register HDGRID *gp;
{
        extern char     *atos();
        register int    i;
        double  len[3], maxlen, d;
        char    buf[64];

        if (!vdef(SECTION)) {
                sprintf(errmsg, "%s must be defined", vnam(SECTION));
                error(USER, errmsg);
        }
        if (vdef(SECTION) > 1) {
                sprintf(errmsg, "ignoring all but first %s", vnam(SECTION));
                error(WARNING, errmsg);
        }
        if (!vdef(OCTREE)) {
                if ((vval(OCTREE) = bmalloc(strlen(froot)+5)) == NULL)
                        error(SYSTEM, "out of memory");
                sprintf(vval(OCTREE), "%s.oct", froot);
                vdef(OCTREE)++;
        }
        if (!vdef(OBSTRUCTIONS)) {
                vval(OBSTRUCTIONS) = "T";
                vdef(OBSTRUCTIONS)++;
        }
        if (!vdef(VDIST)) {
                vval(VDIST) = "F";
                vdef(VDIST)++;
        }
        if (!vdef(OCCUPANCY)) {
                vval(OCCUPANCY) = "U";
                vdef(OCCUPANCY)++;
        }
                                /* append rendering options */
        if (vdef(RENDER))
                rtargc += wordstring(rtargv+rtargc, vval(RENDER));
        
        if (gp == NULL)         /* already initialized? */
                return;
                                /* set grid parameters */
        gp->grid[0] = gp->grid[1] = gp->grid[2] = 0;
        if (sscanf(vval(SECTION),
                "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %hd %hd %hd",
                        &gp->orig[0], &gp->orig[1], &gp->orig[2],
                        &gp->xv[0][0], &gp->xv[0][1], &gp->xv[0][2],
                        &gp->xv[1][0], &gp->xv[1][1], &gp->xv[1][2],
                        &gp->xv[2][0], &gp->xv[2][1], &gp->xv[2][2],
                        &gp->grid[0], &gp->grid[1], &gp->grid[2]) < 12)
                badvalue(SECTION);
        maxlen = 0.;
        for (i = 0; i < 3; i++)
                if ((len[i] = VLEN(gp->xv[i])) > maxlen)
                        maxlen = len[i];
        if (!vdef(GRID)) {
                sprintf(buf, "%.4f", maxlen/8.);
                vval(GRID) = savqstr(buf);
                vdef(GRID)++;
        }
        if ((d = vflt(GRID)) <= FTINY)
                badvalue(GRID);
        for (i = 0; i < 3; i++)
                if (gp->grid[i] <= 0)
                        gp->grid[i] = len[i]/d + (1.-FTINY);
}


creatholo(gp)                   /* create a holodeck output file */
HDGRID  *gp;
{
        extern char     VersionID[];
        long    endloc = 0;
        int     fd;
        FILE    *fp;
                                        /* open & truncate file */
        if ((fp = fopen(hdkfile, "w+")) == NULL) {
                sprintf(errmsg, "cannot open \"%s\" for writing", hdkfile);
                error(SYSTEM, errmsg);
        }
                                        /* write information header */
        newheader("RADIANCE", fp);
        fprintf(fp, "SOFTWARE= %s\n", VersionID);
        printvars(fp);
        fputformat(HOLOFMT, fp);
        fputc('\n', fp);
        putw(HOLOMAGIC, fp);            /* put magic number & terminus */
        fwrite(&endloc, sizeof(long), 1, fp);
        fd = dup(fileno(fp));
        fclose(fp);                     /* flush and close stdio stream */
        hdinit(fd, gp);                 /* allocate and initialize index */
}


headline(s)                     /* process information header line */
char    *s;
{
        extern char     FMTSTR[];
        register char   *cp;
        char    fmt[32];

        if (formatval(fmt, s)) {
                if (strcmp(fmt, HOLOFMT)) {
                        sprintf(errmsg, "%s file \"%s\" has %s%s",
                                        HOLOFMT, hdkfile, FMTSTR, fmt);
                        error(USER, errmsg);
                }
                return;
        }
        for (cp = s; *cp; cp++)         /* take off any comments */
                if (*cp == '#') {
                        *cp = '\0';
                        break;
                }
        setvariable(s, matchvar);       /* don't flag errors */
}


loadholo()                      /* start loading a holodeck from fname */
{
        extern long     ftell();
        FILE    *fp;
        int     fd;
        long    fpos;
                                        /* open holodeck file */
        if ((fp = fopen(hdkfile, ncprocs>0 ? "r+" : "r")) == NULL) {
                sprintf(errmsg, "cannot open \"%s\" for %s", hdkfile,
                                ncprocs>0 ? "appending" : "reading");
                error(SYSTEM, errmsg);
        }
                                        /* load variables from header */
        getheader(fp, headline, NULL);
                                        /* check magic number */
        if (getw(fp) != HOLOMAGIC) {
                sprintf(errmsg, "bad magic number in holodeck file \"%s\"",
                                hdkfile);
                error(USER, errmsg);
        }
        fread(&fpos, sizeof(long), 1, fp);
        if (fpos != 0)
                error(WARNING, "ignoring multiple sections in holodeck file");
        fpos = ftell(fp);                       /* get stdio position */
        fd = dup(fileno(fp));
        fclose(fp);                             /* done with stdio */
        lseek(fd, fpos, 0);                     /* align system file pointer */
        hdinit(fd, NULL);                       /* allocate and load index */
}


done_packets(pl)                /* handle finished packets */
PACKET  *pl;
{
        static int      n2flush = 0;
        register PACKET *p;

        while (pl != NULL) {
                p = pl; pl = p->next; p->next = NULL;
                if (p->nr > 0) {                /* add to holodeck */
                        bcopy((char *)p->ra,
                                (char *)hdnewrays(hdlist[p->hd],p->bi,p->nr),
                                p->nr*sizeof(RAYVAL));
                        if (outdev != NULL)     /* display it */
                                disp_packet((PACKHEAD *)p);
                        if (hdcachesize <= 0)   /* manual flushing */
                                n2flush += p->nr;
                        nraysdone += p->nr;
                        npacksdone++;
                }
                p->nr = 0;                      /* push onto free list */
                p->next = freepacks;
                freepacks = p;
        }
        if (n2flush > 512*RPACKSIZ*nprocs) {
                hdflush(NULL);                  /* flush holodeck buffers */
                n2flush = 0;
        }
}


int
done_rtrace()                   /* clean up and close rtrace calculation */
{
        int     status;
                                        /* already closed? */
        if (!nprocs)
                return;
                                        /* report activity */
        wputs("closing rtrace process...\n");
                                        /* flush beam queue */
        done_packets(flush_queue());
                                        /* close rtrace */
        if ((status = end_rtrace()))
                error(WARNING, "bad exit status from rtrace");
        if (vdef(REPORT))               /* report time */
                report(0);
        return(status);                 /* return status */
}


new_rtrace()                    /* restart rtrace calculation */
{
        char    combuf[128];

        if (nprocs > 0)                 /* already running? */
                return;
        wputs("restarting rtrace process...\n");
        if (vdef(RIF)) {                /* rerun rad to update octree */
                sprintf(combuf, "rad -v 0 -s -w %s", vval(RIF));
                if (system(combuf))
                        error(WARNING, "error running rad");
        }
        if (start_rtrace() < 1)         /* start rtrace */
                error(WARNING, "cannot restart rtrace");
        else if (vdef(REPORT))
                report(0);
}


getradfile(rfargs)              /* run rad and get needed variables */
char    *rfargs;
{
        static short    mvar[] = {OCTREE,-1};
        static char     tf1[] = TEMPLATE;
        char    tf2[64];
        char    combuf[256];
        char    *pippt;
        register int    i;
        register char   *cp;
                                        /* create rad command */
        mktemp(tf1);
        sprintf(tf2, "%s.rif", tf1);
        sprintf(combuf,
                "rad -v 0 -s -e -w %s OPTFILE=%s | egrep '^[ \t]*(NOMATCH",
                        rfargs, tf1);
        cp = combuf;
        while (*cp){
                if (*cp == '|') pippt = cp;
                cp++;
        }                               /* match unset variables */
        for (i = 0; mvar[i] >= 0; i++)
                if (!vdef(mvar[i])) {
                        *cp++ = '|';
                        strcpy(cp, vnam(mvar[i]));
                        while (*cp) cp++;
                        pippt = NULL;
                }
        if (pippt != NULL)
                strcpy(pippt, "> /dev/null");   /* nothing to match */
        else
                sprintf(cp, ")[ \t]*=' > %s", tf2);
        if (system(combuf)) {
                unlink(tf2);                    /* clean up */
                unlink(tf1);
                error(SYSTEM, "cannot execute rad command");
        }
        if (pippt == NULL) {
                loadvars(tf2);                  /* load variables */
                unlink(tf2);
        }
        rtargc += wordfile(rtargv+rtargc, tf1); /* get rtrace options */
        unlink(tf1);                    /* clean up */
}


rootname(rn, fn)                /* remove tail from end of fn */
register char   *rn, *fn;
{
        char    *tp, *dp;

        for (tp = NULL, dp = rn; *rn = *fn++; rn++)
                if (ISDIRSEP(*rn))
                        dp = rn;
                else if (*rn == '.')
                        tp = rn;
        if (tp != NULL && tp > dp)
                *tp = '\0';
}


badvalue(vc)                    /* report bad variable value and exit */
int     vc;
{
        sprintf(errmsg, "bad value for variable '%s'", vnam(vc));
        error(USER, errmsg);
}


eputs(s)                        /* put error message to stderr */
register char  *s;
{
        static int  midline = 0;

        if (!*s)
                return;
        if (!midline++) {       /* prepend line with program name */
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        if (s[strlen(s)-1] == '\n') {
                fflush(stderr);
                midline = 0;
        }
}


wputs(s)                        /* put warning string to stderr */
char    *s;
{
        if (!nowarn)
                eputs(s);
}


quit(ec)                        /* exit program gracefully */
int     ec;
{
        int     status = 0;

        if (hdlist[0] != NULL) {        /* flush holodeck */
                if (nprocs > 0)
                        status = done_rtrace();
                hdflush(NULL);
                if (ncprocs > 0 && vdef(REPORT)) {
                        long    fsiz, fuse;
                        fsiz = hdfilen(hdlist[0]->fd);
                        fuse = hdfiluse(hdlist[0]->fd, 1);
                        fprintf(stderr,
                        "%s: %.1f Mbyte holodeck file, %.1f%% fragmentation\n",
                                        hdkfile, fsiz/(1024.*1024.),
                                        100.*(fsiz-fuse)/fsiz);
                }
        }
        if (orig_mode >= 0)             /* reset holodeck access mode */
                fchmod(hdlist[0]->fd, orig_mode);
        if (outdev != NULL)             /* close display */
                disp_close();
        exit(ec ? ec : status);         /* exit */
}
Revision:	3.21
Committed:	Fri Dec 12 18:12:40 1997 UTC (26 years, 4 months ago) by gregl
Content type:	text/plain
Branch:	MAIN
Changes since 3.20:	+53 -24 lines
Log Message:	now we don't quit display process when our calculation ends
#	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.1	#include "paths.h"
14	gregl	3.12	#include <signal.h>
15	gregl	3.1	#include <sys/types.h>
16	gregl	3.12	#include <sys/stat.h>
17	gregl	3.1
18			/* the following must be consistent with rholo.h */
19			int NVARS = NRHVARS; /* total number of variables */
20
21			VARIABLE vv[] = RHVINIT; /* variable-value pairs */
22
23			char progname; / our program name */
24			char hdkfile; / holodeck file name */
25			char froot[MAXPATH]; /* root file name */
26
27			int nowarn = 0; /* turn warnings off? */
28
29			int ncprocs = 0; /* desired number of compute processes */
30
31			char outdev = NULL; / output device name */
32
33	gregl	3.17	int readinp = 0; /* read commands from stdin */
34
35	gregl	3.20	int force = 0; /* allow overwrite of holodeck */
36
37	gregl	3.1	time_t starttime; /* time we got started */
38			time_t endtime; /* time we should end by */
39			time_t reporttime; /* time for next report */
40
41	gregl	3.8	long maxdisk; /* maximum file space (bytes) */
42
43	gregl	3.1	int rtargc = 1; /* rtrace command */
44			char *rtargv[128] = {"rtrace", NULL};
45
46	gregl	3.12	int orig_mode = -1; /* original file mode (-1 if unchanged) */
47
48	gregl	3.1	long nraysdone = 0L; /* number of rays done */
49			long npacksdone = 0L; /* number of packets done */
50
51			PACKET freepacks; / available packets */
52
53	gregl	3.12	char sigerr[NSIG]; / signal error messages */
54
55	gregl	3.1	extern time_t time();
56
57
58			main(argc, argv)
59			int argc;
60			char *argv[];
61			{
62			HDGRID hdg;
63			int i;
64	gregl	3.3	/* mark start time */
65			starttime = time(NULL);
66	gregl	3.18	initurand(16384); /* initialize urand */
67	gregl	3.1	progname = argv[0]; /* get arguments */
68			for (i = 1; i < argc && argv[i][0] == '-'; i++)
69			switch (argv[i][1]) {
70			case 'w': /* turn off warnings */
71			nowarn++;
72			break;
73			case 'f': /* force overwrite */
74			force++;
75			break;
76	gregl	3.17	case 'i': /* read input from stdin */
77			readinp++;
78			break;
79	gregl	3.1	case 'n': /* compute processes */
80			if (i >= argc-2)
81			goto userr;
82			ncprocs = atoi(argv[++i]);
83			break;
84			case 'o': /* output display */
85			if (i >= argc-2)
86			goto userr;
87			outdev = argv[++i];
88			break;
89			default:
90			goto userr;
91			}
92			/* do we have a job? */
93			if (outdev == NULL && ncprocs <= 0)
94			goto userr;
95			/* get root file name */
96			rootname(froot, hdkfile=argv[i++]);
97			/* load... */
98			if (i < argc) { /* variables */
99			loadvars(argv[i++]);
100			/* cmdline settings */
101			for ( ; i < argc; i++)
102			if (setvariable(argv[i], matchvar) < 0) {
103			sprintf(errmsg, "unknown variable: %s",
104			argv[i]);
105			error(USER, errmsg);
106			}
107			/* check settings */
108			checkvalues();
109			/* load RIF if any */
110			if (vdef(RIF))
111			getradfile(vval(RIF));
112			/* set defaults */
113			setdefaults(&hdg);
114			/* 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			creatholo(&hdg);
120	gregl	3.3	} else { /* else load holodeck */
121	gregl	3.1	loadholo();
122	gregl	3.15	/* check settings */
123			checkvalues();
124			/* load RIF if any */
125			if (vdef(RIF))
126	gregl	3.3	getradfile(vval(RIF));
127	gregl	3.15	/* set defaults */
128			setdefaults(NULL);
129	gregl	3.3	}
130	gregl	3.1	/* initialize */
131			initrholo();
132	gregl	3.15	/* main loop */
133	gregl	3.1	while (rholo())
134			;
135			/* done */
136			quit(0);
137			userr:
138			fprintf(stderr,
139			"Usage: %s {-n nprocs\|-o disp} [-w][-f] output.hdk [control.hif [VAR=val ..]]\n",
140			progname);
141			quit(1);
142			}
143
144
145	gregl	3.12	onsig(signo) /* fatal signal */
146			int signo;
147			{
148			static int gotsig = 0;
149
150			if (gotsig++) /* two signals and we're gone! */
151			_exit(signo);
152
153			alarm(30); /* allow 30 seconds to clean up */
154			signal(SIGALRM, SIG_DFL); /* make certain we do die */
155			eputs("signal - ");
156			eputs(sigerr[signo]);
157			eputs("\n");
158			quit(3);
159			}
160
161
162			sigdie(signo, msg) /* set fatal signal */
163			int signo;
164			char *msg;
165			{
166			if (signal(signo, onsig) == SIG_IGN)
167			signal(signo, SIG_IGN);
168			sigerr[signo] = msg;
169			}
170
171
172			int
173			resfmode(fd, mod) /* restrict open file access mode */
174			int fd, mod;
175			{
176			struct stat stbuf;
177			/* get original mode */
178			if (fstat(fd, &stbuf) < 0)
179			error(SYSTEM, "cannot stat open holodeck file");
180			mod &= stbuf.st_mode; /* always more restrictive */
181			if (mod == stbuf.st_mode)
182			return(-1); /* already set */
183			/* else change it */
184			if (fchmod(fd, mod) < 0) {
185			error(WARNING, "cannot change holodeck file access mode");
186			return(-1);
187			}
188			return(stbuf.st_mode); /* return original mode */
189			}
190
191
192	gregl	3.1	initrholo() /* get our holodeck running */
193			{
194			extern int global_packet();
195			register int i;
196	gregl	3.17	/* close holodeck on exec() */
197			fcntl(hdlist[0]->fd, F_SETFD, FD_CLOEXEC);
198	gregl	3.4
199			if (outdev != NULL) /* open output device */
200			disp_open(outdev);
201	gregl	3.1	else if (ncprocs > 0) /* else use global ray feed */
202			init_global();
203	gregl	3.8	/* record disk space limit */
204			if (!vdef(DISKSPACE))
205			maxdisk = 0;
206			else
207	gregl	3.9	maxdisk = 1024.1024.vflt(DISKSPACE);
208	gregl	3.3	/* record end time */
209	gregl	3.1	if (!vdef(TIME) \|\| vflt(TIME) <= FTINY)
210			endtime = 0;
211			else
212			endtime = starttime + vflt(TIME)*3600.;
213			/* set up memory cache */
214	gregl	3.5	if (outdev == NULL)
215			hdcachesize = 0; /* manual flushing */
216			else if (vdef(CACHE))
217			hdcachesize = 1024.1024.vflt(CACHE);
218	gregl	3.1	/* open report file */
219			if (vdef(REPORT)) {
220			register char *s = sskip2(vval(REPORT), 1);
221			if (*s && freopen(s, "a", stderr) == NULL)
222			quit(2);
223			}
224			/* start rtrace */
225			if (ncprocs > 0) {
226			i = start_rtrace();
227			if (i < 1)
228	gregl	3.20	error(USER, "cannot start rtrace process(es)");
229	gregl	3.1	if (vdef(REPORT)) { /* make first report */
230			printargs(rtargc, rtargv, stderr);
231			report(0);
232			}
233			/* allocate packets */
234			freepacks = (PACKET )bmalloc(isizeof(PACKET));
235			if (freepacks == NULL)
236			goto memerr;
237			freepacks[--i].nr = 0;
238			freepacks[i].next = NULL;
239			if (!vbool(OBSTRUCTIONS)) {
240			freepacks[i].offset = (float *)bmalloc(
241			RPACKSIZsizeof(float)(i+1) );
242			if (freepacks[i].offset == NULL)
243			goto memerr;
244			} else
245			freepacks[i].offset = NULL;
246			while (i--) {
247			freepacks[i].nr = 0;
248			freepacks[i].offset = freepacks[i+1].offset == NULL ?
249			NULL : freepacks[i+1].offset+RPACKSIZ ;
250			freepacks[i].next = &freepacks[i+1];
251			}
252			}
253	gregl	3.12	/* set up signal handling */
254			sigdie(SIGINT, "Interrupt");
255			sigdie(SIGHUP, "Hangup");
256			sigdie(SIGTERM, "Terminate");
257			sigdie(SIGPIPE, "Broken pipe");
258			sigdie(SIGALRM, "Alarm clock");
259			#ifdef SIGXCPU
260			sigdie(SIGXCPU, "CPU limit exceeded");
261			sigdie(SIGXFSZ, "File size exceeded");
262			#endif
263			/* protect holodeck file */
264			orig_mode = resfmode(hdlist[0]->fd, ncprocs>0 ? 0 : 0444);
265	gregl	3.1	return;
266			memerr:
267			error(SYSTEM, "out of memory in initrholo");
268			}
269
270
271			rholo() /* holodeck main loop */
272			{
273			static int idle = 1;
274			PACKET pl = NULL, plend;
275			register PACKET *p;
276			time_t t;
277			long l;
278	gregl	3.4
279			if (outdev != NULL) /* check display */
280			if (!disp_check(idle))
281			return(0);
282	gregl	3.1	/* display only? */
283	gregl	3.19	if (nprocs <= 0)
284	gregl	3.21	return(outdev != NULL);
285	gregl	3.1	/* check file size */
286	gregl	3.9	if (maxdisk > 0 && hdfilen(hdlist[0]->fd) >= maxdisk) {
287	gregl	3.8	error(WARNING, "file limit exceeded");
288	gregl	3.21	done_rtrace();
289			idle = 1;
290			return(1); /* comes back */
291	gregl	3.8	}
292	gregl	3.1	/* check time */
293	gregl	3.3	if (endtime > 0 \|\| reporttime > 0)
294	gregl	3.1	t = time(NULL);
295	gregl	3.8	if (endtime > 0 && t >= endtime) {
296			error(WARNING, "time limit exceeded");
297	gregl	3.21	done_rtrace();
298			idle = 1;
299			return(1); /* comes back */
300	gregl	3.8	}
301	gregl	3.3	if (reporttime > 0 && t >= reporttime)
302	gregl	3.1	report(t);
303			/* get packets to process */
304			while (freepacks != NULL) {
305			p = freepacks; freepacks = p->next; p->next = NULL;
306			if (!next_packet(p)) {
307			p->next = freepacks; freepacks = p;
308	gregl	3.21	idle = 1;
309	gregl	3.1	break;
310			}
311			if (pl == NULL) pl = p;
312			else plend->next = p;
313			plend = p;
314			}
315	gregl	3.21	/* process packets */
316	gregl	3.1	done_packets(do_packets(pl));
317			return(1); /* and continue */
318			}
319
320
321			report(t) /* report progress so far */
322			time_t t;
323			{
324	gregl	3.21	static time_t seconds2go = 1000000;
325
326			if (t == 0L)
327	gregl	3.1	t = time(NULL);
328	gregl	3.21	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	gregl	3.1	}
336
337
338			setdefaults(gp) /* set default values */
339			register HDGRID *gp;
340			{
341			extern char *atos();
342			register int i;
343			double len[3], maxlen, d;
344			char buf[64];
345
346			if (!vdef(SECTION)) {
347			sprintf(errmsg, "%s must be defined", vnam(SECTION));
348			error(USER, errmsg);
349			}
350			if (vdef(SECTION) > 1) {
351			sprintf(errmsg, "ignoring all but first %s", vnam(SECTION));
352			error(WARNING, errmsg);
353			}
354			if (!vdef(OCTREE)) {
355			if ((vval(OCTREE) = bmalloc(strlen(froot)+5)) == NULL)
356			error(SYSTEM, "out of memory");
357			sprintf(vval(OCTREE), "%s.oct", froot);
358			vdef(OCTREE)++;
359			}
360			if (!vdef(OBSTRUCTIONS)) {
361			vval(OBSTRUCTIONS) = "T";
362			vdef(OBSTRUCTIONS)++;
363	gregl	3.14	}
364			if (!vdef(VDIST)) {
365			vval(VDIST) = "F";
366			vdef(VDIST)++;
367	gregl	3.1	}
368			if (!vdef(OCCUPANCY)) {
369			vval(OCCUPANCY) = "U";
370			vdef(OCCUPANCY)++;
371			}
372			/* append rendering options */
373			if (vdef(RENDER))
374			rtargc += wordstring(rtargv+rtargc, vval(RENDER));
375	gregl	3.15
376			if (gp == NULL) /* already initialized? */
377			return;
378			/* set grid parameters */
379	gregl	3.16	gp->grid[0] = gp->grid[1] = gp->grid[2] = 0;
380	gregl	3.15	if (sscanf(vval(SECTION),
381	gregl	3.16	"%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %hd %hd %hd",
382	gregl	3.15	&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	gregl	3.16	&gp->xv[2][0], &gp->xv[2][1], &gp->xv[2][2],
386			&gp->grid[0], &gp->grid[1], &gp->grid[2]) < 12)
387	gregl	3.15	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	gregl	3.16	if (gp->grid[i] <= 0)
401			gp->grid[i] = len[i]/d + (1.-FTINY);
402	gregl	3.1	}
403
404
405			creatholo(gp) /* create a holodeck output file */
406			HDGRID *gp;
407			{
408	gregl	3.12	extern char VersionID[];
409	gregl	3.1	long endloc = 0;
410	gregl	3.10	int fd;
411	gregl	3.1	FILE *fp;
412			/* open & truncate file */
413			if ((fp = fopen(hdkfile, "w+")) == NULL) {
414			sprintf(errmsg, "cannot open \"%s\" for writing", hdkfile);
415			error(SYSTEM, errmsg);
416			}
417			/* write information header */
418			newheader("RADIANCE", fp);
419	gregl	3.12	fprintf(fp, "SOFTWARE= %s\n", VersionID);
420	gregl	3.1	printvars(fp);
421			fputformat(HOLOFMT, fp);
422			fputc('\n', fp);
423			putw(HOLOMAGIC, fp); /* put magic number & terminus */
424			fwrite(&endloc, sizeof(long), 1, fp);
425	gregl	3.10	fd = dup(fileno(fp));
426			fclose(fp); /* flush and close stdio stream */
427			hdinit(fd, gp); /* allocate and initialize index */
428	gregl	3.1	}
429
430
431			headline(s) /* process information header line */
432			char *s;
433			{
434			extern char FMTSTR[];
435			register char *cp;
436			char fmt[32];
437
438	gregl	3.2	if (formatval(fmt, s)) {
439	gregl	3.1	if (strcmp(fmt, HOLOFMT)) {
440			sprintf(errmsg, "%s file \"%s\" has %s%s",
441			HOLOFMT, hdkfile, FMTSTR, fmt);
442			error(USER, errmsg);
443			}
444			return;
445			}
446			for (cp = s; cp; cp++) / take off any comments */
447			if (*cp == '#') {
448			*cp = '\0';
449			break;
450			}
451			setvariable(s, matchvar); /* don't flag errors */
452			}
453
454
455			loadholo() /* start loading a holodeck from fname */
456			{
457	gregl	3.10	extern long ftell();
458	gregl	3.1	FILE *fp;
459	gregl	3.10	int fd;
460			long fpos;
461	gregl	3.4	/* open holodeck file */
462			if ((fp = fopen(hdkfile, ncprocs>0 ? "r+" : "r")) == NULL) {
463			sprintf(errmsg, "cannot open \"%s\" for %s", hdkfile,
464			ncprocs>0 ? "appending" : "reading");
465	gregl	3.1	error(SYSTEM, errmsg);
466			}
467			/* load variables from header */
468			getheader(fp, headline, NULL);
469			/* check magic number */
470			if (getw(fp) != HOLOMAGIC) {
471			sprintf(errmsg, "bad magic number in holodeck file \"%s\"",
472			hdkfile);
473			error(USER, errmsg);
474			}
475	gregl	3.10	fread(&fpos, sizeof(long), 1, fp);
476			if (fpos != 0)
477	gregl	3.1	error(WARNING, "ignoring multiple sections in holodeck file");
478	gregl	3.10	fpos = ftell(fp); /* get stdio position */
479			fd = dup(fileno(fp));
480			fclose(fp); /* done with stdio */
481			lseek(fd, fpos, 0); /* align system file pointer */
482			hdinit(fd, NULL); /* allocate and load index */
483	gregl	3.1	}
484
485
486			done_packets(pl) /* handle finished packets */
487			PACKET *pl;
488			{
489	gregl	3.13	static int n2flush = 0;
490	gregl	3.1	register PACKET *p;
491
492			while (pl != NULL) {
493			p = pl; pl = p->next; p->next = NULL;
494			if (p->nr > 0) { /* add to holodeck */
495			bcopy((char *)p->ra,
496			(char *)hdnewrays(hdlist[p->hd],p->bi,p->nr),
497			p->nr*sizeof(RAYVAL));
498			if (outdev != NULL) /* display it */
499	gregl	3.7	disp_packet((PACKHEAD *)p);
500	gregl	3.13	if (hdcachesize <= 0) /* manual flushing */
501			n2flush += p->nr;
502	gregl	3.6	nraysdone += p->nr;
503			npacksdone++;
504	gregl	3.1	}
505			p->nr = 0; /* push onto free list */
506			p->next = freepacks;
507			freepacks = p;
508	gregl	3.5	}
509	gregl	3.19	if (n2flush > 512RPACKSIZnprocs) {
510	gregl	3.5	hdflush(NULL); /* flush holodeck buffers */
511	gregl	3.13	n2flush = 0;
512	gregl	3.1	}
513			}
514
515
516	gregl	3.21	int
517			done_rtrace() /* clean up and close rtrace calculation */
518	gregl	3.20	{
519	gregl	3.21	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	gregl	3.20	char combuf[128];
539
540	gregl	3.21	if (nprocs > 0) /* already running? */
541	gregl	3.20	return;
542	gregl	3.21	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	gregl	3.20	}
553
554
555	gregl	3.1	getradfile(rfargs) /* run rad and get needed variables */
556			char *rfargs;
557			{
558	gregl	3.15	static short mvar[] = {OCTREE,-1};
559	gregl	3.1	static char tf1[] = TEMPLATE;
560			char tf2[64];
561			char combuf[256];
562	gregl	3.3	char *pippt;
563	gregl	3.1	register int i;
564			register char *cp;
565			/* create rad command */
566			mktemp(tf1);
567			sprintf(tf2, "%s.rif", tf1);
568			sprintf(combuf,
569			"rad -v 0 -s -e -w %s OPTFILE=%s \| egrep '^[ \t]*(NOMATCH",
570			rfargs, tf1);
571			cp = combuf;
572	gregl	3.3	while (*cp){
573			if (*cp == '\|') pippt = cp;
574			cp++;
575			} /* match unset variables */
576	gregl	3.1	for (i = 0; mvar[i] >= 0; i++)
577			if (!vdef(mvar[i])) {
578			*cp++ = '\|';
579			strcpy(cp, vnam(mvar[i]));
580			while (*cp) cp++;
581	gregl	3.3	pippt = NULL;
582	gregl	3.1	}
583	gregl	3.3	if (pippt != NULL)
584			strcpy(pippt, "> /dev/null"); /* nothing to match */
585			else
586			sprintf(cp, ")[ \t]*=' > %s", tf2);
587	gregl	3.1	if (system(combuf)) {
588			unlink(tf2); /* clean up */
589			unlink(tf1);
590	gregl	3.20	error(SYSTEM, "cannot execute rad command");
591	gregl	3.1	}
592	gregl	3.3	if (pippt == NULL) {
593			loadvars(tf2); /* load variables */
594			unlink(tf2);
595			}
596	gregl	3.1	rtargc += wordfile(rtargv+rtargc, tf1); /* get rtrace options */
597	gregl	3.3	unlink(tf1); /* clean up */
598	gregl	3.1	}
599
600
601			rootname(rn, fn) /* remove tail from end of fn */
602			register char rn, fn;
603			{
604			char tp, dp;
605
606			for (tp = NULL, dp = rn; rn = fn++; rn++)
607			if (ISDIRSEP(*rn))
608			dp = rn;
609			else if (*rn == '.')
610			tp = rn;
611			if (tp != NULL && tp > dp)
612			*tp = '\0';
613			}
614
615
616			badvalue(vc) /* report bad variable value and exit */
617			int vc;
618			{
619			sprintf(errmsg, "bad value for variable '%s'", vnam(vc));
620			error(USER, errmsg);
621			}
622
623
624			eputs(s) /* put error message to stderr */
625			register char *s;
626			{
627			static int midline = 0;
628
629			if (!*s)
630			return;
631			if (!midline++) { /* prepend line with program name */
632			fputs(progname, stderr);
633			fputs(": ", stderr);
634			}
635			fputs(s, stderr);
636			if (s[strlen(s)-1] == '\n') {
637			fflush(stderr);
638			midline = 0;
639			}
640			}
641
642
643			wputs(s) /* put warning string to stderr */
644			char *s;
645			{
646			if (!nowarn)
647			eputs(s);
648			}
649
650
651			quit(ec) /* exit program gracefully */
652			int ec;
653			{
654			int status = 0;
655
656			if (hdlist[0] != NULL) { /* flush holodeck */
657	gregl	3.21	if (nprocs > 0)
658			status = done_rtrace();
659	gregl	3.19	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	gregl	3.3	"%s: %.1f Mbyte holodeck file, %.1f%% fragmentation\n",
666	gregl	3.19	hdkfile, fsiz/(1024.*1024.),
667			100.*(fsiz-fuse)/fsiz);
668			}
669	gregl	3.1	}
670	gregl	3.12	if (orig_mode >= 0) /* reset holodeck access mode */
671			fchmod(hdlist[0]->fd, orig_mode);
672	gregl	3.11	if (outdev != NULL) /* close display */
673			disp_close();
674	gregl	3.1	exit(ec ? ec : status); /* exit */
675			}