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

Comparing ray/src/hd/rholo3.c (file contents):
Revision 3.26 by gwlarson, Tue Dec 15 09:28:18 1998 UTC vs.
Revision 3.27 by gwlarson, Thu Jan 7 22:04:49 1999 UTC

# Line 10 | Line 10 | static char SCCSid[] = "$SunId$ SGI";
10  
11   #include "rholo.h"
12  
13 + #ifndef NFRAG2CHUNK
14 + #define NFRAG2CHUNK     4096    /* number of fragments to start chunking */
15 + #endif
16 +
17 + #ifndef abs
18   #define abs(x)          ((x) > 0 ? (x) : -(x))
19 + #endif
20 + #ifndef sgn
21   #define sgn(x)          ((x) > 0 ? 1 : (x) < 0 ? -1 : 0)
22 + #endif
23  
24 + #define rchunk(n)       (((n)+(RPACKSIZ/2))/RPACKSIZ)
25 +
26   static PACKHEAD *complist=NULL; /* list of beams to compute */
27   static int      complen=0;      /* length of complist */
28   static int      listpos=0;      /* current list position for next_packet */
29   static int      lastin= -1;     /* last ordered position in list */
30 + static int      chunky=0;       /* clump beams together on disk */
31  
32  
33   int
34   beamcmp(b0, b1)                         /* comparison for compute order */
35   register PACKHEAD       *b0, *b1;
36   {
37 <        return( b1->nr*(b0->nc+1) - b0->nr*(b1->nc+1) );
37 >        BEAMI   *bip0, *bip1;
38 >        register long   c;
39 >                                        /* first check desired quantities */
40 >        if (chunky)
41 >                c = rchunk(b1->nr)*(rchunk(b0->nc)+1) -
42 >                                rchunk(b0->nr)*(rchunk(b1->nc)+1);
43 >        else
44 >                c = b1->nr*(b0->nc+1) - b0->nr*(b1->nc+1);
45 >        if (c) return(c);
46 >                                /* only one file, so skip the following: */
47 > #if 0
48 >                                        /* next, check file descriptors */
49 >        c = hdlist[b0->hd]->fd - hdlist[b1->hd]->fd;
50 >        if (c) return(c);
51 > #endif
52 >                                        /* finally, check file positions */
53 >        bip0 = &hdlist[b0->hd]->bi[b0->bi];
54 >        bip1 = &hdlist[b1->hd]->bi[b1->bi];
55 >                                        /* put diskless beams last */
56 >        if (!bip0->nrd)
57 >                return(bip1->nrd > 0);
58 >        if (!bip1->nrd)
59 >                return(-1);
60 >        c = bip0->fo - bip1->fo;
61 >        return(c < 0 ? -1 : c > 0);
62   }
63  
64  
# Line 159 | Line 194 | int    nents;
194          default:
195                  error(CONSISTENCY, "bundle_set called with unknown operation");
196          }
197 <        if (outdev == NULL)             /* nothing to display? */
197 >        if (outdev == NULL || !nents)   /* nothing to display? */
198                  return;
199                                          /* load and display beams we have */
200          hbarr = (HDBEAMI *)malloc(nents*sizeof(HDBEAMI));
# Line 169 | Line 204 | int    nents;
204          }
205          hdloadbeams(hbarr, nents, dispbeam);
206          free((char *)hbarr);
207 +        if (hdfragflags&FF_READ) {
208 +                listpos = 0;
209 +                lastin = -1;            /* need to re-sort list */
210 +        }
211          return;
212   memerr:
213          error(SYSTEM, "out of memory in bundle_set");
# Line 280 | Line 319 | int    n1, n2;
319   sortcomplist()                  /* fix our list order */
320   {
321          PACKHEAD        *list2;
322 +        int     listlen;
323          register int    i;
324  
325          if (complen <= 0)       /* check to see if there is even a list */
326                  return;
327 +        if (!chunky)            /* check to see if fragment list is full */
328 +                if (!hdfragOK(hdlist[0]->fd, &listlen, NULL)
329 + #if NFRAG2CHUNK
330 +                                || listlen >= NFRAG2CHUNK
331 + #endif
332 +                                ) {
333 + #ifdef DEBUG
334 +                        error(WARNING, "using chunky comparison mode");
335 + #endif
336 +                        chunky++;       /* use "chunky" comparison */
337 +                        lastin = -1;    /* need to re-sort list */
338 +                }
339          if (lastin < 0 || listpos*4 >= complen*3)
340                  qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
341          else if (listpos) {     /* else sort and merge sublist */
# Line 319 | Line 371 | sortcomplist()                 /* fix our list order */
371   * more or less evenly distributed, such that computing a packet causes
372   * a given bundle to move way down in the computation order.  We keep
373   * track of where the computed bundle with the highest priority would end
374 < * up, and if we get further in our compute list than this, we resort the
374 > * up, and if we get further in our compute list than this, we re-sort the
375   * list and start again from the beginning.  Since
376   * a merge sort is used, the sorting costs are minimal.
377   */
# Line 346 | Line 398 | int    n;
398          if (p->nr > n)
399                  p->nr = n;
400          complist[listpos].nc += p->nr;  /* find where this one would go */
401 +        if (hdgetbeam(hdlist[p->hd], p->bi) != NULL)
402 +                hdfreefrag(hdlist[p->hd], p->bi);
403          while (lastin > listpos &&
404                          beamcmp(complist+lastin, complist+listpos) > 0)
405                  lastin--;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines