ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/hd/rhoptimize.c

Comparing ray/src/hd/rhoptimize.c (file contents):
Revision 3.1 by gwlarson, Wed Nov 4 16:37:19 1998 UTC vs.
Revision 3.3 by gwlarson, Fri Nov 6 16:54:23 1998 UTC

#	Line 12 | Line 12 | static char SCCSid[] = "$SunId$ SGI";
12
13		#include "holo.h"
14
15	+	#include <signal.h>
16	+
17		#ifndef BKBSIZE
18	<	#define BKBSIZE         64              /* beam clump size (kilobytes) */
18	>	#define BKBSIZE         256             /* beam clump size (kilobytes) */
19		#endif
20
21	+	#define flgop(p,i,op)           ((p)[(i)>>5] op (1L<<((i)&0x1f)))
22	+	#define isset(p,i)              flgop(p,i,&)
23	+	#define setfl(p,i)              flgop(p,i,|=)
24	+	#define clrfl(p,i)              flgop(p,i,&=~)
25
26		char    *progname;
27	+	char    tempfile[128];
28
29	+	extern char     *rindex();
30	+	extern int      quit();
31		extern long     rhinitcopy();
32
33
#	Line 26 | Line 35 | main(argc, argv)
35		int     argc;
36		char    *argv[];
37		{
29	–	char    nambuf[128];
38		char    *inpname, *outname;
39		int     hdfd[2];
40		long    nextipos, lastopos, thisopos;
#	Line 39 | Line 47 | char   *argv[];
47		inpname = argv[1];
48		if (argc == 3)                  /* use given output file */
49		outname = argv[2];
50	<	else {                          /* else create temporary file */
51	<	strcpy(nambuf, inpname);
52	<	if ((outname = strrchr(nambuf, '/')) != NULL)
50	>	else {                          /* else use temporary file */
51	>	if (access(inpname, R_OK|W_OK) < 0) {   /* check permissions */
52	>	sprintf(errmsg, "cannot access \"%s\"", inpname);
53	>	error(SYSTEM, errmsg);
54	>	}
55	>	strcpy(tempfile, inpname);
56	>	if ((outname = rindex(tempfile, '/')) != NULL)
57		outname++;
58		else
59	<	outname = nambuf;
59	>	outname = tempfile;
60		sprintf(outname, "rho%d.hdk", getpid());
61	<	outname = nambuf;
61	>	outname = tempfile;
62		}
63		/* copy holodeck file header */
64		nextipos = rhinitcopy(hdfd, inpname, outname);
#	Line 71 | Line 83 | char   *argv[];
83		/* clean up */
84		close(hdfd[0]);
85		close(hdfd[1]);
86	<	if (argc == 2 && rename(outname, inpname) < 0) {
86	>	if (outname == tempfile && rename(outname, inpname) < 0) {
87		sprintf(errmsg, "cannot rename \"%s\" to \"%s\"",
88		outname, inpname);
89		error(SYSTEM, errmsg);
#	Line 96 | Line 108 | char   *infn, *outfn;
108		sprintf(errmsg, "cannot open \"%s\" for writing", outfn);
109		error(SYSTEM, errmsg);
110		}
111	+	/* set up signal handling */
112	+	if (signal(SIGINT, quit) == SIG_IGN) signal(SIGINT, SIG_IGN);
113	+	if (signal(SIGHUP, quit) == SIG_IGN) signal(SIGHUP, SIG_IGN);
114	+	if (signal(SIGTERM, quit) == SIG_IGN) signal(SIGTERM, SIG_IGN);
115	+	#ifdef SIGXCPU
116	+	if (signal(SIGXCPU, quit) == SIG_IGN) signal(SIGXCPU, SIG_IGN);
117	+	if (signal(SIGXFSZ, quit) == SIG_IGN) signal(SIGXFSZ, SIG_IGN);
118	+	#endif
119		/* copy and verify header */
120	<	if (checkheader(infp, HOLOFMT, outfp) < 0 ||
101	<	getw(infp) != HOLOMAGIC)
120	>	if (checkheader(infp, HOLOFMT, outfp) < 0 || getw(infp) != HOLOMAGIC)
121		error(USER, "input not in holodeck format");
122		fputformat(HOLOFMT, outfp);
123		fputc('\n', outfp);
#	Line 111 | Line 130 | char   *infn, *outfn;
130		fclose(infp);
131		if (fclose(outfp) == EOF)
132		error(SYSTEM, "file flushing error in rhinitcopy");
133	<	/* we flush everything manually */
133	>	/* flush everything manually hence */
134		hdcachesize = 0;
135		/* return input position */
136		return(ifpos);
#	Line 149 | Line 168 | HOLO   *hp;
168		GCOORD  *gc;
169		{
170		GCOORD  gci0;
171	<	int     i, j;
171	>	register int    i, j;
172
173		for (i = 3; i--; ) {
174		copystruct(&gci0, gc);
175		gcshifti(&gci0, 0, i-1, hp);
176		for (j = 3; j--; ) {
177		copystruct(ng+(3*i+j), &gci0);
178	<	gcshifti(ng+(3*i+j), 1, j-1, hp);
178	>	gcshifti(ng+(3*i+j), gci0.w==gc->w, j-1, hp);
179		}
180		}
181		}
#	Line 181 | Line 200 | int    b;
200		bneighrem = 0;
201		for (i = 9; i--; )
202		for (j = 9; j--; ) {
203	<	if (i == 4 & j == 4)
203	>	if (i == 4 & j == 4)    /* don't copy starting beam */
204		continue;
205	+	if (wg0[i].w == wg1[j].w)
206	+	continue;
207		copystruct(bgc, wg0+i);
208		copystruct(bgc+1, wg1+j);
209		bneighlist[bneighrem++] = hdbindex(hp, bgc);
210	+	#ifdef DEBUG
211	+	if (bneighlist[bneighrem-1] <= 0)
212	+	error(CONSISTENCY, "bad beam in firstneigh");
213	+	#endif
214		}
215		return(nextneigh());
216		}
217
218
219	+	BEAMI   *beamdir;
220	+
221	+	int
222	+	bpcmp(b1p, b2p)                 /* compare beam positions on disk */
223	+	int     *b1p, *b2p;
224	+	{
225	+	register long   pdif = beamdir[*b1p].fo - beamdir[*b2p].fo;
226	+
227	+	if (pdif > 0L) return(1);
228	+	if (pdif < 0L) return(-1);
229	+	return(0);
230	+	}
231	+
232	+
233		copysect(ifd, ofd)              /* copy holodeck section from ifd to ofd */
234		int     ifd, ofd;
235		{
197	–	#define beamdone(b)     (!hinp->bi[b].nrd || bnrays(hout,b))
236		static short    primes[] = {9431,6803,4177,2659,1609,887,587,251,47,1};
237	<	register HOLO   *hinp, *hout;
237	>	register HOLO   *hinp;
238	>	HOLO    *hout;
239		register BEAM   *bp;
240	+	unsigned int4   *bflags;
241		int     *bqueue;
242		int     bqlen;
243		int4    bqtotal;
244	<	int     bc, bci, bqc, bnc, myprime;
244	>	int     bc, bci, bqc, myprime;
245		register int    i;
246		/* load input section directory */
247		hinp = hdinit(ifd, NULL);
248		/* create output section directory */
249		hout = hdinit(ofd, (HDGRID *)hinp);
250		/* allocate beam queue */
251	<	if ((bqueue = (int *)malloc(nbeams(hinp)*sizeof(int))) == NULL)
251	>	bqueue = (int *)malloc(nbeams(hinp)*sizeof(int));
252	>	bflags = (unsigned int4 *)calloc((nbeams(hinp)>>5)+1,
253	>	sizeof(unsigned int4));
254	>	if (bqueue == NULL | bflags == NULL)
255		error(SYSTEM, "out of memory in copysect");
256	+	/* mark empty beams as done */
257	+	for (i = nbeams(hinp); i > 0; i--)
258	+	if (!hinp->bi[i].nrd)
259	+	setfl(bflags, i);
260		/* pick a good prime step size */
261		for (i = 0; primes[i]<<5 >= nbeams(hinp); i++)
262		;
#	Line 219 | Line 266 | int    ifd, ofd;
266		/* add each input beam and neighbors */
267		for (bc = bci = nbeams(hinp); bc > 0; bc--,
268		bci += bci>myprime ? -myprime : nbeams(hinp)-myprime) {
269	<	if (beamdone(bci))
269	>	if (isset(bflags, bci))
270		continue;
271		bqueue[0] = bci;                /* initialize queue */
272		bqlen = 1;
273	<	bqtotal = bnrays(hinp, bci);
273	>	bqtotal = hinp->bi[bci].nrd;
274	>	setfl(bflags, bci);
275		/* run through growing queue */
276		for (bqc = 0; bqc < bqlen; bqc++) {
277	<	/* transfer the beam */
278	<	bp = hdgetbeam(hinp, bqueue[bqc]);
279	<	bcopy((char *)hdbray(bp),
280	<	(char *)hdnewrays(hout,bqueue[bqc],bp->nrm),
233	<	bp->nrm*sizeof(RAYVAL));
234	<	hdfreebeam(hinp, bqueue[bqc]);
235	<	/* check queue size */
236	<	if (bqtotal >= BKBSIZE*1024/sizeof(RAYVAL))
237	<	continue;
238	<	/* add neighbors to queue */
239	<	for (bnc = firstneigh(hinp,bqueue[bqc]); bnc > 0;
240	<	bnc = nextneigh()) {
241	<	if (beamdone(bnc))      /* see if valid */
277	>	/* add neighbors until full */
278	>	for (i = firstneigh(hinp,bqueue[bqc]); i > 0;
279	>	i = nextneigh()) {
280	>	if (isset(bflags, i))   /* done already? */
281		continue;
282	<	for (i = bqlen; i--; )
283	<	if (bqueue[i] == bnc) break;
284	<	if (i >= 0)
246	<	continue;
247	<	bqueue[bqlen++] = bnc;  /* add it */
248	<	bqtotal += bnrays(hinp, bnc);
282	>	bqueue[bqlen++] = i;    /* add it */
283	>	bqtotal += hinp->bi[i].nrd;
284	>	setfl(bflags, i);
285		if (bqtotal >= BKBSIZE*1024/sizeof(RAYVAL))
286		break;          /* queue full */
287		}
288	+	if (i > 0)
289	+	break;
290		}
291	+	beamdir = hinp->bi;             /* sort queue */
292	+	qsort((char *)bqueue, bqlen, sizeof(*bqueue), bpcmp);
293	+	/* transfer each beam */
294	+	for (i = 0; i < bqlen; i++) {
295	+	bp = hdgetbeam(hinp, bqueue[i]);
296	+	bcopy((char *)hdbray(bp),
297	+	(char *)hdnewrays(hout,bqueue[i],bp->nrm),
298	+	bp->nrm*sizeof(RAYVAL));
299	+	hdfreebeam(hinp, bqueue[i]);
300	+	}
301		hdfreebeam(hout, 0);            /* flush output block */
302	+	#ifdef DEBUG
303	+	hdsync(hout, 0);
304	+	#endif
305		}
306		/* we're done -- clean up */
307		free((char *)bqueue);
308	+	free((char *)bflags);
309		hddone(hinp);
310		hddone(hout);
259	–	#undef beamdone
311		}
312
313
#	Line 282 | Line 333 | register char  *s;
333		quit(code)                      /* exit the program gracefully */
334		int     code;
335		{
336	<	hdsync(NULL, 1);        /* write out any buffered data */
336	>	if (tempfile[0])
337	>	unlink(tempfile);
338		exit(code);
339		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)