ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/holofile.c
(Generate patch)

Comparing ray/src/hd/holofile.c (file contents):
Revision 3.1 by gregl, Fri Oct 31 10:23:29 1997 UTC vs.
Revision 3.10 by gregl, Thu Dec 11 11:29:35 1997 UTC

# Line 16 | Line 16 | static char SCCSid[] = "$SunId$ SGI";
16   #define CACHESIZE       16      /* default cache size (Mbytes, 0==inf) */
17   #endif
18   #ifndef FREEBEAMS
19 < #define FREEBEAMS       1024    /* maximum beams to free at a time */
19 > #define FREEBEAMS       512     /* maximum beams to free at a time */
20   #endif
21   #ifndef PCTFREE
22 < #define PCTFREE         12      /* maximum fraction to free (%) */
22 > #define PCTFREE         20      /* maximum fraction to free (%) */
23   #endif
24 < #ifndef FFDMAX
25 < #define FFDMAX          64      /* max. file descriptor for tracking */
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
27 – #ifndef MAXFRAG
28 – #define MAXFRAG         2048    /* maximum fragments tracked in each file */
29 – #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  
# Line 36 | Line 39 | HOLO   *hdlist[HDMAX+1];       /* holodeck pointers (NULL term
39   static struct fragment {
40          short   nlinks;         /* number of holodeck sections using us */
41          short   nfrags;         /* number of known fragments */
42 <        BEAMI   fi[MAXFRAG];    /* fragments, descending file position */
42 >        BEAMI   *fi;            /* fragments, descending file position */
43          long    flen;           /* last known file length */
44 < } *hdfrag[FFDMAX];      /* fragment lists, indexed by file descriptor */
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 >= FFDMAX)
53 <                return;                         /* descriptor out of range */
54 <        if (hdfrag[fd] == NULL) {
55 <                if ((hdfrag[fd] = (struct fragment *)
56 <                                malloc(sizeof(struct fragment))) == NULL)
57 <                        return;                 /* should flag error? */
58 <                hdfrag[fd]->nlinks = 0;
59 <                hdfrag[fd]->nfrags = 0;
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 */
65 >        hdfrag[fd].nlinks++;
66 >        hdfrag[fd].flen = lseek(fd, 0L, 2);     /* get file length */
67   }
68  
69  
# Line 64 | Line 73 | register int   fd;
73   hdrelease(fd)           /* stop tracking file fragments for some section */
74   register int    fd;
75   {
76 <        if (fd >= FFDMAX || hdfrag[fd] == NULL)
76 >        if (fd < 0 | fd >= nhdfrags || !hdfrag[fd].nlinks)
77                  return;
78 <        if (!--hdfrag[fd]->nlinks) {
79 <                free((char *)hdfrag[fd]);
80 <                hdfrag[fd] = NULL;
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 */
# Line 97 | Line 122 | HDGRID *hproto;                /* holodeck section grid */
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;
# Line 142 | Line 170 | register HOLO  *hp;
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);
# Line 171 | Line 200 | int    all;                    /* include overhead (painful) */
200                  }
201          }
202          if (all)
203 <                for (j = 0; j < FFDMAX; j++)
204 <                        if (hdfrag[j] != NULL)
205 <                                total += sizeof(struct fragment);
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 */
# Line 221 | Line 272 | int    nr;                     /* number of new rays desired */
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)
# Line 292 | Line 344 | register int   i;
344          if (hp->bi[i].nrd == nrays)     /* current one will do? */
345                  return(0);
346  
347 <        if (hp->fd >= FFDMAX || hdfrag[hp->fd] == NULL) /* untracked */
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);
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];
355 >                register struct fragment        *f = &hdfrag[hp->fd];
356                  register int    j, k;
357                                          /* relinquish old fragment */
358 <                if ((j = ++f->nfrags) >= MAXFRAG)
359 <                        f->nfrags--;
360 <                for ( ; ; ) {           /* stick it in our descending list */
361 <                        if (!--j || hp->bi[i].fo < f->fi[j-1].fo) {
362 <                                f->fi[j].fo = hp->bi[i].fo;
363 <                                f->fi[j].nrd = hp->bi[i].nrd;
364 <                                break;
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 <                        copystruct(f->fi+j, f->fi+j-1);
376 <                }
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 (j != k)
386 <                                copystruct(f->fi+j, f->fi+k);
387 <                        while (k+1 < f->nfrags &&
388 <                                f->fi[k+1].fo + f->fi[k+1].nrd*sizeof(RAYVAL) ==
389 <                                        f->fi[j].fo)
390 <                                f->fi[j].fo -= f->fi[++k].nrd*sizeof(RAYVAL);
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                  }
325 –                f->nfrags = j;
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 <                                        && f->fi[k=j].nrd == nrays)
402 <                                break;
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);
# Line 346 | Line 417 | register int   i;
417          }
418          biglob(hp)->nrd += nrays - hp->bi[i].nrd;
419          hp->bi[i].nrd = nrays;
420 <        hp->dirty++;            /* section directory now out of date */
420 >        markdirty(hp);          /* section directory now out of date */
421          return(1);
422   }
423  
# Line 364 | Line 435 | register int   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 = 1; i <= nbeams(hp); i++)
443 <                        nchanged += hdfreebeam(hp, i);
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))
# Line 382 | Line 456 | register int   i;
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)
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 */
# Line 392 | Line 468 | register int   i;
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 */
# Line 405 | Line 522 | register HOLO  *hp;                    /* section we're adding from */
522                  ;
523          nents = j;
524                                          /* insert each beam from hp */
525 <        for (i = nbeams(hp); i > 0; i-- ) {
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 */

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines