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.14 by gregl, Thu Dec 18 15:12:23 1997 UTC vs.
Revision 3.16 by gregl, Wed Dec 31 11:35:39 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         32767   /* 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
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 74 | 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 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 212 | 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 230 | 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 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 410 | Line 410 | register int   i;
410          long    nfo;
411          unsigned int    n;
412                                          /* check file status */
413 <        if (hdfrag[hp->fd].writerr)
413 >        if (hdfragl[hp->fd].writerr)
414                  return(-1);
415   #ifdef DEBUG
416          if (i < 1 | i > nbeams(hp))
# Line 420 | Line 420 | register int   i;
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 >= nhdfrags || !hdfrag[hp->fd].nlinks) /* untracked */
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 <                        hdfrag[hp->fd].flen)            /* EOF special case */
428 <                hdfrag[hp->fd].flen = (nfo=hp->bi[i].fo) + nrays*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 fragment        *f = &hdfrag[hp->fd];
431 >                register struct fraglist        *f = &hdfragl[hp->fd];
432                  register int    j, k;
433 <                                        /* relinquish old fragment */
433 >                n = f->nfrags;          /* 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 >                                n = j-1;
465                          }
466 <                        f->nfrags = j;
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; )
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)
# Line 481 | Line 481 | register int   i;
481                          f->flen += nrays*sizeof(RAYVAL);
482                  } else {                /* else use fragment */
483                          nfo = f->fi[k].fo;
484 <                        if (f->fi[k].nrd == nrays) {    /* delete fragment */
485 <                                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 <                        }
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;
# Line 497 | Line 502 | register int   i;
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 <                        hdfrag[hp->fd].writerr++;
505 >                        hdfragl[hp->fd].writerr++;
506                          hdsync(hp, 0);          /* sync directory */
507                          error(SYSTEM, "write error in hdsyncbeam");
508                  }
# Line 523 | Line 528 | register int   i;
528                          nchanged += hdfreebeam(hdlist[i], 0);
529                  return(nchanged);
530          }
531 <        if (hdfrag[hp->fd].writerr)     /* check for file error */
531 >        if (hdfragl[hp->fd].writerr)    /* check for file error */
532                  return(0);
533          if (i == 0) {                   /* clear entire holodeck */
534                  nchanged = 0;

Diff Legend

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