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

Comparing ray/src/rt/pmapcontrib.c (file contents):
Revision 2.13 by greg, Thu Sep 29 21:51:58 2016 UTC vs.
Revision 2.20 by greg, Tue Feb 16 20:06:06 2021 UTC

# Line 4 | Line 4 | static const char RCSid[] = "$Id$";
4  
5   /*
6     ======================================================================
7 <   Photon map support for building light source contributions
7 >   Photon map for light source contributions
8  
9     Roland Schregle (roland.schregle@{hslu.ch, gmail.com})
10     (c) Lucerne University of Applied Sciences and Arts,
# Line 23 | Line 23 | static const char RCSid[] = "$Id$";
23   #include "pmapdiag.h"
24   #include "rcontrib.h"
25   #include "otypes.h"
26 < #include <sys/mman.h>
27 < #include <sys/wait.h>
26 > #include "otspecial.h"
27 > #if NIX
28 >   #include <sys/mman.h>
29 >   #include <sys/wait.h>  
30 > #endif
31  
32  
30 –
33   static PhotonPrimaryIdx newPhotonPrimary (PhotonMap *pmap,
34                                            const RAY *primRay,
35                                            FILE *primHeap)
# Line 42 | Line 44 | static PhotonPrimaryIdx newPhotonPrimary (PhotonMap *p
44        return 0;
45        
46     /* Check if last primary ray has spawned photons (srcIdx >= 0, see
47 <    * newPhoton()), in which case we write it to the primary heap file
48 <    * before overwriting it */
47 >    * newPhoton()), in which case we save it to the primary heap file
48 >    * before clobbering it */
49     if (pmap -> lastPrimary.srcIdx >= 0) {
50        if (!fwrite(&pmap -> lastPrimary, sizeof(PhotonPrimary), 1, primHeap))
51           error(SYSTEM, "failed writing photon primary in newPhotonPrimary");
# Line 59 | Line 61 | static PhotonPrimaryIdx newPhotonPrimary (PhotonMap *p
61      
62     if (primRay) {
63        FVECT dvec;
64 <      
64 >
65 > #ifdef PMAP_PRIMARYDIR            
66        /* Reverse incident direction to point to light source */
67        dvec [0] = -primRay -> rdir [0];
68        dvec [1] = -primRay -> rdir [1];
69        dvec [2] = -primRay -> rdir [2];
70        pmap -> lastPrimary.dir = encodedir(dvec);
71 + #endif      
72   #ifdef PMAP_PRIMARYPOS      
73        VCOPY(pmap -> lastPrimary.pos, primRay -> rop);
74   #endif      
# Line 75 | Line 79 | static PhotonPrimaryIdx newPhotonPrimary (PhotonMap *p
79  
80  
81  
82 < #ifdef DEBUG_PMAP_CONTRIB
82 > #ifdef DEBUG_PMAP
83   static int checkPrimaryHeap (FILE *file)
84   /* Check heap for ordered primaries */
85   {
# Line 115 | Line 119 | static int checkPrimaryHeap (FILE *file)
119  
120  
121   static PhotonPrimaryIdx buildPrimaries (PhotonMap *pmap, FILE **primaryHeap,
122 +                                        char **primaryHeapFname,
123                                          PhotonPrimaryIdx *primaryOfs,
124                                          unsigned numHeaps)
125   /* Consolidate per-subprocess photon primary heaps into the primary array
# Line 132 | Line 137 | static PhotonPrimaryIdx buildPrimaries (PhotonMap *pma
137     for (heap = 0; heap < numHeaps; heap++) {
138        primaryOfs [heap] = pmap -> numPrimary;
139        
140 <      if (fseek(primaryHeap [heap], 0, SEEK_END))
140 >      if (fseek(primaryHeap [heap], 0, SEEK_END) < 0)
141           error(SYSTEM, "failed photon primary seek in buildPrimaries");
142        pmap -> numPrimary += heapLen = ftell(primaryHeap [heap]) /
143                                        sizeof(PhotonPrimary);      
# Line 148 | Line 153 | static PhotonPrimaryIdx buildPrimaries (PhotonMap *pma
153                  heapLen, primaryHeap [heap]) != heapLen)
154           error(SYSTEM, "failed reading photon primaries in buildPrimaries");
155        
156 <      fclose(primaryHeap [heap]);      
156 >      fclose(primaryHeap [heap]);
157 >      unlink(primaryHeapFname [heap]);
158     }
159    
160     return pmap -> numPrimary;
# Line 167 | Line 173 | typedef  unsigned long  PhotonContribCnt;
173  
174  
175  
176 +
177 +
178 +
179   void distribPhotonContrib (PhotonMap* pm, unsigned numProc)
180   {
181     EmissionMap       emap;
182 <   char              errmsg2 [128], shmFname [255];
182 >   char              errmsg2 [128], shmFname [PMAP_TMPFNLEN];
183     unsigned          srcIdx, proc;
184     int               shmFile, stat, pid;
185     double            *srcFlux,         /* Emitted flux per light source */
186                       srcDistribTarget; /* Target photon count per source */
187     PhotonContribCnt  *photonCnt;       /* Photon emission counter array */
188 <   const unsigned    photonCntSize = sizeof(PhotonContribCnt) *
188 >   unsigned          photonCntSize = sizeof(PhotonContribCnt) *
189                                       PHOTONCNT_NUMEMIT(nsources);
190 <   FILE              *primaryHeap [numProc];
191 <   PhotonPrimaryIdx  primaryOfs [numProc];
190 >   FILE              **primaryHeap = NULL;
191 >   char              **primaryHeapFname = NULL;
192 >   PhotonPrimaryIdx  *primaryOfs = NULL;
193                                      
194     if (!pm)
195        error(USER, "no photon map defined in distribPhotonContrib");
# Line 187 | Line 197 | void distribPhotonContrib (PhotonMap* pm, unsigned num
197     if (!nsources)
198        error(USER, "no light sources in distribPhotonContrib");
199  
190 –   if (nsources > MAXMODLIST)
191 –      error(USER, "too many light sources in distribPhotonContrib");
192 –      
200     /* Allocate photon flux per light source; this differs for every
201      * source as all sources contribute the same number of distributed
202      * photons (srcDistribTarget), hence the number of photons emitted per
# Line 216 | Line 223 | void distribPhotonContrib (PhotonMap* pm, unsigned num
223    
224     /* Per-subprocess / per-source target counts */
225     pm -> distribTarget /= numProc;
226 <   srcDistribTarget = nsources ? (double)pm -> distribTarget / nsources : 0;
226 >   srcDistribTarget = nsources ? (double)pm -> distribTarget / nsources : 0;  
227    
228 <   /* Get photon ports if specified */
229 <   if (ambincl == 1)
230 <      getPhotonPorts();
228 >   if (!pm -> distribTarget)
229 >      error(INTERNAL, "no photons to distribute in distribPhotonContrib");
230 >  
231 >   /* Get photon ports from modifier list */
232 >   getPhotonPorts(photonPortList);
233        
234     /* Get photon sensor modifiers */
235     getPhotonSensors(photonSensorList);      
236 <  
236 >
237 > #if NIX  
238     /* Set up shared mem for photon counters (zeroed by ftruncate) */
239 < #if 0  
230 <   snprintf(shmFname, 255, PMAP_SHMFNAME, getpid());
231 <   shmFile = shm_open(shmFname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
232 < #else
233 <   strcpy(shmFname, PMAP_SHMFNAME);
239 >   strcpy(shmFname, PMAP_TMPFNAME);
240     shmFile = mkstemp(shmFname);
235 – #endif        
241    
242     if (shmFile < 0 || ftruncate(shmFile, photonCntSize) < 0)
243        error(SYSTEM, "failed shared mem init in distribPhotonContrib");
# Line 242 | Line 247 | void distribPhotonContrib (PhotonMap* pm, unsigned num
247                      
248     if (photonCnt == MAP_FAILED)
249        error(SYSTEM, "failed shared mem mapping in distribPhotonContrib");
250 + #else
251 +   /* Allocate photon counters statically on Windoze */
252 +   if (!(photonCnt = malloc(photonCntSize)))
253 +      error(SYSTEM, "failed trivial malloc in distribPhotonContrib");
254 +  
255 +   for (srcIdx = 0; srcIdx < PHOTONCNT_NUMEMIT(nsources); srcIdx++)
256 +      photonCnt [srcIdx] = 0;
257 + #endif /* NIX */
258  
259 +   if (verbose) {
260 +      sprintf(errmsg, "\nIntegrating flux from %d sources", nsources);
261 +
262 +      if (photonPorts) {
263 +         sprintf(errmsg2, " via %d ports", numPhotonPorts);
264 +         strcat(errmsg, errmsg2);
265 +      }
266 +
267 +      strcat(errmsg, "\n");
268 +      eputs(errmsg);
269 +   }
270 +
271     /* =============================================================
272 <    * FLUX INTEGRATION - Get total flux emitted from light source
272 >    * FLUX INTEGRATION - Get total flux emitted from sources/ports
273      * ============================================================= */  
274     for (srcIdx = 0; srcIdx < nsources; srcIdx++) {
275 <      unsigned portCnt = 0;
251 <      
275 >      unsigned portCnt = 0;      
276        srcFlux [srcIdx] = 0;
277        emap.src = source + srcIdx;
278        
255 –      if (photonRepTime)
256 –         eputs("\n");
257 –
279        do {  /* Need at least one iteration if no ports! */      
280           emap.port = emap.src -> sflags & SDISTANT ? photonPorts + portCnt
281                                                     : NULL;
282           photonPartition [emap.src -> so -> otype] (&emap);
283 <        
284 <         if (photonRepTime) {
285 <            sprintf(errmsg, "Integrating flux from source %s (mod %s) ",
286 <                    source [srcIdx].so -> oname,
287 <                    objptr(source [srcIdx].so -> omod) -> oname);
267 <                    
283 >
284 >         if (verbose) {
285 >            sprintf(errmsg, "\tIntegrating flux from source %s ",
286 >                    source [srcIdx].so -> oname);
287 >
288              if (emap.port) {
289                 sprintf(errmsg2, "via port %s ",
290                         photonPorts [portCnt].so -> oname);
291                 strcat(errmsg, errmsg2);
292              }
293 <            
294 <            sprintf(errmsg2, "(%lu partitions)...\n", emap.numPartitions);
293 >
294 >            sprintf(errmsg2, "(%lu partitions)\n", emap.numPartitions);
295              strcat(errmsg, errmsg2);
296              eputs(errmsg);
297 + #if NIX            
298              fflush(stderr);
299 <         }
299 > #endif            
300 >         }                    
301          
302           for (emap.partitionCnt = 0; emap.partitionCnt < emap.numPartitions;
303                emap.partitionCnt++) {
# Line 292 | Line 314 | void distribPhotonContrib (PhotonMap* pm, unsigned num
314           error(WARNING, errmsg);
315        }
316     }  
317 <
318 <   if (photonRepTime)
319 <      eputs("\n");
320 <
321 <   /* Init per-subprocess primary heap files */
322 <   for (proc = 0; proc < numProc; proc++)
323 <      if (!(primaryHeap [proc] = tmpfile()))
317 >  
318 >   /* Allocate & init per-subprocess primary heap files */
319 >   primaryHeap = calloc(numProc, sizeof(FILE*));
320 >   primaryHeapFname = calloc(numProc, sizeof(char*));
321 >   primaryOfs = calloc(numProc, sizeof(PhotonPrimaryIdx));
322 >   if (!primaryHeap || !primaryHeapFname || !primaryOfs)
323 >      error(SYSTEM, "failed primary heap allocation in "
324 >            "distribPhotonContrib");
325 >      
326 >   for (proc = 0; proc < numProc; proc++) {
327 >      primaryHeapFname [proc] = malloc(PMAP_TMPFNLEN);
328 >      if (!primaryHeapFname [proc])
329 >         error(SYSTEM, "failed primary heap file allocation in "
330 >               "distribPhotonContrib");
331 >              
332 >      mktemp(strcpy(primaryHeapFname [proc], PMAP_TMPFNAME));
333 >      if (!(primaryHeap [proc] = fopen(primaryHeapFname [proc], "w+b")))
334           error(SYSTEM, "failed opening primary heap file in "
335                 "distribPhotonContrib");
336 +   }              
337 +
338 +   /* Record start time for progress reports */
339 +   repStartTime = time(NULL);
340 +
341 +   if (verbose) {
342 +      sprintf(errmsg, "\nPhoton distribution @ %d procs\n", numProc);
343 +      eputs(errmsg);
344 +   }
345                
346     /* MAIN LOOP */
347     for (proc = 0; proc < numProc; proc++) {
348 + #if NIX          
349        if (!(pid = fork())) {
350 <         /* SUBPROCESS ENTERS HERE;
351 <          * all opened and memory mapped files are inherited */
352 <          
350 >         /* SUBPROCESS ENTERS HERE; opened and mmapped files inherited */
351 > #else
352 >      if (1) {
353 >         /* No subprocess under Windoze */
354 > #endif  
355           /* Local photon counters for this subprocess */
356           unsigned long  lastNumPhotons = 0, localNumEmitted = 0;
357 <         double         photonFluxSum = 0;   /* Running photon flux sum */
357 >         double         photonFluxSum = 0;   /* Accum. photon flux */
358  
359           /* Seed RNGs from PID for decorellated photon distribution */
360           pmapSeed(randSeed + proc, partState);
361 <         pmapSeed(randSeed + proc, emitState);
362 <         pmapSeed(randSeed + proc, cntState);
363 <         pmapSeed(randSeed + proc, mediumState);
364 <         pmapSeed(randSeed + proc, scatterState);
365 <         pmapSeed(randSeed + proc, rouletteState);
361 >         pmapSeed(randSeed + (proc + 1) % numProc, emitState);
362 >         pmapSeed(randSeed + (proc + 2) % numProc, cntState);
363 >         pmapSeed(randSeed + (proc + 3) % numProc, mediumState);
364 >         pmapSeed(randSeed + (proc + 4) % numProc, scatterState);
365 >         pmapSeed(randSeed + (proc + 5) % numProc, rouletteState);
366 >
367 > #ifdef PMAP_SIGUSR                      
368 >   double partNumEmit;
369 >   unsigned long partEmitCnt;
370 >   double srcPhotonFlux, avgPhotonFlux;
371 >   unsigned       portCnt, passCnt, prePassCnt;
372 >   float          srcPreDistrib;
373 >   double         srcNumEmit;     /* # to emit from source */
374 >   unsigned long  srcNumDistrib;  /* # stored */
375 >
376 >   void sigUsrDiags()
377 >   /* Loop diags via SIGUSR1 */
378 >   {
379 >      sprintf(errmsg,
380 >              "********************* Proc %d Diags *********************\n"
381 >              "srcIdx = %d (%s)\nportCnt = %d (%s)\npassCnt = %d\n"
382 >              "srcFlux = %f\nsrcPhotonFlux = %f\navgPhotonFlux = %f\n"
383 >              "partNumEmit = %f\npartEmitCnt = %lu\n\n",
384 >              proc, srcIdx, findmaterial(source [srcIdx].so) -> oname,
385 >              portCnt, photonPorts [portCnt].so -> oname,
386 >              passCnt, srcFlux [srcIdx], srcPhotonFlux, avgPhotonFlux,
387 >              partNumEmit, partEmitCnt);
388 >      eputs(errmsg);
389 >      fflush(stderr);
390 >   }
391 > #endif
392          
393 + #ifdef PMAP_SIGUSR
394 +         signal(SIGUSR1, sigUsrDiags);
395 + #endif        
396 +
397 + #ifdef DEBUG_PMAP          
398 +         /* Output child process PID after random delay to prevent corrupted
399 +          * console output due to race condition */
400 +         usleep(1e6 * pmapRandom(rouletteState));
401 +         fprintf(stderr, "Proc %d: PID = %d "
402 +                 "(waiting 10 sec to attach debugger...)\n",
403 +                 proc, getpid());
404 +         /* Allow time for debugger to attach to child process */
405 +         sleep(10);
406 + #endif
407 +
408           /* =============================================================
409            * 2-PASS PHOTON DISTRIBUTION
410            * Pass 1 (pre):  emit fraction of target photon count
411            * Pass 2 (main): based on outcome of pass 1, estimate remaining
412            *                number of photons to emit to approximate target
413            *                count
414 <          * ============================================================= */        
414 >          * ============================================================= */
415           for (srcIdx = 0; srcIdx < nsources; srcIdx++) {
416 + #ifndef PMAP_SIGUSR        
417              unsigned       portCnt, passCnt = 0, prePassCnt = 0;
418              float          srcPreDistrib = preDistrib;
419              double         srcNumEmit = 0;       /* # to emit from source */
420              unsigned long  srcNumDistrib = pm -> numPhotons;  /* # stored */
421 + #else
422 +            passCnt = prePassCnt = 0;
423 +            srcPreDistrib = preDistrib;
424 +            srcNumEmit = 0;       /* # to emit from source */
425 +            srcNumDistrib = pm -> numPhotons;  /* # stored */
426 + #endif            
427  
428              if (srcFlux [srcIdx] < FTINY)
429                 continue;
# Line 341 | Line 433 | void distribPhotonContrib (PhotonMap* pm, unsigned num
433                    /* INIT PASS 1 */
434                    if (++prePassCnt > maxPreDistrib) {
435                       /* Warn if no photons contributed after sufficient
436 <                      * iterations */
437 <                     sprintf(errmsg, "proc %d, source %s: "
438 <                             "too many prepasses, skipped",
439 <                             proc, source [srcIdx].so -> oname);
440 <                     error(WARNING, errmsg);
436 >                      * iterations; only output from subprocess 0 to reduce
437 >                      * console clutter */
438 >                     if (!proc) {
439 >                        sprintf(errmsg,
440 >                                "source %s: too many prepasses, skipped",
441 >                                source [srcIdx].so -> oname);
442 >                        error(WARNING, errmsg);
443 >                     }
444 >
445                       break;
446                    }
447                    
# Line 354 | Line 450 | void distribPhotonContrib (PhotonMap* pm, unsigned num
450                 }
451                 else {
452                    /* INIT PASS 2 */
453 + #ifndef PMAP_SIGUSR
454                    double srcPhotonFlux, avgPhotonFlux;
455 + #endif
456                    
457                    /* Based on the outcome of the predistribution we can now
458                     * figure out how many more photons we have to emit from
# Line 376 | Line 474 | void distribPhotonContrib (PhotonMap* pm, unsigned num
474                    srcPhotonFlux = srcFlux [srcIdx] / srcNumEmit;
475                    avgPhotonFlux = photonFluxSum / (srcIdx + 1);
476                    
477 <                  if (avgPhotonFlux > 0 &&
477 >                  if (avgPhotonFlux > FTINY &&
478                        srcPhotonFlux / avgPhotonFlux < FTINY) {
479                       /* Skip source if its photon flux is grossly below the
480 <                      * running average, indicating negligible contribs at
481 <                      * the expense of excessive distribution time */
482 <                     sprintf(errmsg, "proc %d, source %s: "
483 <                             "itsy bitsy photon flux, skipped",
484 <                             proc, source [srcIdx].so -> oname);
485 <                     error(WARNING, errmsg);
486 <                     srcNumEmit = 0;
480 >                      * running average, indicating negligible contributions
481 >                      * at the expense of excessive distribution time; only
482 >                      * output from subproc 0 to reduce console clutter */
483 >                     if (!proc) {
484 >                        sprintf(errmsg,
485 >                                "source %s: itsy bitsy photon flux, skipped",
486 >                                source [srcIdx].so -> oname);                    
487 >                        error(WARNING, errmsg);
488 >                     }
489 >
490 >                     srcNumEmit = 0;   /* Or just break??? */
491                    }
492                          
493                    /* Update sum of photon flux per light source */
494                    photonFluxSum += srcPhotonFlux;
495                 }
496 <              
496 >                              
497                 portCnt = 0;
498                 do {    /* Need at least one iteration if no ports! */
499                    emap.src = source + srcIdx;
500                    emap.port = emap.src -> sflags & SDISTANT
501                                ? photonPorts + portCnt : NULL;
502                    photonPartition [emap.src -> so -> otype] (&emap);
503 <                  
504 <                  if (photonRepTime && !proc) {
503 >
504 >                  if (verbose && !proc) {
505 >                     /* Output from subproc 0 only to avoid race condition
506 >                      * on console I/O */
507                       if (!passCnt)
508 <                        sprintf(errmsg, "PREPASS %d on source %s (mod %s) ",
509 <                                prePassCnt, source [srcIdx].so -> oname,
406 <                                objptr(source[srcIdx].so->omod) -> oname);
508 >                        sprintf(errmsg, "\tPREPASS %d on source %s ",
509 >                                prePassCnt, source [srcIdx].so -> oname);
510                       else
511 <                        sprintf(errmsg, "MAIN PASS on source %s (mod %s) ",
512 <                                source [srcIdx].so -> oname,
513 <                                objptr(source[srcIdx].so->omod) -> oname);
411 <                            
511 >                        sprintf(errmsg, "\tMAIN PASS on source %s ",
512 >                                source [srcIdx].so -> oname);
513 >
514                       if (emap.port) {
515                          sprintf(errmsg2, "via port %s ",
516                                  photonPorts [portCnt].so -> oname);
517                          strcat(errmsg, errmsg2);
518                       }
519 <                    
519 >
520                       sprintf(errmsg2, "(%lu partitions)\n",
521                               emap.numPartitions);
522 <                     strcat(errmsg, errmsg2);
522 >                     strcat(errmsg, errmsg2);                    
523                       eputs(errmsg);
524 + #if NIX                    
525                       fflush(stderr);
526 <                  }
526 > #endif                    
527 >                  }                
528                    
529                    for (emap.partitionCnt = 0; emap.partitionCnt < emap.numPartitions;
530                         emap.partitionCnt++) {
531 + #ifndef PMAP_SIGUSR                      
532                       double partNumEmit;
533                       unsigned long partEmitCnt;
534 + #endif
535                      
536                       /* Get photon origin within current source partishunn
537                        * and build emission map */
# Line 444 | Line 550 | void distribPhotonContrib (PhotonMap* pm, unsigned num
550                          partEmitCnt++;
551                          
552                       /* Update local and shared global emission counter */
447 –                     localNumEmitted += partEmitCnt;                                    
553                       photonCnt [PHOTONCNT_NUMEMIT(srcIdx)] += partEmitCnt;
554 +                     localNumEmitted += partEmitCnt;                                    
555                      
556 <                     /* Integer counter avoids FP rounding errors */
556 >                     /* Integer counter avoids FP rounding errors during
557 >                      * iteration */
558                       while (partEmitCnt--) {
559                          RAY photonRay;
560                      
# Line 456 | Line 563 | void distribPhotonContrib (PhotonMap* pm, unsigned num
563                           * until absorbed/leaked; emitPhoton() sets the
564                           * emitting light source index in photonRay */
565                          emitPhoton(&emap, &photonRay);
566 + #if 1
567 +                        if (emap.port)
568 +                           /* !!!  PHOTON PORT REJECTION SAMPLING HACK: set
569 +                            * !!!  photon port as fake hit object for
570 +                            * !!!  primary ray to check for intersection in
571 +                            * !!!  tracePhoton() */                        
572 +                           photonRay.ro = emap.port -> so;
573 + #endif
574                          newPhotonPrimary(pm, &photonRay, primaryHeap[proc]);
575                          /* Set subprocess index in photonRay for post-
576                           * distrib primary index linearisation; this is
# Line 469 | Line 584 | void distribPhotonContrib (PhotonMap* pm, unsigned num
584                       photonCnt [PHOTONCNT_NUMPHOT] += pm -> numPhotons -
585                                                        lastNumPhotons;
586                       lastNumPhotons = pm -> numPhotons;
587 + #if !NIX
588 +                     /* Synchronous progress report on Windoze */
589 +                     if (!proc && photonRepTime > 0 &&
590 +                           time(NULL) >= repLastTime + photonRepTime) {
591 +                        unsigned s;                        
592 +                        repComplete = pm -> distribTarget * numProc;
593 +                        repProgress = photonCnt [PHOTONCNT_NUMPHOT];
594 +                        
595 +                        for (repEmitted = 0, s = 0; s < nsources; s++)
596 +                           repEmitted += photonCnt [PHOTONCNT_NUMEMIT(s)];
597 +
598 +                        pmapDistribReport();
599 +                     }
600 + #endif
601                    }
602  
603                    portCnt++;
604                 } while (portCnt < numPhotonPorts);                  
605  
606 <               if (pm -> numPhotons == srcNumDistrib)
606 >               if (pm -> numPhotons == srcNumDistrib) {
607                    /* Double predistrib factor in case no photons were stored
608                     * for this source and redo pass 1 */
609                    srcPreDistrib *= 2;
610 +               }
611                 else {
612                    /* Now do pass 2 */
613                    passCnt++;
484 – /*                if (photonRepTime)
485 –                     eputs("\n"); */
614                 }
615              }
616           }
617                          
618           /* Flush heap buffa one final time to prevent data corruption */
619 <         flushPhotonHeap(pm);
492 <         fclose(pm -> heap);
493 <        
619 >         flushPhotonHeap(pm);        
620           /* Flush final photon primary to primary heap file */
621           newPhotonPrimary(pm, NULL, primaryHeap [proc]);
622 <         fclose(primaryHeap [proc]);
622 >         /* Heap files closed automatically on exit
623 >            fclose(pm -> heap);
624 >            fclose(primaryHeap [proc]); */
625                    
626   #ifdef DEBUG_PMAP
627 <         sprintf(errmsg, "Proc %d exited with total %ld photons\n", proc,
627 >         sprintf(errmsg, "Proc %d total %ld photons\n", proc,
628                   pm -> numPhotons);
629           eputs(errmsg);
630 +         fflush(stderr);
631   #endif
632  
633 + #ifdef PMAP_SIGUSR
634 +         signal(SIGUSR1, SIG_DFL);
635 + #endif
636 +
637 + #if NIX
638 +         /* Terminate subprocess */
639           exit(0);
640 + #endif
641        }
642        else if (pid < 0)
643           error(SYSTEM, "failed to fork subprocess in distribPhotonContrib");
644     }
645  
646 + #if NIX
647     /* PARENT PROCESS CONTINUES HERE */
511 –   /* Record start time and enable progress report signal handler */
512 –   repStartTime = time(NULL);
648   #ifdef SIGCONT
649 +   /* Enable progress report signal handler */
650     signal(SIGCONT, pmapDistribReport);
651   #endif
516 – /*
517 –   if (photonRepTime)
518 –      eputs("\n"); */
519 –  
652     /* Wait for subprocesses to complete while reporting progress */
653     proc = numProc;
654     while (proc) {
# Line 530 | Line 662 | void distribPhotonContrib (PhotonMap* pm, unsigned num
662        
663        /* Nod off for a bit and update progress  */
664        sleep(1);
665 <      
666 <      /* Update progress report from shared subprocess counters */
665 >
666 >      /* Asynchronous progress report from shared subprocess counters */      
667        repComplete = pm -> distribTarget * numProc;
668 <      repProgress = photonCnt [PHOTONCNT_NUMPHOT];
668 >      repProgress = photonCnt [PHOTONCNT_NUMPHOT];      
669 >      
670        for (repEmitted = 0, srcIdx = 0; srcIdx < nsources; srcIdx++)
671           repEmitted += photonCnt [PHOTONCNT_NUMEMIT(srcIdx)];
672  
# Line 546 | Line 679 | void distribPhotonContrib (PhotonMap* pm, unsigned num
679        else signal(SIGCONT, pmapDistribReport);
680   #endif
681     }
682 + #endif /* NIX */
683  
684     /* ================================================================
685      * POST-DISTRIBUTION - Set photon flux and build kd-tree, etc.
686      * ================================================================ */
687   #ifdef SIGCONT    
688 +   /* Reset signal handler */
689     signal(SIGCONT, SIG_DFL);
690   #endif  
691     free(emap.samples);
692  
693     if (!pm -> numPhotons)
694 <      error(USER, "empty photon map");
694 >      error(USER, "empty contribution photon map");
695  
696     /* Load per-subprocess primary rays into pm -> primary array */
697 <   pm -> numPrimary = buildPrimaries(pm, primaryHeap, primaryOfs, numProc);
697 >   /* Dumb compilers apparently need the char** cast */
698 >   pm -> numPrimary = buildPrimaries(pm, primaryHeap,
699 >                                     (char**)primaryHeapFname,
700 >                                     primaryOfs, numProc);
701     if (!pm -> numPrimary)
702        error(INTERNAL, "no primary rays in contribution photon map");
703    
704     /* Set photon flux per source */
705     for (srcIdx = 0; srcIdx < nsources; srcIdx++)
706        srcFlux [srcIdx] /= photonCnt [PHOTONCNT_NUMEMIT(srcIdx)];
707 <
707 > #if NIX
708     /* Photon counters no longer needed, unmap shared memory */
709     munmap(photonCnt, sizeof(*photonCnt));
710     close(shmFile);
573 – #if 0  
574 –   shm_unlink(shmFname);
575 – #else
711     unlink(shmFname);
712 + #else
713 +   free(photonCnt);  
714   #endif      
715    
716 <   if (photonRepTime) {
717 <      eputs("\nBuilding contrib photon map...\n");
716 >   if (verbose) {
717 >      eputs("\nBuilding contribution photon map...\n");
718 > #if NIX      
719        fflush(stderr);
720 + #endif      
721     }
722    
723     /* Build underlying data structure; heap is destroyed */
724 <   buildPhotonMap(pm, srcFlux, primaryOfs, numProc);  
724 >   buildPhotonMap(pm, srcFlux, primaryOfs, numProc);
725 >  
726 >   /* Free per-subprocess primary heap files */
727 >   for (proc = 0; proc < numProc; proc++)
728 >      free(primaryHeapFname [proc]);
729 >      
730 >   free(primaryHeapFname);
731 >   free(primaryHeap);
732 >   free(primaryOfs);
733 >  
734 >   if (verbose)
735 >      eputs("\n");
736   }

Diff Legend

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