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

Comparing ray/src/hd/rhoptimize.c (file contents):
Revision 3.3 by gwlarson, Fri Nov 6 16:54:23 1998 UTC vs.
Revision 3.4 by gwlarson, Mon Nov 9 17:11:40 1998 UTC

# Line 18 | Line 18 | static char SCCSid[] = "$SunId$ SGI";
18   #define BKBSIZE         256             /* beam clump size (kilobytes) */
19   #endif
20  
21 #define flgop(p,i,op)           ((p)[(i)>>5] op (1L<<((i)&0x1f)))
22 #define isset(p,i)              flgop(p,i,&)
23 #define setfl(p,i)              flgop(p,i,|=)
24 #define clrfl(p,i)              flgop(p,i,&=~)
25
21   char    *progname;
22   char    tempfile[128];
23  
# Line 130 | Line 125 | char   *infn, *outfn;
125          fclose(infp);
126          if (fclose(outfp) == EOF)
127                  error(SYSTEM, "file flushing error in rhinitcopy");
128 <                                        /* flush everything manually hence */
129 <        hdcachesize = 0;
128 >                                        /* check cache size */
129 >        if (BKBSIZE*1024*1.5 > hdcachesize)
130 >                hdcachesize = BKBSIZE*1024*1.5;
131                                          /* return input position */
132          return(ifpos);
133   }
134  
135  
136 < gcshifti(gc, ia, di, hp)        /* shift cell row or column */
141 < register GCOORD *gc;
142 < int     ia, di;
143 < register HOLO   *hp;
144 < {
145 <        int     nw;
136 > static HOLO     *hout;          /* output holodeck section */
137  
138 <        if (di > 0) {
139 <                if (++gc->i[ia] >= hp->grid[((gc->w>>1)+1+ia)%3]) {
140 <                        nw = ((gc->w&~1) + (ia<<1) + 3) % 6;
141 <                        gc->i[ia] = gc->i[1-ia];
151 <                        gc->i[1-ia] = gc->w&1 ? hp->grid[((nw>>1)+2-ia)%3]-1 : 0;
152 <                        gc->w = nw;
153 <                }
154 <        } else if (di < 0) {
155 <                if (--gc->i[ia] < 0) {
156 <                        nw = ((gc->w&~1) + (ia<<1) + 2) % 6;
157 <                        gc->i[ia] = gc->i[1-ia];
158 <                        gc->i[1-ia] = gc->w&1 ? hp->grid[((nw>>1)+2-ia)%3]-1 : 0;
159 <                        gc->w = nw;
160 <                }
161 <        }
162 < }
163 <
164 <
165 < mkneighgrid(ng, hp, gc)         /* compute neighborhood for grid cell */
166 < GCOORD  ng[3*3];
167 < HOLO    *hp;
168 < GCOORD  *gc;
138 > static int
139 > xferbeam(bp, hb)                /* transfer the given beam to hout and free */
140 > register BEAM   *bp;
141 > HDBEAMI *hb;
142   {
143 <        GCOORD  gci0;
144 <        register int    i, j;
145 <
173 <        for (i = 3; i--; ) {
174 <                copystruct(&gci0, gc);
175 <                gcshifti(&gci0, 0, i-1, hp);
176 <                for (j = 3; j--; ) {
177 <                        copystruct(ng+(3*i+j), &gci0);
178 <                        gcshifti(ng+(3*i+j), gci0.w==gc->w, j-1, hp);
179 <                }
180 <        }
181 < }
182 <
183 <
184 < int     bneighlist[9*9-1];
185 < int     bneighrem;
186 <
187 < #define nextneigh()     (bneighrem<=0 ? 0 : bneighlist[--bneighrem])
188 <
189 < int
190 < firstneigh(hp, b)               /* initialize neighbor list and return first */
191 < HOLO    *hp;
192 < int     b;
193 < {
194 <        GCOORD  wg0[9], wg1[9], bgc[2];
195 <        int     i, j;
196 <
197 <        hdbcoord(bgc, hp, b);
198 <        mkneighgrid(wg0, hp, bgc);
199 <        mkneighgrid(wg1, hp, bgc+1);
200 <        bneighrem = 0;
201 <        for (i = 9; i--; )
202 <                for (j = 9; j--; ) {
203 <                        if (i == 4 & j == 4)    /* don't copy starting beam */
204 <                                continue;
205 <                        if (wg0[i].w == wg1[j].w)
206 <                                continue;
207 <                        copystruct(bgc, wg0+i);
208 <                        copystruct(bgc+1, wg1+j);
209 <                        bneighlist[bneighrem++] = hdbindex(hp, bgc);
210 < #ifdef DEBUG
211 <                        if (bneighlist[bneighrem-1] <= 0)
212 <                                error(CONSISTENCY, "bad beam in firstneigh");
213 < #endif
214 <                }
215 <        return(nextneigh());
216 < }
217 <
218 <
219 < BEAMI   *beamdir;
220 <
221 < int
222 < bpcmp(b1p, b2p)                 /* compare beam positions on disk */
223 < int     *b1p, *b2p;
224 < {
225 <        register long   pdif = beamdir[*b1p].fo - beamdir[*b2p].fo;
226 <
227 <        if (pdif > 0L) return(1);
228 <        if (pdif < 0L) return(-1);
143 >        bcopy((char *)hdbray(bp), (char *)hdnewrays(hout,hb->b,bp->nrm),
144 >                        bp->nrm*sizeof(RAYVAL));
145 >        hdfreebeam(hb->h, hb->b);
146          return(0);
147   }
148  
232
149   copysect(ifd, ofd)              /* copy holodeck section from ifd to ofd */
150   int     ifd, ofd;
151   {
152 <        static short    primes[] = {9431,6803,4177,2659,1609,887,587,251,47,1};
237 <        register HOLO   *hinp;
238 <        HOLO    *hout;
239 <        register BEAM   *bp;
240 <        unsigned int4   *bflags;
241 <        int     *bqueue;
242 <        int     bqlen;
243 <        int4    bqtotal;
244 <        int     bc, bci, bqc, myprime;
245 <        register int    i;
152 >        HOLO    *hinp;
153                                          /* load input section directory */
154          hinp = hdinit(ifd, NULL);
155                                          /* create output section directory */
156          hout = hdinit(ofd, (HDGRID *)hinp);
157 <                                        /* allocate beam queue */
158 <        bqueue = (int *)malloc(nbeams(hinp)*sizeof(int));
159 <        bflags = (unsigned int4 *)calloc((nbeams(hinp)>>5)+1,
253 <                        sizeof(unsigned int4));
254 <        if (bqueue == NULL | bflags == NULL)
255 <                error(SYSTEM, "out of memory in copysect");
256 <                                        /* mark empty beams as done */
257 <        for (i = nbeams(hinp); i > 0; i--)
258 <                if (!hinp->bi[i].nrd)
259 <                        setfl(bflags, i);
260 <                                        /* pick a good prime step size */
261 <        for (i = 0; primes[i]<<5 >= nbeams(hinp); i++)
262 <                ;
263 <        while ((myprime = primes[i++]) > 1)
264 <                if (nbeams(hinp) % myprime)
265 <                        break;
266 <                                        /* add each input beam and neighbors */
267 <        for (bc = bci = nbeams(hinp); bc > 0; bc--,
268 <                        bci += bci>myprime ? -myprime : nbeams(hinp)-myprime) {
269 <                if (isset(bflags, bci))
270 <                        continue;
271 <                bqueue[0] = bci;                /* initialize queue */
272 <                bqlen = 1;
273 <                bqtotal = hinp->bi[bci].nrd;
274 <                setfl(bflags, bci);
275 <                                                /* run through growing queue */
276 <                for (bqc = 0; bqc < bqlen; bqc++) {
277 <                                                /* add neighbors until full */
278 <                        for (i = firstneigh(hinp,bqueue[bqc]); i > 0;
279 <                                        i = nextneigh()) {
280 <                                if (isset(bflags, i))   /* done already? */
281 <                                        continue;
282 <                                bqueue[bqlen++] = i;    /* add it */
283 <                                bqtotal += hinp->bi[i].nrd;
284 <                                setfl(bflags, i);
285 <                                if (bqtotal >= BKBSIZE*1024/sizeof(RAYVAL))
286 <                                        break;          /* queue full */
287 <                        }
288 <                        if (i > 0)
289 <                                break;
290 <                }
291 <                beamdir = hinp->bi;             /* sort queue */
292 <                qsort((char *)bqueue, bqlen, sizeof(*bqueue), bpcmp);
293 <                                                /* transfer each beam */
294 <                for (i = 0; i < bqlen; i++) {
295 <                        bp = hdgetbeam(hinp, bqueue[i]);
296 <                        bcopy((char *)hdbray(bp),
297 <                                (char *)hdnewrays(hout,bqueue[i],bp->nrm),
298 <                                        bp->nrm*sizeof(RAYVAL));
299 <                        hdfreebeam(hinp, bqueue[i]);
300 <                }
301 <                hdfreebeam(hout, 0);            /* flush output block */
302 < #ifdef DEBUG
303 <                hdsync(hout, 0);
304 < #endif
305 <        }
306 <                                        /* we're done -- clean up */
307 <        free((char *)bqueue);
308 <        free((char *)bflags);
157 >                                        /* clump the beams */
158 >        clumpbeams(hinp, 0, BKBSIZE*1024, xferbeam);
159 >                                        /* clean up */
160          hddone(hinp);
161          hddone(hout);
162   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines