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.1 by gregl, Fri Oct 31 10:23:29 1997 UTC vs.
Revision 3.2 by gregl, Mon Nov 3 18:33:13 1997 UTC

# Line 17 | Line 17 | static char SCCSid[] = "$SunId$ SGI";
17  
18   static PACKHEAD *complist;      /* list of beams to compute */
19   static int      complen;        /* length of complist */
20 < static int      listpos;        /* current list position for next_pack */
21 < static int      lastin;         /* last ordered position in list */
20 > static int      listpos;        /* current list position for next_packet */
21 > static int      lastin = -1;    /* last ordered position in list */
22  
23  
24   int
25 + beamcmp(b0, b1)                 /* comparison for descending compute order */
26 + register PACKHEAD       *b0, *b1;
27 + {
28 +        return( b1->nr*(bnrays(hdlist[b0->hd],b0->bi)+1) -
29 +                b0->nr*(bnrays(hdlist[b1->hd],b1->bi)+1) );
30 + }
31 +
32 +
33 + bundle_set(op, clist, nents)    /* bundle set operation */
34 + int     op;
35 + PACKHEAD        *clist;
36 + int     nents;
37 + {
38 +        BEAM    *b;
39 +        PACKHEAD        *p;
40 +        register int    i, n;
41 +
42 +        switch (op) {
43 +        case BS_NEW:                    /* new computation set */
44 +                if (complen)
45 +                        free((char *)complist);
46 +                if (nents <= 0) {
47 +                        complist = NULL;
48 +                        listpos = complen = 0;
49 +                        lastin = -1;
50 +                        return;
51 +                }
52 +                complist = (PACKHEAD *)malloc(nents*sizeof(PACKHEAD));
53 +                if (complist == NULL)
54 +                        goto memerr;
55 +                bcopy((char *)clist, (char *)complist, nents*sizeof(PACKHEAD));
56 +                complen = nents;
57 +                listpos = 0;
58 +                lastin = -1;            /* flag for initial sort */
59 +                break;
60 +        case BS_ADD:                    /* add to computation set */
61 +                if (nents <= 0)
62 +                        return;
63 +                                        /* merge any common members */
64 +                for (i = 0; i < complen; i++)
65 +                        for (n = 0; n < nents; n++)
66 +                                if (clist[n].bi == complist[i].bi &&
67 +                                                clist[n].hd == complist[i].hd) {
68 +                                        complist[i].nr += clist[n].nr;
69 +                                        clist[n].nr = 0;
70 +                                        lastin = -1;    /* flag full sort */
71 +                                        break;
72 +                                }
73 +                                        /* sort updated list */
74 +                sortcomplist();
75 +                                        /* sort new entries */
76 +                qsort((char *)clist, nents, sizeof(PACKHEAD), beamcmp);
77 +                                        /* what can't we satisfy? */
78 +                for (n = 0; n < nents && clist[n].nr >
79 +                                bnrays(hdlist[clist[n].hd],clist[n].bi); n++)
80 +                        ;
81 +                if (n) {                /* allocate space for merged list */
82 +                        PACKHEAD        *newlist;
83 +                        newlist = (PACKHEAD *)malloc(
84 +                                        (complen+n)*sizeof(PACKHEAD) );
85 +                        if (newlist == NULL)
86 +                                goto memerr;
87 +                                                /* merge lists */
88 +                        mergeclists(newlist, clist, n, complist, complen);
89 +                        if (complen)
90 +                                free((char *)complist);
91 +                        complist = newlist;
92 +                        complen += n;
93 +                }
94 +                listpos = 0;
95 +                lastin = complen-1;     /* list is now sorted */
96 +                break;
97 +        case BS_DEL:                    /* delete from computation set */
98 +                if (nents <= 0)
99 +                        return;
100 +                                        /* find each member */
101 +                for (i = 0; i < complen; i++)
102 +                        for (n = 0; n < nents; n++)
103 +                                if (clist[n].bi == complist[i].bi &&
104 +                                                clist[n].hd == complist[i].hd) {
105 +                                        if (clist[n].nr == 0 ||
106 +                                                clist[n].nr >= complist[i].nr)
107 +                                                complist[i].nr = 0;
108 +                                        else
109 +                                                complist[i].nr -= clist[n].nr;
110 +                                        lastin = -1;    /* flag full sort */
111 +                                        break;
112 +                                }
113 +                                        /* sort updated list */
114 +                sortcomplist();
115 +                return;                 /* no display */
116 +        default:
117 +                error(CONSISTENCY, "bundle_set called with unknown operation");
118 +        }
119 +        n = 0;                          /* allocate packet holder */
120 +        for (i = 0; i < nents; i++)
121 +                if (clist[i].nr > n)
122 +                        n = clist[i].nr;
123 +        p = (PACKHEAD *)malloc(sizeof(PACKHEAD) + n*sizeof(RAYVAL));
124 +                                        /* now, display what we can */
125 +        for (i = 0; i < nents; i++)
126 +                if (clist[i].nr > 0 &&
127 +                (b = hdgetbeam(hdlist[clist[i].hd], clist[i].bi)) != NULL) {
128 +                        bcopy((char *)hdbray(b), (char *)(p+1),
129 +                                        (p->nr=b->nrm)*sizeof(RAYVAL));
130 +                        disp_packet((PACKET *)p);
131 +                }
132 +        free((char *)p);                /* clean up */
133 +        return;
134 + memerr:
135 +        error(SYSTEM, "out of memory in bundle_set");
136 + }
137 +
138 +
139 + int
140   weightf(hp, x0, x1, x2)         /* voxel weighting function */
141   register HOLO   *hp;
142   register int    x0, x1, x2;
# Line 82 | Line 197 | int    x, y, z, dx, dy, dz;
197   }
198  
199  
85 – int
86 – beamcmp(b0, b1)                 /* comparison for descending compute order */
87 – register PACKHEAD       *b0, *b1;
88 – {
89 –        return( b1->nr*(bnrays(hdlist[b0->hd],b0->bi)+1) -
90 –                b0->nr*(bnrays(hdlist[b1->hd],b1->bi)+1) );
91 – }
92 –
93 –
200   init_global()                   /* initialize global ray computation */
201   {
202          long    wtotal = 0;
# Line 156 | Line 262 | int    n1, n2;
262   sortcomplist()                  /* fix our list order */
263   {
264          PACKHEAD        *list2;
265 +        register int    i;
266 +
267                                  /* empty queue */
268          done_packets(flush_queue());
269 +        if (complen <= 0)       /* check to see if there even is a list */
270 +                return;
271          if (lastin < 0)         /* flag to sort entire list */
272                  qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
273          else if (listpos) {     /* else sort and merge sublist */
# Line 170 | Line 280 | sortcomplist()                 /* fix our list order */
280                                  complist+listpos, complen-listpos);
281                  free((char *)list2);
282          }
283 <        listpos = 0; lastin = complen-1;
283 >                                        /* check for all finished */
284 >        if (complist[0].nr <= bnrays(hdlist[complist[0].hd],complist[0].bi)) {
285 >                free((char *)complist);
286 >                complist = NULL;
287 >                complen = 0;
288 >        }
289 >                                        /* drop satisfied requests */
290 >        for (i = complen; i-- && complist[i].nr <=
291 >                        bnrays(hdlist[complist[i].hd],complist[i].bi); )
292 >                ;
293 >        if (i < complen-1) {
294 >                list2 = (PACKHEAD *)realloc((char *)complist,
295 >                                (i+1)*sizeof(PACKHEAD));
296 >                if (list2 != NULL) {
297 >                        complist = list2;
298 >                        complen = i+1;
299 >                }
300 >        }
301 >        listpos = 0; lastin = i;
302   }
303  
304  

Diff Legend

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