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

Comparing ray/src/rt/ambient.c (file contents):
Revision 2.14 by greg, Tue Nov 3 21:29:52 1992 UTC vs.
Revision 2.26 by greg, Thu Apr 27 14:12:05 1995 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1992 Regents of the University of California */
1 > /* Copyright (c) 1993 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 6 | Line 6 | static char SCCSid[] = "$SunId$ LBL";
6  
7   /*
8   *  ambient.c - routines dealing with ambient (inter-reflected) component.
9 – *
10 – *     5/9/86
9   */
10  
11   #include  "ray.h"
# Line 29 | Line 27 | typedef struct ambtree {
27  
28   extern CUBE  thescene;          /* contains space boundaries */
29  
30 + extern char  *shm_boundary;     /* shared memory boundary */
31 +
32   #define  MAXASET        511     /* maximum number of elements in ambient set */
33   OBJECT  ambset[MAXASET+1]={0};  /* ambient include/exclude set */
34  
# Line 38 | Line 38 | double minarad;                /* minimum ambient radius */
38   static AMBTREE  atrunk;         /* our ambient trunk node */
39  
40   static FILE  *ambfp = NULL;     /* ambient file pointer */
41 + static int  nunflshed = 0;      /* number of unflushed ambient values */
42  
43 + #ifndef SORT_THRESH
44 + #ifdef BIGMEM
45 + #define SORT_THRESH     (6*(1L<<20)/sizeof(AMBVAL))
46 + #else
47 + #define SORT_THRESH     (2*(1L<<20)/sizeof(AMBVAL))
48 + #endif
49 + #endif
50 + #ifndef SORT_INTVL
51 + #define SORT_INTVL      (SORT_THRESH*2)
52 + #endif
53 +
54 + static long  ambclock = 0;      /* ambient access clock */
55 + static int  nambvals = 0;       /* number of stored ambient values */
56 + static long  lastsort = 0;      /* time of last value sort */
57 + static long  sortintvl = SORT_INTVL;    /* time until next sort */
58 +
59 + #define MAXACLOCK       (1L<<30)        /* clock turnover value */
60 + #define tracktime       (shm_boundary == NULL || ambfp == NULL)
61 + #define need2sort       (ambclock > lastsort+sortintvl && \
62 +                                nambvals > SORT_THRESH)
63 +
64   #define  AMBFLUSH       (BUFSIZ/AMBVALSIZ)
65  
66   #define  newambval()    (AMBVAL *)bmalloc(sizeof(AMBVAL))
67  
46 – #define  newambtree()   (AMBTREE *)calloc(8, sizeof(AMBTREE))
47 –
68   extern long  ftell(), lseek();
69 < static int  initambfile(), avsave(), avinsert(), ambsync();
69 > static int  initambfile(), avsave(), avinsert(), sortambvals();
70 > static AMBVAL  *avstore();
71 > #ifdef  F_SETLKW
72 > static  aflock();
73 > #endif
74  
75  
76   setambres(ar)                           /* set ambient resolution */
77   int  ar;
78   {
79 +        ambres = ar < 0 ? 0 : ar;               /* may be done already */
80                                                  /* set min & max radii */
81          if (ar <= 0) {
82 <                minarad = 0.0;
82 >                minarad = 0;
83                  maxarad = thescene.cusize / 2.0;
84          } else {
85                  minarad = thescene.cusize / ar;
86 <                maxarad = 16.0 * minarad;               /* heuristic */
86 >                maxarad = 16 * minarad;                 /* heuristic */
87                  if (maxarad > thescene.cusize / 2.0)
88                          maxarad = thescene.cusize / 2.0;
89          }
90 <        if (maxarad <= FTINY)
91 <                maxarad = .001;
90 >        if (minarad <= FTINY)
91 >                minarad = 10*FTINY;
92 >        if (maxarad <= minarad)
93 >                maxarad = 64 * minarad;
94   }
95  
96  
97 + setambacc(newa)                         /* set ambient accuracy */
98 + double  newa;
99 + {
100 +        static double  oldambacc = -1.0;
101 +
102 +        ambacc = newa < 0.0 ? 0.0 : newa;       /* may be done already */
103 +        if (oldambacc < -FTINY)
104 +                oldambacc = ambacc;     /* do nothing first call */
105 +        if (fabs(newa - oldambacc) < 0.01)
106 +                return;                 /* insignificant -- don't bother */
107 +        if (ambacc <= FTINY)
108 +                return;                 /* cannot build new tree */
109 +                                        /* else need to rebuild tree */
110 +        sortambvals(1);
111 +        oldambacc = ambacc;             /* remeber setting for next call */
112 + }
113 +
114 +
115   setambient(afile)                       /* initialize calculation */
116   char  *afile;
117   {
# Line 74 | Line 119 | char  *afile;
119          AMBVAL  amb;
120                                                  /* init ambient limits */
121          setambres(ambres);
122 +        setambacc(ambacc);
123 +        if (afile == NULL)
124 +                return;
125 +        if (ambacc <= FTINY) {
126 +                sprintf(errmsg, "zero ambient accuracy so \"%s\" not opened",
127 +                                afile);
128 +                error(WARNING, errmsg);
129 +                return;
130 +        }
131                                                  /* open ambient file */
132 <        if (afile != NULL)
133 <                if ((ambfp = fopen(afile, "r+")) != NULL) {
134 <                        initambfile(0);
135 <                        headlen = ftell(ambfp);
136 <                        while (readambval(&amb, ambfp))
137 <                                avinsert(&amb, &atrunk, thescene.cuorg,
138 <                                                thescene.cusize);
139 <                                                        /* align */
140 <                        fseek(ambfp, -((ftell(ambfp)-headlen)%AMBVALSIZ), 1);
141 <                } else if ((ambfp = fopen(afile, "w+")) != NULL)
142 <                        initambfile(1);
143 <                else {
144 <                        sprintf(errmsg, "cannot open ambient file \"%s\"",
145 <                                        afile);
146 <                        error(SYSTEM, errmsg);
93 <                }
132 >        if ((ambfp = fopen(afile, "r+")) != NULL) {
133 >                initambfile(0);
134 >                headlen = ftell(ambfp);
135 >                while (readambval(&amb, ambfp))
136 >                        avinsert(avstore(&amb));
137 >                                                /* align */
138 >                fseek(ambfp, -((ftell(ambfp)-headlen)%AMBVALSIZ), 1);
139 >        } else if ((ambfp = fopen(afile, "w+")) != NULL)
140 >                initambfile(1);
141 >        else {
142 >                sprintf(errmsg, "cannot open ambient file \"%s\"", afile);
143 >                error(SYSTEM, errmsg);
144 >        }
145 >        nunflshed++;    /* lie */
146 >        ambsync();
147   }
148  
149  
# Line 142 | Line 195 | register RAY  *r;
195                  return;
196          }
197                                                  /* get ambient value */
198 +        if (need2sort)
199 +                sortambvals(0);
200          setcolor(acol, 0.0, 0.0, 0.0);
201          d = sumambient(acol, r, rdepth,
202                          &atrunk, thescene.cuorg, thescene.cusize);
# Line 176 | Line 231 | double s;
231                                          /* do this node */
232          wsum = 0.0;
233          for (av = at->alist; av != NULL; av = av->next) {
234 +                if (tracktime)
235 +                        av->latick = ambclock++;
236                  /*
237                   *  Ambient level test.
238                   */
239 <                if (av->lvl > al || av->weight < r->rweight-FTINY)
239 >                if (av->lvl > al)       /* list sorted, so this works */
240 >                        break;
241 >                if (av->weight < r->rweight-FTINY)
242                          continue;
243                  /*
244                   *  Ambient radius test.
# Line 306 | Line 365 | int  creat;
365   {
366          extern char  *progname, *octname, VersionID[];
367  
368 + #ifdef  F_SETLKW
369 +        aflock(creat ? F_WRLCK : F_RDLCK);
370 + #endif
371   #ifdef MSDOS
372          setmode(fileno(ambfp), O_BINARY);
373   #endif
374 <        setbuf(ambfp, bmalloc(BUFSIZ));
374 >        setbuf(ambfp, bmalloc(BUFSIZ+8));
375          if (creat) {                    /* new file */
376 +                newheader("RADIANCE", ambfp);
377                  fprintf(ambfp, "%s -av %g %g %g -ab %d -aa %g ",
378                                  progname, colval(ambval,RED),
379                                  colval(ambval,GRN), colval(ambval,BLU),
# Line 322 | Line 385 | int  creat;
385                  fputformat(AMBFMT, ambfp);
386                  putc('\n', ambfp);
387                  putambmagic(ambfp);
325 –                fflush(ambfp);
326 – #ifndef  NIX
327 –                sync();                 /* protect against NFS buffering */
328 – #endif
388          } else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
389                  error(USER, "bad ambient file");
390   }
# Line 335 | Line 394 | static
394   avsave(av)                              /* insert and save an ambient value */
395   AMBVAL  *av;
396   {
397 <        static int  nunflshed = 0;
339 <
340 <        avinsert(av, &atrunk, thescene.cuorg, thescene.cusize);
397 >        avinsert(avstore(av));
398          if (ambfp == NULL)
399                  return;
400          if (writambval(av, ambfp) < 0)
401                  goto writerr;
402 <        if (++nunflshed >= AMBFLUSH) {
402 >        if (++nunflshed >= AMBFLUSH)
403                  if (ambsync() == EOF)
404                          goto writerr;
348 –                nunflshed = 0;
349 –        }
405          return;
406   writerr:
407          error(SYSTEM, "error writing ambient file");
408   }
409  
410  
411 + static AMBVAL *
412 + avstore(aval)                           /* allocate memory and store aval */
413 + register AMBVAL  *aval;
414 + {
415 +        register AMBVAL  *av;
416 +
417 +        if ((av = newambval()) == NULL)
418 +                error(SYSTEM, "out of memory in avstore");
419 +        copystruct(av, aval);
420 +        av->latick = ambclock;
421 +        av->next = NULL;
422 +        nambvals++;
423 +        return(av);
424 + }
425 +
426 +
427 + #define ATALLOCSZ       512             /* #/8 trees to allocate at once */
428 +
429 + static AMBTREE  *atfreelist = NULL;     /* free ambient tree structures */
430 +
431 +
432   static
433 < avinsert(aval, at, c0, s)               /* insert ambient value in a tree */
434 < AMBVAL  *aval;
359 < register AMBTREE  *at;
360 < FVECT  c0;
361 < double  s;
433 > AMBTREE *
434 > newambtree()                            /* allocate 8 ambient tree structs */
435   {
436 +        register AMBTREE  *atp, *upperlim;
437 +
438 +        if (atfreelist == NULL) {       /* get more nodes */
439 +                atfreelist = (AMBTREE *)bmalloc(ATALLOCSZ*8*sizeof(AMBTREE));
440 +                if (atfreelist == NULL)
441 +                        return(NULL);
442 +                                        /* link new free list */
443 +                upperlim = atfreelist + 8*(ATALLOCSZ-1);
444 +                for (atp = atfreelist; atp < upperlim; atp += 8)
445 +                        atp->kid = atp + 8;
446 +                atp->kid = NULL;
447 +        }
448 +        atp = atfreelist;
449 +        atfreelist = atp->kid;
450 +        bzero((char *)atp, 8*sizeof(AMBTREE));
451 +        return(atp);
452 + }
453 +
454 +
455 + static
456 + freeambtree(atp)                        /* free 8 ambient tree structs */
457 + AMBTREE  *atp;
458 + {
459 +        atp->kid = atfreelist;
460 +        atfreelist = atp;
461 + }
462 +
463 +
464 + static
465 + avinsert(av)                            /* insert ambient value in our tree */
466 + register AMBVAL  *av;
467 + {
468 +        register AMBTREE  *at;
469 +        register AMBVAL  *ap;
470 +        AMBVAL  avh;
471          FVECT  ck0;
472 +        double  s;
473          int  branch;
365 –        register AMBVAL  *av;
474          register int  i;
475  
476 <        if ((av = newambval()) == NULL)
477 <                goto memerr;
478 <        copystruct(av, aval);
479 <        VCOPY(ck0, c0);
476 >        if (av->rad <= FTINY)
477 >                error(CONSISTENCY, "zero ambient radius in avinsert");
478 >        at = &atrunk;
479 >        VCOPY(ck0, thescene.cuorg);
480 >        s = thescene.cusize;
481          while (s*(OCTSCALE/2) > av->rad*ambacc) {
482                  if (at->kid == NULL)
483                          if ((at->kid = newambtree()) == NULL)
484 <                                goto memerr;
484 >                                error(SYSTEM, "out of memory in avinsert");
485                  s *= 0.5;
486                  branch = 0;
487                  for (i = 0; i < 3; i++)
# Line 382 | Line 491 | double s;
491                          }
492                  at = at->kid + branch;
493          }
494 <        av->next = at->alist;
495 <        at->alist = av;
496 <        return;
497 < memerr:
498 <        error(SYSTEM, "out of memory in avinsert");
494 >        avh.next = at->alist;           /* order by increasing level */
495 >        for (ap = &avh; ap->next != NULL; ap = ap->next)
496 >                if (ap->next->lvl >= av->lvl)
497 >                        break;
498 >        av->next = ap->next;
499 >        ap->next = av;
500 >        at->alist = avh.next;
501   }
502  
503  
504 < #ifdef  NIX
504 > static
505 > unloadatree(at, f)                      /* unload an ambient value tree */
506 > register AMBTREE  *at;
507 > int     (*f)();
508 > {
509 >        register AMBVAL  *av;
510 >        register int  i;
511 >                                        /* transfer values at this node */
512 >        for (av = at->alist; av != NULL; av = at->alist) {
513 >                at->alist = av->next;
514 >                (*f)(av);
515 >        }
516 >        if (at->kid == NULL)
517 >                return;
518 >        for (i = 0; i < 8; i++)         /* transfer and free children */
519 >                unloadatree(at->kid+i, f);
520 >        freeambtree(at->kid);
521 >        at->kid = NULL;
522 > }
523  
524 +
525 + static AMBVAL   **avlist1, **avlist2;   /* ambient value lists for sorting */
526 + static int      i_avlist;               /* index for lists */
527 +
528 +
529   static
530 < ambsync()                       /* flush ambient file */
530 > av2list(av)
531 > AMBVAL  *av;
532   {
533 <        return(fflush(ambfp));
533 >        if (i_avlist >= nambvals)
534 >                error(CONSISTENCY, "too many ambient values in av2list1");
535 >        avlist1[i_avlist] = avlist2[i_avlist] = av;
536 >        i_avlist++;
537   }
538  
401 – #else
539  
540 < #include  <sys/types.h>
541 < #include  <sys/stat.h>
540 > static int
541 > alatcmp(avp1, avp2)                     /* compare ambient values for MRA */
542 > AMBVAL  **avp1, **avp2;
543 > {
544 >        return((**avp2).latick - (**avp1).latick);
545 > }
546  
547 +
548 + static int
549 + aposcmp(avp1, avp2)                     /* compare ambient value positions */
550 + AMBVAL  **avp1, **avp2;
551 + {
552 +        return(*avp1 - *avp2);
553 + }
554 +
555 +
556   static
557 + sortambvals(always)                     /* resort ambient values */
558 + int     always;
559 + {
560 +        AMBTREE  oldatrunk;
561 +        AMBVAL  tav, *tap, *pnext;
562 +        register int    i, j;
563 +        /*
564 +         * The idea here is to minimize memory thrashing
565 +         * in VM systems by improving reference locality.
566 +         * We do this by periodically sorting our stored ambient
567 +         * values in memory in order of most recently to least
568 +         * recently accessed.  This ordering was chosen so that new
569 +         * ambient values (which tend to be less important) go into
570 +         * higher memory with the infrequently accessed values.
571 +         *      Since we expect our values to need sorting less
572 +         * frequently as the process continues, we double our
573 +         * waiting interval after each call.
574 +         *      This routine is also called by setambacc() with
575 +         * the "always" parameter set to 1 so that the ambient
576 +         * tree will be rebuilt with the new accuracy parameter.
577 +         */
578 +        if (tracktime) {
579 +                avlist1 = (AMBVAL **)malloc(nambvals*sizeof(AMBVAL *));
580 +                avlist2 = (AMBVAL **)malloc(nambvals*sizeof(AMBVAL *));
581 +        } else
582 +                avlist1 = avlist2 = NULL;
583 +        if (avlist2 == NULL) {          /* rebuild tree? */
584 +                if (avlist1 != NULL)
585 +                        free((char *)avlist1);
586 +                if (!always)
587 +                        return;
588 +                copystruct(&oldatrunk, &atrunk);
589 +                atrunk.alist = NULL;
590 +                atrunk.kid = NULL;
591 +                unloadatree(&oldatrunk, avinsert);
592 +        } else {                        /* sort memory by last access time */
593 +                i_avlist = 0;
594 +                unloadatree(&atrunk, av2list);  /* empty current tree */
595 +                /*
596 +                 * Sorting memory is tricky because it isn't contiguous.
597 +                 * We have to sort an array of pointers by MRA and also
598 +                 * by memory position.  We then copy values in "loops"
599 +                 * to minimize memory hits.  Nevertheless, we will visit
600 +                 * everyone at least once, and this is an expensive process
601 +                 * when we're thrashing, which is when we need to do it.
602 +                 */
603 +                qsort((char *)avlist1, nambvals, sizeof(AMBVAL *), alatcmp);
604 +                qsort((char *)avlist2, nambvals, sizeof(AMBVAL *), aposcmp);
605 +                for (i = 0; i < nambvals; i++) {
606 +                        if (avlist1[i] == NULL || avlist1[i] == avlist2[i])
607 +                                continue;
608 +                        tap = avlist2[i];
609 +                        copystruct(&tav, tap);
610 +                        for (j = i; (pnext = avlist1[j]) != tap;
611 +                                        j = (AMBVAL **)bsearch((char *)&pnext,
612 +                                                (char *)(avlist2+i),nambvals-i,
613 +                                                sizeof(AMBVAL *),aposcmp) -
614 +                                                avlist2) {
615 +                                copystruct(avlist2[j], pnext);
616 +                                avinsert(avlist2[j]);
617 +                                avlist1[j] = NULL;
618 +                        }
619 +                        copystruct(avlist2[j], &tav);
620 +                        avinsert(avlist2[j]);
621 +                        avlist1[j] = NULL;
622 +                }
623 +                free((char *)avlist1);
624 +                free((char *)avlist2);
625 +                if (sortintvl < MAXACLOCK/4)
626 +                        sortintvl <<= 1;        /* wait twice as long next */
627 +        }
628 +        if (ambclock >= MAXACLOCK)
629 +                ambclock = MAXACLOCK/2;
630 +        lastsort = ambclock;
631 + }
632 +
633 +
634 + #ifdef  F_SETLKW
635 +
636 + static
637 + aflock(typ)                     /* lock/unlock ambient file */
638 + int  typ;
639 + {
640 +        static struct flock  fls;       /* static so initialized to zeroes */
641 +
642 +        fls.l_type = typ;
643 +        if (fcntl(fileno(ambfp), F_SETLKW, &fls) < 0)
644 +                error(SYSTEM, "cannot (un)lock ambient file");
645 + }
646 +
647 +
648 + int
649   ambsync()                       /* synchronize ambient file */
650   {
651          static FILE  *ambinp = NULL;
652 <        struct flock  fls;
653 <        struct stat  sts;
412 < #define flen    sts.st_size
652 >        static long  lastpos = -1;
653 >        long  flen;
654          AMBVAL  avs;
414 –        long  lastpos;
655          register int  n;
656 +
657 +        if (nunflshed == 0)
658 +                return(0);
659 +        if (lastpos < 0)        /* initializing (locked in initambfile) */
660 +                goto syncend;
661                                  /* gain exclusive access */
662 <        fls.l_type = F_WRLCK;
418 <        fls.l_whence = 0;
419 <        fls.l_start = 0L;
420 <        fls.l_len = 0L;
421 <        if (fcntl(fileno(ambfp), F_SETLKW, &fls) < 0)
422 <                error(SYSTEM, "cannot lock ambient file");
662 >        aflock(F_WRLCK);
663                                  /* see if file has grown */
664 <        lastpos = lseek(fileno(ambfp), 0L, 1);  /* get previous position */
665 <        if (fstat(fileno(ambfp), &sts) < 0)     /* get current length */
666 <                error(SYSTEM, "cannot stat ambient file");
667 <        if (n = (flen - lastpos)/AMBVALSIZ) {   /* file has grown */
428 <                if (ambinp == NULL) {           /* use duplicate file */
664 >        if ((flen = lseek(fileno(ambfp), 0L, 2)) < 0)
665 >                goto seekerr;
666 >        if (n = flen - lastpos) {               /* file has grown */
667 >                if (ambinp == NULL) {           /* use duplicate filedes */
668                          ambinp = fdopen(dup(fileno(ambfp)), "r");
669                          if (ambinp == NULL)
670                                  error(SYSTEM, "fdopen failed in ambsync");
671                  }
672 <                while (n--) {                   /* load contributed values */
672 >                if (fseek(ambinp, lastpos, 0) < 0)
673 >                        goto seekerr;
674 >                while (n >= AMBVALSIZ) {        /* load contributed values */
675                          readambval(&avs, ambinp);
676 <                        avinsert(&avs,&atrunk,thescene.cuorg,thescene.cusize);
677 <                }                               /* moves shared file pointer */
678 <                if (n = (flen - lastpos)%AMBVALSIZ)     /* alignment */
679 <                        lseek(fileno(ambfp), flen-n, 0);
676 >                        avinsert(avstore(&avs));
677 >                        n -= AMBVALSIZ;
678 >                }
679 >                /*** seek always as safety measure
680 >                if (n) ***/                     /* alignment */
681 >                        if (lseek(fileno(ambfp), flen-n, 0) < 0)
682 >                                goto seekerr;
683          }
684 + #ifdef  DEBUG
685 +        if (ambfp->_ptr - ambfp->_base != nunflshed*AMBVALSIZ) {
686 +                sprintf(errmsg, "ambient file buffer at %d rather than %d",
687 +                                ambfp->_ptr - ambfp->_base,
688 +                                nunflshed*AMBVALSIZ);
689 +                error(CONSISTENCY, errmsg);
690 +        }
691 + #endif
692 + syncend:
693          n = fflush(ambfp);                      /* calls write() at last */
694 <        fls.l_type = F_UNLCK;                   /* release file */
695 <        fcntl(fileno(ambfp), F_SETLKW, &fls);
694 >        if ((lastpos = lseek(fileno(ambfp), 0L, 1)) < 0)
695 >                goto seekerr;
696 >        aflock(F_UNLCK);                        /* release file */
697 >        nunflshed = 0;
698          return(n);
699 + seekerr:
700 +        error(SYSTEM, "seek failed in ambsync");
701 + }
702 +
703 + #else
704 +
705 + int
706 + ambsync()                       /* flush ambient file */
707 + {
708 +        if (nunflshed == 0)
709 +                return(0);
710 +        nunflshed = 0;
711 +        return(fflush(ambfp));
712   }
713  
714   #endif

Diff Legend

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