ViewVC Help

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

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

Comparing ray/src/hd/holofile.c (file contents):
Revision 3.14 by gregl, Thu Dec 18 15:12:23 1997 UTC vs.
Revision 3.15 by gregl, Mon Dec 29 15:17:45 1997 UTC

#	Line 21 | Line 21 | static char SCCSid[] = "$SunId$ SGI";
21		#ifndef PCTFREE
22		#define PCTFREE         20      /* maximum fraction to free (%) */
23		#endif
24	+	#ifndef MAXFRAG
25	+	#define MAXFRAG         131000  /* maximum fragments/file to track (0==inf) */
26	+	#endif
27
25	–	/* define MAXFRAG if you want to limit fragment tracking memory */
26	–
28		#ifndef BSD
29		#define write   writebuf        /* safe i/o routines */
30		#define read    readbuf
#	Line 177 | Line 178 | int    all;
178		return(n);
179		}
180		/* sync the beams */
181	<	for (j = all ? nbeams(hp) : 0; j > 0; j--)
181	>	for (j = (all ? nbeams(hp) : 0); j > 0; j--)
182		if (hp->bl[j] != NULL)
183		hdsyncbeam(hp, j);
184		if (!hp->dirty)                 /* directory clean? */
#	Line 374 | Line 375 | int    (*bf)();                /* callback function (optional) */
375		error(CONSISTENCY, "bad beam in hdloadbeams");
376		/* sort list for optimal access */
377		qsort((char *)hb, n, sizeof(HDBEAMI), hdfilord);
377	–	if ((origcachesize = hdcachesize) == 0)
378	–	goto loadbeams;
378		bytesloaded = needbytes = 0;    /* figure out memory needs */
379	<	for (i = 0; i < n; i++)
380	<	if ((bp = hb[i].h->bl[hb[i].b]) != NULL) {
381	<	bp->tick = hdclock;             /* preempt swap */
382	<	bytesloaded += bp->nrm;
383	<	} else                                  /* prepare to load */
384	<	needbytes += hb[i].h->bi[hb[i].b].nrd;
385	<	bytesloaded *= sizeof(RAYVAL);
386	<	needbytes *= sizeof(RAYVAL);
387	<	do {                            /* free enough memory */
388	<	memuse = hdmemuse(0);
389	<	bytes2free = needbytes - (signed)(hdcachesize-memuse);
390	<	if (bytes2free > (signed)(memuse - bytesloaded))
391	<	bytes2free = memuse - bytesloaded;
392	<	} while (bytes2free > 0 &&
393	<	hdfreecache(100*bytes2free/memuse, NULL) < 0);
394	<	loadbeams:
379	>	if ((origcachesize = hdcachesize) > 0) {
380	>	for (i = n; i--; )
381	>	if ((bp = hb[i].h->bl[hb[i].b]) != NULL) {
382	>	bp->tick = hdclock;     /* preempt swap */
383	>	bytesloaded += bp->nrm;
384	>	} else                          /* prepare to load */
385	>	needbytes += hb[i].h->bi[hb[i].b].nrd;
386	>	bytesloaded *= sizeof(RAYVAL);
387	>	needbytes *= sizeof(RAYVAL);
388	>	do {                            /* free enough memory */
389	>	memuse = hdmemuse(0);
390	>	bytes2free = needbytes - (signed)(hdcachesize-memuse);
391	>	if (bytes2free > (signed)(memuse - bytesloaded))
392	>	bytes2free = memuse - bytesloaded;
393	>	} while (bytes2free > 0 &&
394	>	hdfreecache(100*bytes2free/memuse, NULL) < 0);
395	>	}
396		hdcachesize = 0;                /* load the ordered beams w/o swap */
397		for (i = 0; i < n; i++)
398		if ((bp = hdgetbeam(hb[i].h, hb[i].b)) != NULL && bf != NULL)
#	Line 433 | Line 433 | register int   i;
433		/* relinquish old fragment */
434		if (hp->bi[i].nrd) {
435		j = f->nfrags++;
436	<	#ifdef MAXFRAG
436	>	#if MAXFRAG
437		if (j >= MAXFRAG-1)
438		f->nfrags--;
439		#endif
#	Line 457 | Line 457 | register int   i;
457		copystruct(f->fi+j, f->fi+(j-1));
458		}
459		/* coalesce adjacent fragments */
460	<	for (j = k = 0; k < f->nfrags; j++, k++) {
461	<	if (k > j)
462	<	copystruct(f->fi+j, f->fi+k);
463	<	while (k+1 < f->nfrags && f->fi[k+1].fo +
464	<	f->fi[k+1].nrd*sizeof(RAYVAL)
465	<	== f->fi[j].fo) {
466	<	f->fi[j].fo -=
467	<	f->fi[++k].nrd*sizeof(RAYVAL);
468	<	f->fi[j].nrd += f->fi[k].nrd;
469	<	}
460	>	if (j && f->fi[j-1].fo == f->fi[j].fo +
461	>	f->fi[j].nrd*sizeof(RAYVAL)) {
462	>	f->fi[j].nrd += f->fi[j-1].nrd;
463	>	f->fi[j-1].nrd = 0;
464		}
465	<	f->nfrags = j;
465	>	if (j+1 < f->nfrags && f->fi[j].fo == f->fi[j+1].fo +
466	>	f->fi[j+1].nrd*sizeof(RAYVAL)) {
467	>	f->fi[j+1].nrd += f->fi[j].nrd;
468	>	f->fi[j].nrd = 0;
469	>	}
470		}
471		k = -1;                 /* find closest-sized fragment */
472	<	for (j = nrays ? f->nfrags : 0; j-- > 0; )
472	>	for (j = (nrays ? f->nfrags : 0); j-- > 0; )
473		if (f->fi[j].nrd >= nrays &&
474		(k < 0 || f->fi[j].nrd < f->fi[k].nrd))
475		if (f->fi[k=j].nrd == nrays)
#	Line 481 | Line 479 | register int   i;
479		f->flen += nrays*sizeof(RAYVAL);
480		} else {                /* else use fragment */
481		nfo = f->fi[k].fo;
482	<	if (f->fi[k].nrd == nrays) {    /* delete fragment */
483	<	f->nfrags--;
486	<	for (j = k; j < f->nfrags; j++)
487	<	copystruct(f->fi+j, f->fi+(j+1));
488	<	} else {                        /* else shrink it */
489	<	f->fi[k].fo += nrays*sizeof(RAYVAL);
490	<	f->fi[k].nrd -= nrays;
491	<	}
482	>	f->fi[k].fo += nrays*sizeof(RAYVAL);
483	>	f->fi[k].nrd -= nrays;
484		}
485	+	/* delete empty remnants */
486	+	for (j = k = 0; k < f->nfrags; j++, k++) {
487	+	while (f->fi[k].nrd == 0)
488	+	if (++k >= f->nfrags)
489	+	goto endloop;
490	+	if (k > j)
491	+	copystruct(f->fi+j, f->fi+k);
492	+	}
493	+	endloop:
494	+	f->nfrags = j;
495		}
496		if (nrays) {            /* write the new fragment */
497		errno = 0;

Diff Legend

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