ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/holofile.c
Revision: 3.16
Committed: Wed Dec 31 11:35:39 1997 UTC (26 years, 3 months ago) by gregl
Content type: text/plain
Branch: MAIN
Changes since 3.15: +41 -38 lines
Log Message:
more minor improvements to hdsyncbeam()

File Contents

# Content
1 /* Copyright (c) 1997 Silicon Graphics, Inc. */
2
3 #ifndef lint
4 static char SCCSid[] = "$SunId$ SGI";
5 #endif
6
7 /*
8 * Routines for managing holodeck files
9 *
10 * 9/30/97 GWLarson
11 */
12
13 #include "holo.h"
14
15 #ifndef CACHESIZE
16 #define CACHESIZE 16 /* default cache size (Mbytes, 0==inf) */
17 #endif
18 #ifndef FREEBEAMS
19 #define FREEBEAMS 512 /* maximum beams to free at a time */
20 #endif
21 #ifndef PCTFREE
22 #define PCTFREE 20 /* maximum fraction to free (%) */
23 #endif
24 #ifndef MAXFRAG
25 #define MAXFRAG 32767 /* maximum fragments/file to track (0==inf) */
26 #endif
27
28 #ifndef BSD
29 #define write writebuf /* safe i/o routines */
30 #define read readbuf
31 #endif
32
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 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 } *hdfragl; /* fragment lists, indexed by file descriptor */
47
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 >= nhdfragls) {
55 if (nhdfragls)
56 hdfragl = (struct fraglist *)realloc((char *)hdfragl,
57 (fd+1)*sizeof(struct fraglist));
58 else
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 *)(hdfragl+nhdfragls),
64 (fd+1-nhdfragls)*sizeof(struct fraglist));
65 nhdfragls = fd+1;
66 }
67 hdfragl[fd].nlinks++;
68 hdfragl[fd].flen = lseek(fd, 0L, 2); /* get file length */
69 }
70
71
72 /* Do we need a routine to locate file fragments given known occupants? */
73
74
75 hdrelease(fd) /* stop tracking file fragments for some section */
76 register int fd;
77 {
78 if (fd < 0 | fd >= nhdfragls || !hdfragl[fd].nlinks)
79 return;
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
87
88 markdirty(hp) /* mark holodeck section directory dirty */
89 register HOLO *hp;
90 {
91 static BEAMI smudge = {0, -1};
92
93 if (hp->dirty) /* already marked? */
94 return;
95 hp->dirty = 1;
96 if (lseek(hp->fd, biglob(hp)->fo+(nbeams(hp)-1)*sizeof(BEAMI), 0) < 0
97 || write(hp->fd, (char *)&smudge,
98 sizeof(BEAMI)) != sizeof(BEAMI))
99 error(SYSTEM, "seek/write error in markdirty");
100 }
101
102
103 HOLO *
104 hdinit(fd, hproto) /* initialize a holodeck section in a file */
105 int fd; /* corresponding file descriptor */
106 HDGRID *hproto; /* holodeck section grid */
107 {
108 long fpos;
109 register HOLO *hp;
110 register int n;
111 /* prepare for system errors */
112 errno = 0;
113 if ((fpos = lseek(fd, 0L, 1)) < 0)
114 error(SYSTEM, "cannot determine holodeck file position");
115 if (hproto == NULL) { /* assume we're loading it */
116 HDGRID hpr;
117 /* load header */
118 if (read(fd, (char *)&hpr, sizeof(HDGRID)) != sizeof(HDGRID))
119 error(SYSTEM, "cannot load holodeck header");
120 /* allocate grid */
121 if ((hp = hdalloc(&hpr)) == NULL)
122 goto memerr;
123 /* load beam directory */
124 n = nbeams(hp)*sizeof(BEAMI);
125 if (read(fd, (char *)(hp->bi+1), n) != n)
126 error(SYSTEM, "failure loading holodeck directory");
127 /* check that it's clean */
128 if (hp->bi[nbeams(hp)].fo < 0)
129 error(USER, "dirty holodeck section");
130 } else { /* assume we're creating it */
131 if ((hp = hdalloc(hproto)) == NULL)
132 goto memerr;
133 /* write header and skeleton */
134 n = nbeams(hp)*sizeof(BEAMI);
135 if (write(fd, (char *)hproto, sizeof(HDGRID)) !=
136 sizeof(HDGRID) ||
137 write(fd, (char *)(hp->bi+1), n) != n)
138 error(SYSTEM, "cannot write header to holodeck file");
139 }
140 hp->fd = fd;
141 hp->dirty = 0;
142 biglob(hp)->fo = fpos + sizeof(HDGRID);
143 /* start tracking fragments */
144 hdattach(fd);
145 /* check rays on disk */
146 fpos = hdfilen(fd);
147 biglob(hp)->nrd = 0;
148 for (n = hproto == NULL ? nbeams(hp) : 0; n > 0; n--)
149 if (hp->bi[n].nrd)
150 if (hp->bi[n].fo + hp->bi[n].nrd > fpos)
151 hp->bi[n].nrd = 0; /* off end */
152 else
153 biglob(hp)->nrd += hp->bi[n].nrd;
154 /* add to holodeck list */
155 for (n = 0; n < HDMAX; n++)
156 if (hdlist[n] == NULL) {
157 hdlist[n] = hp;
158 break;
159 }
160 /* all done */
161 return(hp);
162 memerr:
163 error(SYSTEM, "cannot allocate holodeck grid");
164 }
165
166
167 int
168 hdsync(hp, all) /* update beams and directory on disk */
169 register HOLO *hp;
170 int all;
171 {
172 register int j, n;
173
174 if (hp == NULL) { /* do all holodecks */
175 n = 0;
176 for (j = 0; hdlist[j] != NULL; j++)
177 n += hdsync(hdlist[j], all);
178 return(n);
179 }
180 /* sync the beams */
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? */
185 return(0);
186 errno = 0;
187 if (lseek(hp->fd, biglob(hp)->fo, 0) < 0)
188 error(SYSTEM, "cannot seek on holodeck file");
189 n = nbeams(hp)*sizeof(BEAMI);
190 if (write(hp->fd, (char *)(hp->bi+1), n) != n)
191 error(SYSTEM, "cannot update holodeck section directory");
192 hp->dirty = 0;
193 return(1);
194 }
195
196
197 unsigned
198 hdmemuse(all) /* return memory usage (in bytes) */
199 int all; /* include overhead (painful) */
200 {
201 long total = 0;
202 register int i, j;
203
204 for (j = 0; hdlist[j] != NULL; j++) {
205 total += blglob(hdlist[j])->nrm * sizeof(RAYVAL);
206 if (all) {
207 total += sizeof(HOLO) + sizeof(BEAM *) +
208 nbeams(hdlist[j]) *
209 (sizeof(BEAM *)+sizeof(BEAMI));
210 for (i = nbeams(hdlist[j]); i > 0; i--)
211 if (hdlist[j]->bl[i] != NULL)
212 total += sizeof(BEAM);
213 }
214 }
215 if (all)
216 for (j = 0; j < nhdfragls; j++) {
217 total += sizeof(struct fraglist);
218 if (hdfragl[j].nfrags)
219 total += FRAGBLK*sizeof(BEAMI) *
220 ((hdfragl[j].nfrags-1)/FRAGBLK + 1) ;
221 }
222 return(total);
223 }
224
225
226 long
227 hdfilen(fd) /* return file length for fd */
228 int fd;
229 {
230 long fpos, flen;
231
232 if (fd < 0)
233 return(-1);
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(hdfragl[fd].flen);
242 }
243
244
245 long
246 hdfiluse(fd, all) /* compute file usage (in bytes) */
247 int fd; /* open file descriptor to check */
248 int all; /* include overhead and unflushed data */
249 {
250 long total = 0;
251 register int i, j;
252
253 for (j = 0; hdlist[j] != NULL; j++) {
254 if (hdlist[j]->fd != fd)
255 continue;
256 total += biglob(hdlist[j])->nrd * sizeof(RAYVAL);
257 if (all) {
258 for (i = nbeams(hdlist[j]); i > 0; i--)
259 if (hdlist[j]->bl[i] != NULL)
260 total += sizeof(RAYVAL) *
261 (hdlist[j]->bl[i]->nrm -
262 hdlist[j]->bi[i].nrd);
263 total += sizeof(HDGRID) +
264 nbeams(hdlist[j])*sizeof(BEAMI);
265 }
266 }
267 return(total); /* does not include fragments */
268 }
269
270
271 RAYVAL *
272 hdnewrays(hp, i, nr) /* allocate space for add'l rays and return pointer */
273 register HOLO *hp;
274 register int i;
275 int nr; /* number of new rays desired */
276 {
277 RAYVAL *p;
278 int n;
279
280 if (nr <= 0)
281 return(NULL);
282 if (i < 1 | i > nbeams(hp))
283 error(CONSISTENCY, "bad beam index given to hdnewrays");
284 if (hp->bl[i] != NULL)
285 hp->bl[i]->tick = hdclock; /* preempt swap */
286 if (hdcachesize > 0 && hdmemuse(0) >= hdcachesize)
287 hdfreecache(PCTFREE, NULL); /* free some space */
288 errno = 0;
289 if (hp->bl[i] == NULL) { /* allocate (and load) */
290 n = hp->bi[i].nrd + nr;
291 if ((hp->bl[i] = (BEAM *)malloc(hdbsiz(n))) == NULL)
292 goto memerr;
293 blglob(hp)->nrm += n;
294 if (n = hp->bl[i]->nrm = hp->bi[i].nrd) {
295 if (lseek(hp->fd, hp->bi[i].fo, 0) < 0)
296 error(SYSTEM, "seek error on holodeck file");
297 n *= sizeof(RAYVAL);
298 if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n)
299 error(SYSTEM,
300 "error reading beam from holodeck file");
301 }
302 } else { /* just grow in memory */
303 hp->bl[i] = (BEAM *)realloc( (char *)hp->bl[i],
304 hdbsiz(hp->bl[i]->nrm + nr) );
305 if (hp->bl[i] == NULL)
306 goto memerr;
307 blglob(hp)->nrm += nr;
308 }
309 p = hdbray(hp->bl[i]) + hp->bl[i]->nrm;
310 hp->bl[i]->nrm += nr; /* update in-core structure */
311 bzero((char *)p, nr*sizeof(RAYVAL));
312 hp->bl[i]->tick = hdclock; /* update LRU clock */
313 blglob(hp)->tick = hdclock++;
314 return(p); /* point to new rays */
315 memerr:
316 error(SYSTEM, "out of memory in hdnewrays");
317 }
318
319
320 BEAM *
321 hdgetbeam(hp, i) /* get beam (from file if necessary) */
322 register HOLO *hp;
323 register int i;
324 {
325 register int n;
326
327 if (i < 1 | i > nbeams(hp))
328 error(CONSISTENCY, "bad beam index given to hdgetbeam");
329 if (hp->bl[i] == NULL) { /* load from disk */
330 if (!(n = hp->bi[i].nrd))
331 return(NULL);
332 if (hdcachesize > 0 && hdmemuse(0) >= hdcachesize)
333 hdfreecache(PCTFREE, NULL); /* get free space */
334 errno = 0;
335 if ((hp->bl[i] = (BEAM *)malloc(hdbsiz(n))) == NULL)
336 error(SYSTEM, "cannot allocate memory for beam");
337 blglob(hp)->nrm += hp->bl[i]->nrm = n;
338 if (lseek(hp->fd, hp->bi[i].fo, 0) < 0)
339 error(SYSTEM, "seek error on holodeck file");
340 n *= sizeof(RAYVAL);
341 if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n)
342 error(SYSTEM, "error reading beam from holodeck file");
343 }
344 hp->bl[i]->tick = hdclock; /* update LRU clock */
345 blglob(hp)->tick = hdclock++;
346 return(hp->bl[i]);
347 }
348
349
350 int
351 hdfilord(hb1, hb2) /* order beams for optimal loading */
352 register HDBEAMI *hb1, *hb2;
353 {
354 register int c;
355 /* sort by file descriptor first */
356 if ((c = hb1->h->fd - hb2->h->fd))
357 return(c);
358 /* then by position in file */
359 return(hb1->h->bi[hb1->b].fo - hb2->h->bi[hb2->b].fo);
360 }
361
362
363 hdloadbeams(hb, n, bf) /* load a list of beams in optimal order */
364 register HDBEAMI *hb; /* list gets sorted by hdfilord() */
365 int n; /* list length */
366 int (*bf)(); /* callback function (optional) */
367 {
368 unsigned origcachesize, memuse;
369 register BEAM *bp;
370 int bytesloaded, needbytes, bytes2free;
371 register int i;
372 /* precheck consistency */
373 for (i = n; i--; )
374 if (hb[i].h == NULL || hb[i].b < 1 | hb[i].b > nbeams(hb[i].h))
375 error(CONSISTENCY, "bad beam in hdloadbeams");
376 /* sort list for optimal access */
377 qsort((char *)hb, n, sizeof(HDBEAMI), hdfilord);
378 bytesloaded = needbytes = 0; /* figure out memory needs */
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)
399 (*bf)(bp, hb[i].h, hb[i].b);
400 hdcachesize = origcachesize; /* resume dynamic swapping */
401 }
402
403
404 int
405 hdsyncbeam(hp, i) /* sync beam in memory with beam on disk */
406 register HOLO *hp;
407 register int i;
408 {
409 unsigned int nrays;
410 long nfo;
411 unsigned int n;
412 /* check file status */
413 if (hdfragl[hp->fd].writerr)
414 return(-1);
415 #ifdef DEBUG
416 if (i < 1 | i > nbeams(hp))
417 error(CONSISTENCY, "bad beam index in hdsyncbeam");
418 #endif
419 /* is current fragment OK? */
420 if (hp->bl[i] == NULL || (nrays = hp->bl[i]->nrm) == hp->bi[i].nrd)
421 return(0);
422 /* locate fragment */
423 if (hp->fd >= nhdfragls || !hdfragl[hp->fd].nlinks) /* untracked */
424 hp->bi[i].fo = lseek(hp->fd, 0L, 2);
425
426 else if (hp->bi[i].fo + hp->bi[i].nrd*sizeof(RAYVAL) ==
427 hdfragl[hp->fd].flen) /* EOF special case */
428 hdfragl[hp->fd].flen = (nfo=hp->bi[i].fo) + nrays*sizeof(RAYVAL);
429
430 else { /* general case */
431 register struct fraglist *f = &hdfragl[hp->fd];
432 register int j, k;
433 n = f->nfrags; /* relinquish old fragment */
434 if (hp->bi[i].nrd) {
435 j = f->nfrags++;
436 #if MAXFRAG
437 if (j >= MAXFRAG-1)
438 f->nfrags--;
439 #endif
440 if (j % FRAGBLK == 0) { /* more frag. space */
441 if (f->fi == NULL)
442 f->fi = (BEAMI *)malloc(
443 FRAGBLK*sizeof(BEAMI));
444 else
445 f->fi = (BEAMI *)realloc((char *)f->fi,
446 (j+FRAGBLK)*sizeof(BEAMI));
447 if (f->fi == NULL)
448 error(SYSTEM,
449 "out of memory in hdsyncbeam");
450 }
451 for ( ; ; j--) { /* insert in descending list */
452 if (!j || hp->bi[i].fo < f->fi[j-1].fo) {
453 f->fi[j].fo = hp->bi[i].fo;
454 f->fi[j].nrd = hp->bi[i].nrd;
455 break;
456 }
457 copystruct(f->fi+j, f->fi+(j-1));
458 }
459 /* coalesce adjacent fragments */
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 n = j-1;
465 }
466 if (j+1 < f->nfrags && f->fi[j].fo == f->fi[j+1].fo +
467 f->fi[j+1].nrd*sizeof(RAYVAL)) {
468 f->fi[j+1].nrd += f->fi[j].nrd;
469 f->fi[j].nrd = 0;
470 if (j < n) n = j;
471 }
472 }
473 k = -1; /* find closest-sized fragment */
474 for (j = (nrays ? f->nfrags : 0); j-- > 0; )
475 if (f->fi[j].nrd >= nrays &&
476 (k < 0 || f->fi[j].nrd < f->fi[k].nrd))
477 if (f->fi[k=j].nrd == nrays)
478 break;
479 if (k < 0) { /* no fragment -- extend file */
480 nfo = f->flen;
481 f->flen += nrays*sizeof(RAYVAL);
482 } else { /* else use fragment */
483 nfo = f->fi[k].fo;
484 f->fi[k].fo += nrays*sizeof(RAYVAL);
485 if (!(f->fi[k].nrd -= nrays) && k < n)
486 n = k;
487 }
488 /* delete empty remnants */
489 for (j = k = n; k < f->nfrags; j++, k++) {
490 while (f->fi[k].nrd == 0)
491 if (++k >= f->nfrags)
492 goto endloop;
493 if (k > j)
494 copystruct(f->fi+j, f->fi+k);
495 }
496 endloop:
497 f->nfrags = j;
498 }
499 if (nrays) { /* write the new fragment */
500 errno = 0;
501 if (lseek(hp->fd, nfo, 0) < 0)
502 error(SYSTEM, "cannot seek on holodeck file");
503 n = hp->bl[i]->nrm * sizeof(RAYVAL);
504 if (write(hp->fd, (char *)hdbray(hp->bl[i]), n) != n) {
505 hdfragl[hp->fd].writerr++;
506 hdsync(hp, 0); /* sync directory */
507 error(SYSTEM, "write error in hdsyncbeam");
508 }
509 }
510 biglob(hp)->nrd += nrays - hp->bi[i].nrd;
511 hp->bi[i].nrd = nrays;
512 hp->bi[i].fo = nfo;
513 markdirty(hp); /* section directory now out of date */
514 return(1);
515 }
516
517
518 int
519 hdfreebeam(hp, i) /* free beam, writing if dirty */
520 register HOLO *hp;
521 register int i;
522 {
523 int nchanged;
524
525 if (hp == NULL) { /* clear all holodecks */
526 nchanged = 0;
527 for (i = 0; hdlist[i] != NULL; i++)
528 nchanged += hdfreebeam(hdlist[i], 0);
529 return(nchanged);
530 }
531 if (hdfragl[hp->fd].writerr) /* check for file error */
532 return(0);
533 if (i == 0) { /* clear entire holodeck */
534 nchanged = 0;
535 for (i = nbeams(hp); i > 0; i--)
536 if (hp->bl[i] != NULL)
537 nchanged += hdfreebeam(hp, i);
538 return(nchanged);
539 }
540 #ifdef DEBUG
541 if (i < 1 | i > nbeams(hp))
542 error(CONSISTENCY, "bad beam index to hdfreebeam");
543 #endif
544 if (hp->bl[i] == NULL)
545 return(0);
546 /* check for additions */
547 nchanged = hp->bl[i]->nrm - hp->bi[i].nrd;
548 if (nchanged)
549 hdsyncbeam(hp, i); /* write new fragment */
550 blglob(hp)->nrm -= hp->bl[i]->nrm;
551 free((char *)hp->bl[i]); /* free memory */
552 hp->bl[i] = NULL;
553 return(nchanged);
554 }
555
556
557 int
558 hdkillbeam(hp, i) /* delete beam from holodeck */
559 register HOLO *hp;
560 register int i;
561 {
562 static BEAM emptybeam;
563 int nchanged;
564
565 if (hp == NULL) { /* clobber all holodecks */
566 nchanged = 0;
567 for (i = 0; hdlist[i] != NULL; i++)
568 nchanged += hdkillbeam(hdlist[i], 0);
569 return(nchanged);
570 }
571 if (i == 0) { /* clobber entire holodeck */
572 nchanged = 0;
573 for (i = nbeams(hp); i > 0; i--)
574 if (hp->bi[i].nrd > 0 || hp->bl[i] != NULL)
575 nchanged += hdkillbeam(hp, i);
576 #ifdef DEBUG
577 if (biglob(hp)->nrd != 0 | blglob(hp)->nrm != 0)
578 error(CONSISTENCY, "bad beam count in hdkillbeam");
579 #endif
580 return(nchanged);
581 }
582 #ifdef DEBUG
583 if (i < 1 | i > nbeams(hp))
584 error(CONSISTENCY, "bad beam index to hdkillbeam");
585 #endif
586 if (hp->bl[i] != NULL) { /* free memory */
587 blglob(hp)->nrm -= nchanged = hp->bl[i]->nrm;
588 free((char *)hp->bl[i]);
589 } else
590 nchanged = hp->bi[i].nrd;
591 if (hp->bi[i].nrd) { /* free file fragment */
592 hp->bl[i] = &emptybeam;
593 hdsyncbeam(hp, i);
594 }
595 hp->bl[i] = NULL;
596 return(nchanged);
597 }
598
599
600 int
601 hdlrulist(hb, nents, n, hp) /* add beams from holodeck to LRU list */
602 register HDBEAMI *hb; /* beam list */
603 int nents; /* current list length */
604 int n; /* maximum list length */
605 register HOLO *hp; /* section we're adding from */
606 {
607 register int i, j;
608 /* insert each beam from hp */
609 for (i = nbeams(hp); i > 0; i--) {
610 if (hp->bl[i] == NULL) /* check if loaded */
611 continue;
612 #if 0
613 if (hp->bl[i]->tick == hdclock) /* preempt swap? */
614 continue;
615 #endif
616 if ((j = ++nents) >= n) /* grow list if we can */
617 nents--;
618 for ( ; ; ) { /* bubble into place */
619 if (!--j || hp->bl[i]->tick >=
620 hb[j-1].h->bl[hb[j-1].b]->tick) {
621 hb[j].h = hp;
622 hb[j].b = i;
623 break;
624 }
625 copystruct(hb+j, hb+(j-1));
626 }
627 }
628 return(nents); /* return new list length */
629 }
630
631
632 int
633 hdfreecache(pct, honly) /* free up cache space, writing changes */
634 int pct; /* maximum percentage to free */
635 register HOLO *honly; /* NULL means check all */
636 {
637 HDBEAMI hb[FREEBEAMS];
638 int freetarget;
639 int n;
640 register int i;
641 /* compute free target */
642 freetarget = (honly != NULL) ? blglob(honly)->nrm :
643 hdmemuse(0)/sizeof(RAYVAL) ;
644 freetarget = freetarget*pct/100;
645 if (freetarget <= 0)
646 return(0);
647 /* find least recently used */
648 n = 0;
649 if (honly != NULL)
650 n = hdlrulist(hb, n, FREEBEAMS, honly);
651 else
652 for (i = 0; hdlist[i] != NULL; i++)
653 n = hdlrulist(hb, n, FREEBEAMS, hdlist[i]);
654 /* free LRU beams */
655 for (i = 0; i < n; i++) {
656 hdfreebeam(hb[i].h, hb[i].b);
657 if ((freetarget -= hb[i].h->bi[hb[i].b].nrd) <= 0)
658 break;
659 }
660 hdsync(honly, 0); /* synchronize directories as necessary */
661 return(-freetarget); /* return how far past goal we went */
662 }
663
664
665 hddone(hp) /* clean up holodeck section and free */
666 register HOLO *hp; /* NULL means clean up all */
667 {
668 register int i;
669
670 if (hp == NULL) { /* NULL means clean up everything */
671 while (hdlist[0] != NULL)
672 hddone(hdlist[0]);
673 return;
674 }
675 /* flush all data and free memory */
676 hdflush(hp);
677 /* release fragment resources */
678 hdrelease(hp->fd);
679 /* remove hp from active list */
680 for (i = 0; hdlist[i] != NULL; i++)
681 if (hdlist[i] == hp) {
682 while ((hdlist[i] = hdlist[i+1]) != NULL)
683 i++;
684 break;
685 }
686 free((char *)hp->bl); /* free beam list */
687 free((char *)hp); /* free holodeck struct */
688 }