ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/holofile.c
Revision: 3.10
Committed: Thu Dec 11 11:29:35 1997 UTC (26 years, 3 months ago) by gregl
Content type: text/plain
Branch: MAIN
Changes since 3.9: +45 -3 lines
Log Message:
added function to delete beams and clobber holodecks

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
25 /* define MAXFRAG if you want to limit fragment tracking memory */
26
27 #ifndef BSD
28 #define write writebuf /* safe i/o routines */
29 #define read readbuf
30 #endif
31
32 #define FRAGBLK 64 /* number of fragments to allocate at a time */
33
34 int hdcachesize = CACHESIZE*1024*1024; /* target cache size (bytes) */
35 unsigned long hdclock; /* clock value */
36
37 HOLO *hdlist[HDMAX+1]; /* holodeck pointers (NULL term.) */
38
39 static struct fragment {
40 short nlinks; /* number of holodeck sections using us */
41 short nfrags; /* number of known fragments */
42 BEAMI *fi; /* fragments, descending file position */
43 long flen; /* last known file length */
44 } *hdfrag; /* fragment lists, indexed by file descriptor */
45
46 static int nhdfrags; /* size of hdfrag array */
47
48
49 hdattach(fd) /* start tracking file fragments for some section */
50 register int fd;
51 {
52 if (fd >= nhdfrags) {
53 if (nhdfrags)
54 hdfrag = (struct fragment *)realloc((char *)hdfrag,
55 (fd+1)*sizeof(struct fragment));
56 else
57 hdfrag = (struct fragment *)malloc(
58 (fd+1)*sizeof(struct fragment));
59 if (hdfrag == NULL)
60 error(SYSTEM, "out of memory in hdattach");
61 bzero((char *)(hdfrag+nhdfrags),
62 (fd+1-nhdfrags)*sizeof(struct fragment));
63 nhdfrags = fd+1;
64 }
65 hdfrag[fd].nlinks++;
66 hdfrag[fd].flen = lseek(fd, 0L, 2); /* get file length */
67 }
68
69
70 /* Do we need a routine to locate file fragments given known occupants? */
71
72
73 hdrelease(fd) /* stop tracking file fragments for some section */
74 register int fd;
75 {
76 if (fd < 0 | fd >= nhdfrags || !hdfrag[fd].nlinks)
77 return;
78 if (!--hdfrag[fd].nlinks && hdfrag[fd].nfrags) {
79 free((char *)hdfrag[fd].fi);
80 hdfrag[fd].fi = NULL;
81 hdfrag[fd].nfrags = 0;
82 }
83 }
84
85
86 markdirty(hp) /* mark holodeck section directory dirty */
87 register HOLO *hp;
88 {
89 static BEAMI smudge = {0, -1};
90
91 if (hp->dirty) /* already marked? */
92 return;
93 hp->dirty = 1;
94 if (lseek(hp->fd, biglob(hp)->fo+(nbeams(hp)-1)*sizeof(BEAMI), 0) < 0
95 || write(hp->fd, (char *)&smudge,
96 sizeof(BEAMI)) != sizeof(BEAMI))
97 error(SYSTEM, "seek/write error in markdirty");
98 }
99
100
101 HOLO *
102 hdinit(fd, hproto) /* initialize a holodeck section in a file */
103 int fd; /* corresponding file descriptor */
104 HDGRID *hproto; /* holodeck section grid */
105 {
106 long fpos;
107 register HOLO *hp;
108 register int n;
109 /* prepare for system errors */
110 errno = 0;
111 if ((fpos = lseek(fd, 0L, 1)) < 0)
112 error(SYSTEM, "cannot determine holodeck file position");
113 if (hproto == NULL) { /* assume we're loading it */
114 HDGRID hpr;
115 /* load header */
116 if (read(fd, (char *)&hpr, sizeof(HDGRID)) != sizeof(HDGRID))
117 error(SYSTEM, "cannot load holodeck header");
118 /* allocate grid */
119 if ((hp = hdalloc(&hpr)) == NULL)
120 goto memerr;
121 /* load beam directory */
122 n = nbeams(hp)*sizeof(BEAMI);
123 if (read(fd, (char *)(hp->bi+1), n) != n)
124 error(SYSTEM, "failure loading holodeck directory");
125 /* check that it's clean */
126 if (hp->bi[nbeams(hp)].fo < 0)
127 error(USER, "dirty holodeck section");
128 } else { /* assume we're creating it */
129 if ((hp = hdalloc(hproto)) == NULL)
130 goto memerr;
131 /* write header and skeleton */
132 n = nbeams(hp)*sizeof(BEAMI);
133 if (write(fd, (char *)hproto, sizeof(HDGRID)) !=
134 sizeof(HDGRID) ||
135 write(fd, (char *)(hp->bi+1), n) != n)
136 error(SYSTEM, "cannot write header to holodeck file");
137 }
138 hp->fd = fd;
139 hp->dirty = 0;
140 biglob(hp)->fo = fpos + sizeof(HDGRID);
141 biglob(hp)->nrd = 0; /* count rays on disk */
142 for (n = nbeams(hp); n > 0; n--)
143 biglob(hp)->nrd += hp->bi[n].nrd;
144 /* add to holodeck list */
145 for (n = 0; n < HDMAX; n++)
146 if (hdlist[n] == NULL) {
147 hdlist[n] = hp;
148 break;
149 }
150 /* start tracking fragments (last) */
151 hdattach(fd);
152 /* all done */
153 return(hp);
154 memerr:
155 error(SYSTEM, "cannot allocate holodeck grid");
156 }
157
158
159 int
160 hdsync(hp) /* update directory on disk if necessary */
161 register HOLO *hp;
162 {
163 register int j, n;
164
165 if (hp == NULL) { /* do all */
166 n = 0;
167 for (j = 0; hdlist[j] != NULL; j++)
168 n += hdsync(hdlist[j]);
169 return(n);
170 }
171 if (!hp->dirty) /* check first */
172 return(0);
173 errno = 0;
174 if (lseek(hp->fd, biglob(hp)->fo, 0) < 0)
175 error(SYSTEM, "cannot seek on holodeck file");
176 n = nbeams(hp)*sizeof(BEAMI);
177 if (write(hp->fd, (char *)(hp->bi+1), n) != n)
178 error(SYSTEM, "cannot update holodeck section directory");
179 hp->dirty = 0;
180 return(1);
181 }
182
183
184 long
185 hdmemuse(all) /* return memory usage (in bytes) */
186 int all; /* include overhead (painful) */
187 {
188 long total = 0;
189 register int i, j;
190
191 for (j = 0; hdlist[j] != NULL; j++) {
192 total += blglob(hdlist[j])->nrm * sizeof(RAYVAL);
193 if (all) {
194 total += sizeof(HOLO) + sizeof(BEAM *) +
195 nbeams(hdlist[j]) *
196 (sizeof(BEAM *)+sizeof(BEAMI));
197 for (i = nbeams(hdlist[j]); i > 0; i--)
198 if (hdlist[j]->bl[i] != NULL)
199 total += sizeof(BEAM);
200 }
201 }
202 if (all)
203 for (j = 0; j < nhdfrags; j++) {
204 total += sizeof(struct fragment);
205 if (hdfrag[j].nfrags)
206 total += FRAGBLK*sizeof(BEAMI) *
207 ((hdfrag[j].nfrags-1)/FRAGBLK + 1) ;
208 }
209 return(total);
210 }
211
212
213 long
214 hdfilen(fd) /* return file length for fd */
215 int fd;
216 {
217 long fpos, flen;
218
219 if (fd < 0)
220 return(-1);
221 if (fd >= nhdfrags || !hdfrag[fd].nlinks) {
222 if ((fpos = lseek(fd, 0L, 1)) < 0)
223 return(-1);
224 flen = lseek(fd, 0L, 2);
225 lseek(fd, fpos, 0);
226 return(flen);
227 }
228 return(hdfrag[fd].flen);
229 }
230
231
232 long
233 hdfiluse(fd, all) /* compute file usage (in bytes) */
234 int fd; /* open file descriptor to check */
235 int all; /* include overhead and unflushed data */
236 {
237 long total = 0;
238 register int i, j;
239
240 for (j = 0; hdlist[j] != NULL; j++) {
241 if (hdlist[j]->fd != fd)
242 continue;
243 total += biglob(hdlist[j])->nrd * sizeof(RAYVAL);
244 if (all) {
245 for (i = nbeams(hdlist[j]); i > 0; i--)
246 if (hdlist[j]->bl[i] != NULL)
247 total += sizeof(RAYVAL) *
248 (hdlist[j]->bl[i]->nrm -
249 hdlist[j]->bi[i].nrd);
250 total += sizeof(HDGRID) +
251 nbeams(hdlist[j])*sizeof(BEAMI);
252 }
253 }
254 return(total); /* does not include fragments */
255 }
256
257
258 RAYVAL *
259 hdnewrays(hp, i, nr) /* allocate space for add'l rays and return pointer */
260 register HOLO *hp;
261 register int i;
262 int nr; /* number of new rays desired */
263 {
264 RAYVAL *p;
265 int n;
266
267 if (nr <= 0)
268 return(NULL);
269 if (i < 1 | i > nbeams(hp))
270 error(CONSISTENCY, "bad beam index given to hdnewrays");
271 if (hp->bl[i] != NULL)
272 hp->bl[i]->tick = hdclock; /* preempt swap */
273 if (hdcachesize > 0 && hdmemuse(0) >= hdcachesize)
274 hdfreecache(PCTFREE, NULL); /* free some space */
275 errno = 0;
276 if (hp->bl[i] == NULL) { /* allocate (and load) */
277 n = hp->bi[i].nrd + nr;
278 if ((hp->bl[i] = (BEAM *)malloc(hdbsiz(n))) == NULL)
279 goto memerr;
280 blglob(hp)->nrm += n;
281 if (n = hp->bl[i]->nrm = hp->bi[i].nrd) {
282 if (lseek(hp->fd, hp->bi[i].fo, 0) < 0)
283 error(SYSTEM, "seek error on holodeck file");
284 n *= sizeof(RAYVAL);
285 if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n)
286 error(SYSTEM,
287 "error reading beam from holodeck file");
288 }
289 } else { /* just grow in memory */
290 hp->bl[i] = (BEAM *)realloc( (char *)hp->bl[i],
291 hdbsiz(hp->bl[i]->nrm + nr) );
292 if (hp->bl[i] == NULL)
293 goto memerr;
294 blglob(hp)->nrm += nr;
295 }
296 p = hdbray(hp->bl[i]) + hp->bl[i]->nrm;
297 hp->bl[i]->nrm += nr; /* update in-core structure */
298 bzero((char *)p, nr*sizeof(RAYVAL));
299 hp->bl[i]->tick = ++hdclock; /* update LRU clock */
300 blglob(hp)->tick = hdclock;
301 return(p); /* point to new rays */
302 memerr:
303 error(SYSTEM, "out of memory in hdnewrays");
304 }
305
306
307 BEAM *
308 hdgetbeam(hp, i) /* get beam (from file if necessary) */
309 register HOLO *hp;
310 register int i;
311 {
312 register int n;
313
314 if (i < 1 | i > nbeams(hp))
315 error(CONSISTENCY, "bad beam index given to hdgetbeam");
316 if (hp->bl[i] == NULL) { /* load from disk */
317 if (!(n = hp->bi[i].nrd))
318 return(NULL);
319 if (hdcachesize > 0 && hdmemuse(0) >= hdcachesize)
320 hdfreecache(PCTFREE, NULL); /* get free space */
321 errno = 0;
322 if ((hp->bl[i] = (BEAM *)malloc(hdbsiz(n))) == NULL)
323 error(SYSTEM, "cannot allocate memory for beam");
324 blglob(hp)->nrm += hp->bl[i]->nrm = n;
325 if (lseek(hp->fd, hp->bi[i].fo, 0) < 0)
326 error(SYSTEM, "seek error on holodeck file");
327 n *= sizeof(RAYVAL);
328 if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n)
329 error(SYSTEM, "error reading beam from holodeck file");
330 }
331 hp->bl[i]->tick = ++hdclock; /* update LRU clock */
332 blglob(hp)->tick = hdclock;
333 return(hp->bl[i]);
334 }
335
336
337 int
338 hdgetbi(hp, i) /* allocate a file fragment */
339 register HOLO *hp;
340 register int i;
341 {
342 int nrays = hp->bl[i]->nrm;
343
344 if (hp->bi[i].nrd == nrays) /* current one will do? */
345 return(0);
346
347 if (hp->fd >= nhdfrags || !hdfrag[hp->fd].nlinks) /* untracked */
348 hp->bi[i].fo = lseek(hp->fd, 0L, 2);
349
350 else if (hp->bi[i].fo + hp->bi[i].nrd*sizeof(RAYVAL) ==
351 hdfrag[hp->fd].flen) /* EOF special case */
352 hdfrag[hp->fd].flen = hp->bi[i].fo + nrays*sizeof(RAYVAL);
353
354 else { /* general case */
355 register struct fragment *f = &hdfrag[hp->fd];
356 register int j, k;
357 /* relinquish old fragment */
358 if (hp->bi[i].nrd) {
359 j = f->nfrags++;
360 #ifdef MAXFRAG
361 if (j >= MAXFRAG-1)
362 f->nfrags--;
363 #endif
364 if (j % FRAGBLK == 0) { /* more frag. space */
365 if (f->fi == NULL)
366 f->fi = (BEAMI *)malloc(
367 FRAGBLK*sizeof(BEAMI));
368 else
369 f->fi = (BEAMI *)realloc((char *)f->fi,
370 (j+FRAGBLK)*sizeof(BEAMI));
371 if (f->fi == NULL)
372 error(SYSTEM,
373 "out of memory in hdgetbi");
374 }
375 for ( ; ; j--) { /* insert in descending list */
376 if (!j || hp->bi[i].fo < f->fi[j-1].fo) {
377 f->fi[j].fo = hp->bi[i].fo;
378 f->fi[j].nrd = hp->bi[i].nrd;
379 break;
380 }
381 copystruct(f->fi+j, f->fi+j-1);
382 }
383 /* coalesce adjacent fragments */
384 for (j = k = 0; k < f->nfrags; j++, k++) {
385 if (k > j)
386 copystruct(f->fi+j, f->fi+k);
387 while (k+1 < f->nfrags && f->fi[k+1].fo +
388 f->fi[k+1].nrd*sizeof(RAYVAL)
389 == f->fi[j].fo) {
390 f->fi[j].fo -=
391 f->fi[++k].nrd*sizeof(RAYVAL);
392 f->fi[j].nrd += f->fi[k].nrd;
393 }
394 }
395 f->nfrags = j;
396 }
397 k = -1; /* find closest-sized fragment */
398 for (j = f->nfrags; j-- > 0; )
399 if (f->fi[j].nrd >= nrays &&
400 (k < 0 || f->fi[j].nrd < f->fi[k].nrd))
401 if (f->fi[k=j].nrd == nrays)
402 break;
403 if (k < 0) { /* no fragment -- extend file */
404 hp->bi[i].fo = f->flen;
405 f->flen += nrays*sizeof(RAYVAL);
406 } else { /* else use fragment */
407 hp->bi[i].fo = f->fi[k].fo;
408 if (f->fi[k].nrd == nrays) { /* delete fragment */
409 f->nfrags--;
410 for (j = k; j < f->nfrags; j++)
411 copystruct(f->fi+j, f->fi+j+1);
412 } else { /* else shrink it */
413 f->fi[k].fo += nrays*sizeof(RAYVAL);
414 f->fi[k].nrd -= nrays;
415 }
416 }
417 }
418 biglob(hp)->nrd += nrays - hp->bi[i].nrd;
419 hp->bi[i].nrd = nrays;
420 markdirty(hp); /* section directory now out of date */
421 return(1);
422 }
423
424
425 int
426 hdfreebeam(hp, i) /* free beam, writing if dirty */
427 register HOLO *hp;
428 register int i;
429 {
430 int nchanged, n;
431
432 if (hp == NULL) { /* clear all holodecks */
433 nchanged = 0;
434 for (i = 0; hdlist[i] != NULL; i++)
435 nchanged += hdfreebeam(hdlist[i], 0);
436 return(nchanged);
437 }
438 if (hp->fd < 0) /* check for recursive error */
439 return(-1);
440 if (i == 0) { /* clear entire holodeck */
441 nchanged = 0;
442 for (i = nbeams(hp); i > 0; i--)
443 if (hp->bl[i] != NULL)
444 nchanged += hdfreebeam(hp, i);
445 return(nchanged);
446 }
447 if (i < 1 | i > nbeams(hp))
448 error(CONSISTENCY, "bad beam index to hdfreebeam");
449 if (hp->bl[i] == NULL)
450 return(0);
451 /* check for additions */
452 nchanged = hp->bl[i]->nrm - hp->bi[i].nrd;
453 if (nchanged) {
454 hdgetbi(hp, i); /* allocate a file position */
455 errno = 0;
456 if (lseek(hp->fd, hp->bi[i].fo, 0) < 0)
457 error(SYSTEM, "cannot seek on holodeck file");
458 n = hp->bl[i]->nrm * sizeof(RAYVAL);
459 if (write(hp->fd, (char *)hdbray(hp->bl[i]), n) != n) {
460 hp->fd = -1; /* avoid recursive error */
461 error(SYSTEM, "write error in hdfreebeam");
462 }
463 }
464 blglob(hp)->nrm -= hp->bl[i]->nrm;
465 free((char *)hp->bl[i]); /* free memory */
466 hp->bl[i] = NULL;
467 return(nchanged);
468 }
469
470
471 int
472 hdkillbeam(hp, i) /* delete beam from holodeck */
473 register HOLO *hp;
474 register int i;
475 {
476 static BEAM emptybeam;
477 int nchanged, n;
478
479 if (hp == NULL) { /* clobber all holodecks */
480 nchanged = 0;
481 for (i = 0; hdlist[i] != NULL; i++)
482 nchanged += hdkillbeam(hdlist[i], 0);
483 return(nchanged);
484 }
485 if (i == 0) { /* clobber entire holodeck */
486 nchanged = 0;
487 for (i = nbeams(hp); i > 0; i--)
488 if (hp->bi[i].nrd > 0 || hp->bl[i] != NULL)
489 nchanged += hdkillbeam(hp, i);
490 #ifdef DEBUG
491 if (biglob(hp)->nrd != 0 | blglob(hp)->nrm != 0)
492 error(CONSISTENCY, "bad beam count in hdkillbeam");
493 #endif
494 return(nchanged);
495 }
496 if (i < 1 | i > nbeams(hp))
497 error(CONSISTENCY, "bad beam index to hdkillbeam");
498 if (hp->bl[i] != NULL) { /* free memory */
499 blglob(hp)->nrm -= nchanged = hp->bl[i]->nrm;
500 free((char *)hp->bl[i]);
501 } else
502 nchanged = hp->bi[i].nrd;
503 if (hp->bi[i].nrd) { /* free file fragment */
504 hp->bl[i] = &emptybeam;
505 hdgetbi(hp, i);
506 }
507 hp->bl[i] = NULL;
508 return(nchanged);
509 }
510
511
512 hdlrulist(ha, ba, n, hp) /* add beams from holodeck to LRU list */
513 register HOLO *ha[]; /* section list (NULL terminated) */
514 register int ba[]; /* beam index to go with section */
515 int n; /* length of arrays minus 1 */
516 register HOLO *hp; /* section we're adding from */
517 {
518 register int i, j;
519 int nents;
520 /* find last entry in LRU list */
521 for (j = 0; ha[j] != NULL; j++)
522 ;
523 nents = j;
524 /* insert each beam from hp */
525 for (i = nbeams(hp); i > 0; i--) {
526 if (hp->bl[i] == NULL) /* check if loaded */
527 continue;
528 if ((j = ++nents) > n) /* grow list if we can */
529 nents--;
530 for ( ; ; ) { /* bubble into place */
531 if (!--j || hp->bl[i]->tick >=
532 ha[j-1]->bl[ba[j-1]]->tick) {
533 ha[j] = hp;
534 ba[j] = i;
535 break;
536 }
537 ha[j] = ha[j-1];
538 ba[j] = ba[j-1];
539 }
540 }
541 ha[nents] = NULL; /* all done */
542 ba[nents] = 0;
543 }
544
545
546 hdfreecache(pct, honly) /* free up cache space, writing changes */
547 int pct; /* maximum percentage to free */
548 register HOLO *honly; /* NULL means check all */
549 {
550 HOLO *hp[FREEBEAMS+1];
551 int bn[FREEBEAMS+1];
552 int freetarget;
553 register int i;
554 /* compute free target */
555 freetarget = (honly != NULL) ? blglob(honly)->nrm :
556 hdmemuse(0)/sizeof(RAYVAL) ;
557 freetarget = freetarget*pct/100;
558 /* find least recently used */
559 hp[0] = NULL;
560 bn[0] = 0;
561 if (honly != NULL)
562 hdlrulist(hp, bn, FREEBEAMS, honly);
563 else
564 for (i = 0; hdlist[i] != NULL; i++)
565 hdlrulist(hp, bn, FREEBEAMS, hdlist[i]);
566 /* free LRU beams */
567 for (i = 0; hp[i] != NULL; i++) {
568 hdfreebeam(hp[i], bn[i]);
569 if ((freetarget -= hp[i]->bi[bn[i]].nrd) <= 0)
570 break;
571 }
572 hdsync(honly); /* synchronize directories as necessary */
573 }
574
575
576 hddone(hp) /* clean up holodeck section and free */
577 register HOLO *hp; /* NULL means clean up all */
578 {
579 register int i;
580
581 if (hp == NULL) { /* NULL means clean up everything */
582 while (hdlist[0] != NULL)
583 hddone(hdlist[0]);
584 return;
585 }
586 /* flush all data and free memory */
587 hdflush(hp);
588 /* release fragment resources */
589 hdrelease(hp->fd);
590 /* remove hp from active list */
591 for (i = 0; hdlist[i] != NULL; i++)
592 if (hdlist[i] == hp) {
593 while ((hdlist[i] = hdlist[i+1]) != NULL)
594 i++;
595 break;
596 }
597 free((char *)hp->bl); /* free beam list */
598 free((char *)hp); /* free holodeck struct */
599 }