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.15 by gregl, Mon Dec 29 15:17:45 1997 UTC vs.
Revision 3.18 by gregl, Thu Jan 1 16:40:38 1998 UTC

#	Line 22 | Line 22 | static char SCCSid[] = "$SunId$ SGI";
22		#define PCTFREE         20      /* maximum fraction to free (%) */
23		#endif
24		#ifndef MAXFRAG
25	<	#define MAXFRAG         131000  /* maximum fragments/file to track (0==inf) */
25	>	#define MAXFRAG         32767   /* maximum fragments/file to track (0==inf) */
26		#endif
27
28		#ifndef BSD
#	Line 30 | Line 30 | static char SCCSid[] = "$SunId$ SGI";
30		#define read    readbuf
31		#endif
32
33	<	#define FRAGBLK         64      /* number of fragments to allocate at a time */
33	>	#define FRAGBLK         256     /* number of fragments to allocate at a time */
34
35		unsigned        hdcachesize = CACHESIZE*1024*1024;      /* target cache size */
36		unsigned long   hdclock;        /* clock value */
37
38		HOLO    *hdlist[HDMAX+1];       /* holodeck pointers (NULL term.) */
39
40	<	static struct fragment {
40	>	static struct fraglist {
41		short   nlinks;         /* number of holodeck sections using us */
42		short   writerr;        /* write error encountered */
43		int     nfrags;         /* number of known fragments */
44		BEAMI   *fi;            /* fragments, descending file position */
45		long    flen;           /* last known file length */
46	<	} *hdfrag;              /* fragment lists, indexed by file descriptor */
46	>	} *hdfragl;             /* fragment lists, indexed by file descriptor */
47
48	<	static int      nhdfrags;       /* size of hdfrag array */
48	>	static int      nhdfragls;      /* size of hdfragl array */
49
50
51		hdattach(fd)            /* start tracking file fragments for some section */
52		register int    fd;
53		{
54	<	if (fd >= nhdfrags) {
55	<	if (nhdfrags)
56	<	hdfrag = (struct fragment *)realloc((char *)hdfrag,
57	<	(fd+1)*sizeof(struct fragment));
54	>	if (fd >= nhdfragls) {
55	>	if (nhdfragls)
56	>	hdfragl = (struct fraglist *)realloc((char *)hdfragl,
57	>	(fd+1)*sizeof(struct fraglist));
58		else
59	<	hdfrag = (struct fragment *)malloc(
60	<	(fd+1)*sizeof(struct fragment));
61	<	if (hdfrag == NULL)
59	>	hdfragl = (struct fraglist *)malloc(
60	>	(fd+1)*sizeof(struct fraglist));
61	>	if (hdfragl == NULL)
62		error(SYSTEM, "out of memory in hdattach");
63	<	bzero((char *)(hdfrag+nhdfrags),
64	<	(fd+1-nhdfrags)*sizeof(struct fragment));
65	<	nhdfrags = fd+1;
63	>	bzero((char *)(hdfragl+nhdfragls),
64	>	(fd+1-nhdfragls)*sizeof(struct fraglist));
65	>	nhdfragls = fd+1;
66		}
67	<	hdfrag[fd].nlinks++;
68	<	hdfrag[fd].flen = lseek(fd, 0L, 2);     /* get file length */
67	>	hdfragl[fd].nlinks++;
68	>	hdfragl[fd].flen = lseek(fd, 0L, 2);    /* get file length */
69		}
70
71
#	Line 75 | Line 75 | register int   fd;
75		hdrelease(fd)           /* stop tracking file fragments for some section */
76		register int    fd;
77		{
78	<	if (fd < 0 | fd >= nhdfrags || !hdfrag[fd].nlinks)
78	>	if (fd < 0 | fd >= nhdfragls || !hdfragl[fd].nlinks)
79		return;
80	<	if (!--hdfrag[fd].nlinks && hdfrag[fd].nfrags) {
81	<	free((char *)hdfrag[fd].fi);
82	<	hdfrag[fd].fi = NULL;
83	<	hdfrag[fd].nfrags = 0;
80	>	if (!--hdfragl[fd].nlinks && hdfragl[fd].nfrags) {
81	>	free((char *)hdfragl[fd].fi);
82	>	hdfragl[fd].fi = NULL;
83	>	hdfragl[fd].nfrags = 0;
84		}
85		}
86
#	Line 213 | Line 213 | int    all;                    /* include overhead (painful) */
213		}
214		}
215		if (all)
216	<	for (j = 0; j < nhdfrags; j++) {
217	<	total += sizeof(struct fragment);
218	<	if (hdfrag[j].nfrags)
216	>	for (j = 0; j < nhdfragls; j++) {
217	>	total += sizeof(struct fraglist);
218	>	if (hdfragl[j].nfrags)
219		total += FRAGBLK*sizeof(BEAMI) *
220	<	((hdfrag[j].nfrags-1)/FRAGBLK + 1) ;
220	>	((hdfragl[j].nfrags-1)/FRAGBLK + 1) ;
221		}
222		return(total);
223		}
#	Line 231 | Line 231 | int    fd;
231
232		if (fd < 0)
233		return(-1);
234	<	if (fd >= nhdfrags || !hdfrag[fd].nlinks) {
234	>	if (fd >= nhdfragls || !hdfragl[fd].nlinks) {
235		if ((fpos = lseek(fd, 0L, 1)) < 0)
236		return(-1);
237		flen = lseek(fd, 0L, 2);
238		lseek(fd, fpos, 0);
239		return(flen);
240		}
241	<	return(hdfrag[fd].flen);
241	>	return(hdfragl[fd].flen);
242		}
243
244
#	Line 348 | Line 348 | register int   i;
348
349
350		int
351	<	hdfilord(hb1, hb2)      /* order beams for optimal loading */
351	>	hdfilord(hb1, hb2)      /* order beams for quick loading */
352		register HDBEAMI        *hb1, *hb2;
353		{
354	<	register int    c;
355	<	/* sort by file descriptor first */
354	>	register long   c;
355	>	/* residents go first */
356	>	if (hb2->h->bl[hb2->b] != NULL)
357	>	return(hb1->h->bl[hb1->b] == NULL);
358	>	if (hb1->h->bl[hb1->b] != NULL)
359	>	return(-1);
360	>	/* otherwise sort by file descriptor */
361		if ((c = hb1->h->fd - hb2->h->fd))
362		return(c);
363		/* then by position in file */
364	<	return(hb1->h->bi[hb1->b].fo - hb2->h->bi[hb2->b].fo);
364	>	c = hb1->h->bi[hb1->b].fo - hb2->h->bi[hb2->b].fo;
365	>	return(c > 0 ? 1 : c < 0 ? -1 : 0);
366		}
367
368
#	Line 375 | Line 381 | int    (*bf)();                /* callback function (optional) */
381		error(CONSISTENCY, "bad beam in hdloadbeams");
382		/* sort list for optimal access */
383		qsort((char *)hb, n, sizeof(HDBEAMI), hdfilord);
384	<	bytesloaded = needbytes = 0;    /* figure out memory needs */
384	>	bytesloaded = 0;                /* run through loaded beams */
385	>	for ( ; n && (bp = hb->h->bl[hb->b]) != NULL; n--, hb++) {
386	>	bp->tick = hdclock;             /* preempt swap */
387	>	bytesloaded += bp->nrm;
388	>	if (bf != NULL)
389	>	(*bf)(bp, hb->h, hb->b);
390	>	}
391	>	bytesloaded *= sizeof(RAYVAL);
392		if ((origcachesize = hdcachesize) > 0) {
393	+	needbytes = 0;          /* figure out memory needs */
394		for (i = n; i--; )
395	<	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);
395	>	needbytes += hb[i].h->bi[hb[i].b].nrd;
396		needbytes *= sizeof(RAYVAL);
397		do {                            /* free enough memory */
398		memuse = hdmemuse(0);
399	<	bytes2free = needbytes - (signed)(hdcachesize-memuse);
400	<	if (bytes2free > (signed)(memuse - bytesloaded))
399	>	bytes2free = needbytes - (int)(hdcachesize-memuse);
400	>	if (bytes2free > (int)(memuse - bytesloaded))
401		bytes2free = memuse - bytesloaded;
402		} while (bytes2free > 0 &&
403		hdfreecache(100*bytes2free/memuse, NULL) < 0);
404	+	hdcachesize = 0;                /* load beams w/o swap */
405		}
396	–	hdcachesize = 0;                /* load the ordered beams w/o swap */
406		for (i = 0; i < n; i++)
407		if ((bp = hdgetbeam(hb[i].h, hb[i].b)) != NULL && bf != NULL)
408		(*bf)(bp, hb[i].h, hb[i].b);
#	Line 410 | Line 419 | register int   i;
419		long    nfo;
420		unsigned int    n;
421		/* check file status */
422	<	if (hdfrag[hp->fd].writerr)
422	>	if (hdfragl[hp->fd].writerr)
423		return(-1);
424		#ifdef DEBUG
425		if (i < 1 | i > nbeams(hp))
#	Line 420 | Line 429 | register int   i;
429		if (hp->bl[i] == NULL || (nrays = hp->bl[i]->nrm) == hp->bi[i].nrd)
430		return(0);
431		/* locate fragment */
432	<	if (hp->fd >= nhdfrags || !hdfrag[hp->fd].nlinks) /* untracked */
433	<	hp->bi[i].fo = lseek(hp->fd, 0L, 2);
432	>	if (hp->bi[i].fo + hp->bi[i].nrd*sizeof(RAYVAL) ==
433	>	hdfragl[hp->fd].flen)           /* EOF special case */
434	>	hdfragl[hp->fd].flen = (nfo=hp->bi[i].fo) + nrays*sizeof(RAYVAL);
435
426	–	else if (hp->bi[i].fo + hp->bi[i].nrd*sizeof(RAYVAL) ==
427	–	hdfrag[hp->fd].flen)            /* EOF special case */
428	–	hdfrag[hp->fd].flen = (nfo=hp->bi[i].fo) + nrays*sizeof(RAYVAL);
429	–
436		else {                                          /* general case */
437	<	register struct fragment        *f = &hdfrag[hp->fd];
437	>	register struct fraglist        *f = &hdfragl[hp->fd];
438		register int    j, k;
439	<	/* relinquish old fragment */
439	>	n = f->nfrags;          /* relinquish old fragment */
440		if (hp->bi[i].nrd) {
441		j = f->nfrags++;
442		#if MAXFRAG
#	Line 461 | Line 467 | register int   i;
467		f->fi[j].nrd*sizeof(RAYVAL)) {
468		f->fi[j].nrd += f->fi[j-1].nrd;
469		f->fi[j-1].nrd = 0;
470	+	n = j-1;
471		}
472		if (j+1 < f->nfrags && f->fi[j].fo == f->fi[j+1].fo +
473		f->fi[j+1].nrd*sizeof(RAYVAL)) {
474		f->fi[j+1].nrd += f->fi[j].nrd;
475		f->fi[j].nrd = 0;
476	+	if (j < n) n = j;
477		}
478		}
479		k = -1;                 /* find closest-sized fragment */
#	Line 480 | Line 488 | register int   i;
488		} else {                /* else use fragment */
489		nfo = f->fi[k].fo;
490		f->fi[k].fo += nrays*sizeof(RAYVAL);
491	<	f->fi[k].nrd -= nrays;
491	>	if (!(f->fi[k].nrd -= nrays) && k < n)
492	>	n = k;
493		}
494		/* delete empty remnants */
495	<	for (j = k = 0; k < f->nfrags; j++, k++) {
495	>	for (j = k = n; k < f->nfrags; j++, k++) {
496		while (f->fi[k].nrd == 0)
497		if (++k >= f->nfrags)
498		goto endloop;
#	Line 499 | Line 508 | register int   i;
508		error(SYSTEM, "cannot seek on holodeck file");
509		n = hp->bl[i]->nrm * sizeof(RAYVAL);
510		if (write(hp->fd, (char *)hdbray(hp->bl[i]), n) != n) {
511	<	hdfrag[hp->fd].writerr++;
512	<	hdsync(hp, 0);          /* sync directory */
511	>	hdfragl[hp->fd].writerr++;
512	>	hdsync(NULL, 0);        /* sync directories */
513		error(SYSTEM, "write error in hdsyncbeam");
514		}
515		}
#	Line 525 | Line 534 | register int   i;
534		nchanged += hdfreebeam(hdlist[i], 0);
535		return(nchanged);
536		}
537	<	if (hdfrag[hp->fd].writerr)     /* check for file error */
537	>	if (hdfragl[hp->fd].writerr)    /* check for file error */
538		return(0);
539		if (i == 0) {                   /* clear entire holodeck */
540		nchanged = 0;

Diff Legend

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