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

Comparing src/hd/holofile.c (file contents):
Revision 3.18 by gregl, Thu Jan 1 16:40:38 1998 UTC vs.
Revision 3.20 by gregl, Mon Jan 5 16:45:24 1998 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1997 Silicon Graphics, Inc. */
1 > /* Copyright (c) 1998 Silicon Graphics, Inc. */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ SGI";
# Line 126 | Line 126 | HDGRID *hproto;                /* holodeck section grid */
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");
129 >                        error(WARNING, "dirty holodeck section");
130          } else {                        /* assume we're creating it */
131                  if ((hp = hdalloc(hproto)) == NULL)
132                          goto memerr;
# Line 410 | Line 410 | int    (*bf)();                /* callback function (optional) */
410   }
411  
412  
413 + hdfreefrag(fd, bi)                      /* free a file fragment */
414 + int     fd;
415 + register BEAMI  *bi;
416 + {
417 +        register struct fraglist        *f;
418 +        register int    j, k;
419 +
420 +        if (bi->nrd == 0)
421 +                return;
422 + #ifdef DEBUG
423 +        if (fd < 0 | fd >= nhdfragls || !hdfragl[fd].nlinks)
424 +                error(CONSISTENCY, "bad file descriptor in hdfreefrag");
425 + #endif
426 +        f = &hdfragl[fd];
427 +        if (f->nfrags % FRAGBLK == 0) { /* delete empty remnants */
428 +                for (j = k = 0; k < f->nfrags; j++, k++) {
429 +                        while (f->fi[k].nrd == 0)
430 +                                if (++k >= f->nfrags)
431 +                                        goto endloop;
432 +                        if (k > j)
433 +                                copystruct(f->fi+j, f->fi+k);
434 +                }
435 +        endloop:
436 +                f->nfrags = j;
437 +        }
438 +        j = f->nfrags++;                /* allocate a slot in free list */
439 + #if MAXFRAG
440 +        if (j >= MAXFRAG-1)
441 +                f->nfrags--;
442 + #endif
443 +        if (j % FRAGBLK == 0) {         /* more free list space */
444 +                if (f->fi == NULL)
445 +                        f->fi = (BEAMI *)malloc(FRAGBLK*sizeof(BEAMI));
446 +                else
447 +                        f->fi = (BEAMI *)realloc((char *)f->fi,
448 +                                        (j+FRAGBLK)*sizeof(BEAMI));
449 +                if (f->fi == NULL)
450 +                        error(SYSTEM, "out of memory in hdfreefrag");
451 +        }
452 +        for ( ; ; j--) {                /* insert in descending list */
453 +                if (!j || bi->fo < f->fi[j-1].fo) {
454 +                        f->fi[j].fo = bi->fo;
455 +                        f->fi[j].nrd = bi->nrd;
456 +                        break;
457 +                }
458 +                copystruct(f->fi+j, f->fi+(j-1));
459 +        }
460 +                                        /* coalesce adjacent fragments */
461 +                                                /* successors never empty */
462 +        if (j && f->fi[j-1].fo == f->fi[j].fo + f->fi[j].nrd*sizeof(RAYVAL)) {
463 +                f->fi[j].nrd += f->fi[j-1].nrd;
464 +                f->fi[j-1].nrd = 0;
465 +        }
466 +        for (k = j+1; k < f->nfrags; k++)       /* get non-empty predecessor */
467 +                if (f->fi[k].nrd) {
468 +                        if (f->fi[j].fo == f->fi[k].fo +
469 +                                        f->fi[k].nrd*sizeof(RAYVAL)) {
470 +                                f->fi[k].nrd += f->fi[j].nrd;
471 +                                f->fi[j].nrd = 0;
472 +                        }
473 +                        break;
474 +                }
475 + }
476 +
477 +
478 + long
479 + hdallocfrag(fd, nrays)          /* allocate a file fragment */
480 + int     fd;
481 + unsigned int4   nrays;
482 + {
483 +        register struct fraglist        *f;
484 +        register int    j, k;
485 +        long    nfo;
486 +
487 +        if (nrays == 0)
488 +                return(-1L);
489 + #ifdef DEBUG
490 +        if (fd < 0 | fd >= nhdfragls || !hdfragl[fd].nlinks)
491 +                error(CONSISTENCY, "bad file descriptor in hdallocfrag");
492 + #endif
493 +        f = &hdfragl[fd];
494 +        k = -1;                         /* find closest-sized fragment */
495 +        for (j = f->nfrags; j-- > 0; )
496 +                if (f->fi[j].nrd >= nrays &&
497 +                                (k < 0 || f->fi[j].nrd < f->fi[k].nrd))
498 +                        if (f->fi[k=j].nrd == nrays)
499 +                                break;
500 +        if (k < 0) {                    /* no fragment -- extend file */
501 +                nfo = f->flen;
502 +                f->flen += nrays*sizeof(RAYVAL);
503 +        } else {                        /* else use fragment */
504 +                nfo = f->fi[k].fo;
505 +                f->fi[k].fo += nrays*sizeof(RAYVAL);
506 +                f->fi[k].nrd -= nrays;
507 +        }
508 +        return(nfo);
509 + }
510 +
511 +
512   int
513   hdsyncbeam(hp, i)               /* sync beam in memory with beam on disk */
514   register HOLO   *hp;
515   register int    i;
516   {
517 <        unsigned int    nrays;
419 <        long    nfo;
517 >        unsigned int4   nrays;
518          unsigned int    n;
519 +        long    nfo;
520                                          /* check file status */
521          if (hdfragl[hp->fd].writerr)
522                  return(-1);
# Line 428 | Line 527 | register int   i;
527                                          /* is current fragment OK? */
528          if (hp->bl[i] == NULL || (nrays = hp->bl[i]->nrm) == hp->bi[i].nrd)
529                  return(0);
530 <                                        /* locate fragment */
531 <        if (hp->bi[i].fo + hp->bi[i].nrd*sizeof(RAYVAL) ==
532 <                        hdfragl[hp->fd].flen)           /* EOF special case */
533 <                hdfragl[hp->fd].flen = (nfo=hp->bi[i].fo) + nrays*sizeof(RAYVAL);
435 <
436 <        else {                                          /* general case */
437 <                register struct fraglist        *f = &hdfragl[hp->fd];
438 <                register int    j, k;
439 <                n = f->nfrags;          /* relinquish old fragment */
440 <                if (hp->bi[i].nrd) {
441 <                        j = f->nfrags++;
442 < #if MAXFRAG
443 <                        if (j >= MAXFRAG-1)
444 <                                f->nfrags--;
445 < #endif
446 <                        if (j % FRAGBLK == 0) {         /* more frag. space */
447 <                                if (f->fi == NULL)
448 <                                        f->fi = (BEAMI *)malloc(
449 <                                                        FRAGBLK*sizeof(BEAMI));
450 <                                else
451 <                                        f->fi = (BEAMI *)realloc((char *)f->fi,
452 <                                                (j+FRAGBLK)*sizeof(BEAMI));
453 <                                if (f->fi == NULL)
454 <                                        error(SYSTEM,
455 <                                                "out of memory in hdsyncbeam");
456 <                        }
457 <                        for ( ; ; j--) {        /* insert in descending list */
458 <                                if (!j || hp->bi[i].fo < f->fi[j-1].fo) {
459 <                                        f->fi[j].fo = hp->bi[i].fo;
460 <                                        f->fi[j].nrd = hp->bi[i].nrd;
461 <                                        break;
462 <                                }
463 <                                copystruct(f->fi+j, f->fi+(j-1));
464 <                        }
465 <                                        /* coalesce adjacent fragments */
466 <                        if (j && f->fi[j-1].fo == f->fi[j].fo +
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 */
480 <                for (j = (nrays ? f->nfrags : 0); j-- > 0; )
481 <                        if (f->fi[j].nrd >= nrays &&
482 <                                        (k < 0 || f->fi[j].nrd < f->fi[k].nrd))
483 <                                if (f->fi[k=j].nrd == nrays)
484 <                                        break;
485 <                if (k < 0) {            /* no fragment -- extend file */
486 <                        nfo = f->flen;
487 <                        f->flen += nrays*sizeof(RAYVAL);
488 <                } else {                /* else use fragment */
489 <                        nfo = f->fi[k].fo;
490 <                        f->fi[k].fo += nrays*sizeof(RAYVAL);
491 <                        if (!(f->fi[k].nrd -= nrays) && k < n)
492 <                                n = k;
493 <                }
494 <                                        /* delete empty remnants */
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;
499 <                        if (k > j)
500 <                                copystruct(f->fi+j, f->fi+k);
501 <                }
502 <        endloop:
503 <                f->nfrags = j;
504 <        }
505 <        if (nrays) {            /* write the new fragment */
530 >        if (hp->bi[i].nrd)              /* relinquish old fragment */
531 >                hdfreefrag(hp->fd, &hp->bi[i]);
532 >        if (nrays) {                    /* get and write new fragment */
533 >                nfo = hdallocfrag(hp->fd, nrays);
534                  errno = 0;
535                  if (lseek(hp->fd, nfo, 0) < 0)
536                          error(SYSTEM, "cannot seek on holodeck file");
# Line 512 | Line 540 | register int   i;
540                          hdsync(NULL, 0);        /* sync directories */
541                          error(SYSTEM, "write error in hdsyncbeam");
542                  }
543 <        }
543 >                hp->bi[i].fo = nfo;
544 >        } else
545 >                hp->bi[i].fo = 0L;
546          biglob(hp)->nrd += nrays - hp->bi[i].nrd;
547          hp->bi[i].nrd = nrays;
548 <        hp->bi[i].fo = nfo;
519 <        markdirty(hp);          /* section directory now out of date */
548 >        markdirty(hp);                  /* section directory now out of date */
549          return(1);
550   }
551  

Diff Legend

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