ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rholo3.c
Revision: 3.20
Committed: Thu Jan 22 11:25:51 1998 UTC (26 years, 2 months ago) by gregl
Content type: text/plain
Branch: MAIN
Changes since 3.19: +40 -55 lines
Log Message:
made it so ^L does not require flushing of queue

File Contents

# Content
1 /* Copyright (c) 1998 Silicon Graphics, Inc. */
2
3 #ifndef lint
4 static char SCCSid[] = "$SunId$ SGI";
5 #endif
6
7 /*
8 * Routines for tracking beam compuatations
9 */
10
11 #include "rholo.h"
12
13 #define abs(x) ((x) > 0 ? (x) : -(x))
14 #define sgn(x) ((x) > 0 ? 1 : (x) < 0 ? -1 : 0)
15
16 static PACKHEAD *complist=NULL; /* list of beams to compute */
17 static int complen=0; /* length of complist */
18 static int listpos=0; /* current list position for next_packet */
19 static int lastin= -1; /* last ordered position in list */
20
21
22 int
23 beamcmp(b0, b1) /* comparison for descending compute order */
24 register PACKHEAD *b0, *b1;
25 {
26 return( b1->nr*(b0->nc+1) - b0->nr*(b1->nc+1) );
27 }
28
29
30 int
31 dispbeam(b, hp, bi) /* display a holodeck beam */
32 register BEAM *b;
33 HOLO *hp;
34 int bi;
35 {
36 static int n = 0;
37 static PACKHEAD *p = NULL;
38
39 if (b == NULL)
40 return;
41 if (b->nrm > n) { /* (re)allocate packet holder */
42 n = b->nrm;
43 if (p == NULL) p = (PACKHEAD *)malloc(packsiz(n));
44 else p = (PACKHEAD *)realloc((char *)p, packsiz(n));
45 if (p == NULL)
46 error(SYSTEM, "out of memory in dispbeam");
47 }
48 /* assign packet fields */
49 bcopy((char *)hdbray(b), (char *)packra(p), b->nrm*sizeof(RAYVAL));
50 p->nr = p->nc = b->nrm;
51 for (p->hd = 0; hdlist[p->hd] != hp; p->hd++)
52 if (hdlist[p->hd] == NULL)
53 error(CONSISTENCY, "unregistered holodeck in dispbeam");
54 p->bi = bi;
55 disp_packet(p); /* display it */
56 }
57
58
59 bundle_set(op, clist, nents) /* bundle set operation */
60 int op;
61 register PACKHEAD *clist;
62 int nents;
63 {
64 int oldnr;
65 register int i, n;
66 /* look for common members */
67 for (n = 0; n < nents; n++) {
68 for (i = 0; i < complen; i++)
69 if (clist[n].bi == complist[i].bi &&
70 clist[n].hd == complist[i].hd) {
71 oldnr = complist[i].nr;
72 clist[n].nc = complist[i].nc;
73 switch (op) {
74 case BS_ADD: /* add to count */
75 complist[i].nr += clist[n].nr;
76 clist[n].nr = 0;
77 break;
78 case BS_ADJ: /* reset count */
79 complist[i].nr = clist[n].nr;
80 clist[n].nr = 0;
81 break;
82 case BS_DEL: /* delete count */
83 if (clist[n].nr == 0 ||
84 clist[n].nr >= complist[i].nr)
85 complist[i].nr = 0;
86 else
87 complist[i].nr -= clist[n].nr;
88 break;
89 }
90 if (complist[i].nr != oldnr)
91 lastin = -1; /* flag sort */
92 break;
93 }
94 if (i >= complen)
95 clist[n].nc = bnrays(hdlist[clist[n].hd], clist[n].bi);
96 }
97 /* complete list operations */
98 switch (op) {
99 case BS_NEW: /* new computation set */
100 listpos = 0;
101 lastin = -1;
102 if (complen) /* free old list */
103 free((char *)complist);
104 complist = NULL;
105 if (!(complen = nents))
106 return;
107 complist = (PACKHEAD *)malloc(nents*sizeof(PACKHEAD));
108 if (complist == NULL)
109 goto memerr;
110 bcopy((char *)clist, (char *)complist, nents*sizeof(PACKHEAD));
111 break;
112 case BS_ADD: /* add to computation set */
113 case BS_ADJ: /* adjust set quantities */
114 if (nents <= 0)
115 return;
116 sortcomplist(); /* sort updated list & new entries */
117 qsort((char *)clist, nents, sizeof(PACKHEAD), beamcmp);
118 /* what can't we satisfy? */
119 for (n = 0; n < nents && clist[n].nr > clist[n].nc; n++)
120 ;
121 if (op == BS_ADJ)
122 nents = n;
123 if (n) { /* allocate space for merged list */
124 PACKHEAD *newlist;
125 newlist = (PACKHEAD *)malloc(
126 (complen+n)*sizeof(PACKHEAD) );
127 if (newlist == NULL)
128 goto memerr;
129 /* merge lists */
130 mergeclists(newlist, clist, n, complist, complen);
131 if (complen)
132 free((char *)complist);
133 complist = newlist;
134 complen += n;
135 }
136 listpos = 0;
137 lastin = complen-1; /* list is now sorted */
138 break;
139 case BS_DEL: /* delete from computation set */
140 return; /* already done */
141 default:
142 error(CONSISTENCY, "bundle_set called with unknown operation");
143 }
144 if (outdev != NULL) { /* load and display beams we have */
145 register HDBEAMI *hb;
146
147 hb = (HDBEAMI *)malloc(nents*sizeof(HDBEAMI));
148 for (i = 0; i < nents; i++) {
149 hb[i].h = hdlist[clist[i].hd];
150 hb[i].b = clist[i].bi;
151 }
152 hdloadbeams(hb, nents, dispbeam);
153 free((char *)hb);
154 }
155 return;
156 memerr:
157 error(SYSTEM, "out of memory in bundle_set");
158 }
159
160
161 double
162 beamvolume(hp, bi) /* compute approximate volume of a beam */
163 HOLO *hp;
164 int bi;
165 {
166 GCOORD gc[2];
167 FVECT cp[4], edgeA, edgeB, cent[2];
168 FVECT v, crossp[2], diffv;
169 double vol[2];
170 register int i;
171 /* get grid coordinates */
172 if (!hdbcoord(gc, hp, bi))
173 error(CONSISTENCY, "bad beam index in beamvolume");
174 for (i = 0; i < 2; i++) { /* compute cell area vectors */
175 hdcell(cp, hp, gc+i);
176 VSUM(edgeA, cp[1], cp[0], -1.0);
177 VSUM(edgeB, cp[3], cp[1], -1.0);
178 fcross(crossp[i], edgeA, edgeB);
179 /* compute center */
180 cent[i][0] = 0.5*(cp[0][0] + cp[2][0]);
181 cent[i][1] = 0.5*(cp[0][1] + cp[2][1]);
182 cent[i][2] = 0.5*(cp[0][2] + cp[2][2]);
183 }
184 /* compute difference vector */
185 VSUM(diffv, cent[1], cent[0], -1.0);
186 for (i = 0; i < 2; i++) { /* compute volume contributions */
187 vol[i] = 0.5*DOT(crossp[i], diffv);
188 if (vol[i] < 0.) vol[i] = -vol[i];
189 }
190 return(vol[0] + vol[1]); /* return total volume */
191 }
192
193
194 init_global() /* initialize global ray computation */
195 {
196 long wtotal = 0;
197 double frac;
198 int i;
199 register int j, k;
200 /* free old list and empty queue */
201 if (complen > 0) {
202 free((char *)complist);
203 done_packets(flush_queue());
204 }
205 /* allocate beam list */
206 complen = 0;
207 for (j = 0; hdlist[j] != NULL; j++)
208 complen += nbeams(hdlist[j]);
209 complist = (PACKHEAD *)malloc(complen*sizeof(PACKHEAD));
210 if (complist == NULL)
211 error(SYSTEM, "out of memory in init_global");
212 /* compute beam weights */
213 k = 0;
214 for (j = 0; hdlist[j] != NULL; j++) {
215 frac = 512. * VLEN(hdlist[j]->wg[0]) *
216 VLEN(hdlist[j]->wg[1]) *
217 VLEN(hdlist[j]->wg[2]);
218 for (i = nbeams(hdlist[j]); i > 0; i--) {
219 complist[k].hd = j;
220 complist[k].bi = i;
221 complist[k].nr = frac*beamvolume(hdlist[j], i) + 0.5;
222 complist[k].nc = bnrays(hdlist[j], i);
223 wtotal += complist[k++].nr;
224 }
225 }
226 /* adjust weights */
227 if (vdef(DISKSPACE))
228 frac = 1024.*1024.*vflt(DISKSPACE) / (wtotal*sizeof(RAYVAL));
229 else
230 frac = 1024.*1024.*16384. / (wtotal*sizeof(RAYVAL));
231 while (k--)
232 complist[k].nr = frac * complist[k].nr;
233 listpos = 0; lastin = -1; /* flag initial sort */
234 }
235
236
237 mergeclists(cdest, cl1, n1, cl2, n2) /* merge two sorted lists */
238 register PACKHEAD *cdest;
239 register PACKHEAD *cl1, *cl2;
240 int n1, n2;
241 {
242 register int cmp;
243
244 while (n1 | n2) {
245 if (!n1) cmp = 1;
246 else if (!n2) cmp = -1;
247 else cmp = beamcmp(cl1, cl2);
248 if (cmp > 0) {
249 copystruct(cdest, cl2);
250 cl2++; n2--;
251 } else {
252 copystruct(cdest, cl1);
253 cl1++; n1--;
254 }
255 cdest++;
256 }
257 }
258
259
260 sortcomplist() /* fix our list order */
261 {
262 PACKHEAD *list2;
263 register int i;
264
265 if (complen <= 0) /* check to see if there is even a list */
266 return;
267 if (lastin < 0 || listpos*4 >= complen*3)
268 qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
269 else if (listpos) { /* else sort and merge sublist */
270 list2 = (PACKHEAD *)malloc(listpos*sizeof(PACKHEAD));
271 if (list2 == NULL)
272 error(SYSTEM, "out of memory in sortcomplist");
273 bcopy((char *)complist,(char *)list2,listpos*sizeof(PACKHEAD));
274 qsort((char *)list2, listpos, sizeof(PACKHEAD), beamcmp);
275 mergeclists(complist, list2, listpos,
276 complist+listpos, complen-listpos);
277 free((char *)list2);
278 }
279 /* drop satisfied requests */
280 for (i = complen; i-- && complist[i].nr <= complist[i].nc; )
281 ;
282 if (i < 0) {
283 free((char *)complist);
284 complist = NULL;
285 complen = 0;
286 } else if (i < complen-1) {
287 list2 = (PACKHEAD *)realloc((char *)complist,
288 (i+1)*sizeof(PACKHEAD));
289 if (list2 != NULL) {
290 complist = list2;
291 complen = i+1;
292 }
293 }
294 listpos = 0; lastin = i;
295 }
296
297
298 /*
299 * The following routine works on the assumption that the bundle weights are
300 * more or less evenly distributed, such that computing a packet causes
301 * a given bundle to move way down in the computation order. We keep
302 * track of where the computed bundle with the highest priority would end
303 * up, and if we get further in our compute list than this, we resort the
304 * list and start again from the beginning. Since
305 * a merge sort is used, the sorting costs are minimal.
306 */
307 next_packet(p, n) /* prepare packet for computation */
308 register PACKET *p;
309 int n;
310 {
311 register int i;
312
313 if (listpos > lastin) /* time to sort the list */
314 sortcomplist();
315 if (complen <= 0)
316 return(0);
317 p->hd = complist[listpos].hd;
318 p->bi = complist[listpos].bi;
319 p->nc = complist[listpos].nc;
320 p->nr = complist[listpos].nr - p->nc;
321 if (p->nr <= 0)
322 return(0);
323 #ifdef DEBUG
324 if (n < 1 | n > RPACKSIZ)
325 error(CONSISTENCY, "next_packet called with bad n value");
326 #endif
327 if (p->nr > n)
328 p->nr = n;
329 complist[listpos].nc += p->nr; /* find where this one would go */
330 while (lastin > listpos &&
331 beamcmp(complist+lastin, complist+listpos) > 0)
332 lastin--;
333 listpos++;
334 return(1);
335 }