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

Comparing ray/src/rt/RtraceSimulManager.cpp (file contents):
Revision 2.20 by greg, Thu Nov 7 18:37:11 2024 UTC vs.
Revision 2.24 by greg, Wed Nov 20 17:46:25 2024 UTC

# Line 181 | Line 181 | RadSimulManager::GetNCores()
181   int
182   RadSimulManager::SetThreadCount(int nt)
183   {
184 <        if (!Ready())
185 <                return 0;
184 >        if (!Ready()) return 0;
185  
186          if (nt <= 0) nt = castonly ? 1 : GetNCores();
187  
# Line 196 | Line 195 | RadSimulManager::SetThreadCount(int nt)
195          return NThreads();
196   }
197  
199 – // Assign ray to subthread (fails if NThreads()<2)
200 – bool
201 – RadSimulManager::SplitRay(RAY *r)
202 – {
203 –        if (!ray_pnprocs || ThreadsAvailable() < 1)
204 –                return false;
205 –
206 –        return (ray_psend(r) > 0);
207 – }
208 –
198   // Process a ray (in subthread), optional result
199 < bool
199 > int
200   RadSimulManager::ProcessRay(RAY *r)
201   {
202 <        if (!Ready()) return false;
202 >        if (!Ready()) return -1;
203  
204          if (!ray_pnprocs) {     // single-threaded mode?
205                  samplendx++;
206                  rayvalue(r);
207 <                return true;
207 >                return 1;
208          }
209 <        int     rv = ray_pqueue(r);
221 <        if (rv < 0) {
222 <                error(WARNING, "ray tracing process(es) died");
223 <                return false;
224 <        }
225 <        return (rv > 0);
209 >        return ray_pqueue(r);
210   }
211  
212   // Wait for next result (or fail)
# Line 249 | Line 233 | RadSimulManager::Cleanup(bool everything)
233          return 0;
234   }
235  
252 – // How many threads are currently unoccupied?
253 – int
254 – RadSimulManager::ThreadsAvailable() const
255 – {
256 –        if (!ray_pnprocs) return 1;
257 –
258 –        return ray_pnidle;
259 – }
260 –
236   // Global pointer to simulation manager for trace call-back (only one)
237   static const RtraceSimulManager *       ourRTsimMan = NULL;
238  
# Line 288 | Line 263 | RtraceSimulManager::UpdateMode()
263  
264          int     misMatch = (rtFlags ^ curFlags) & RTmask;
265                                  // updates based on toggled flags
266 <        if (misMatch & RTtraceSources) {
266 >        if (((misMatch & RTtraceSources) != 0) & (nsources > 0)) {
267 >                int     nt = NThreads();
268 >                if (nt > 1) {
269 >                        if (FlushQueue() < 0)
270 >                                return false;
271 >                        SetThreadCount(1);
272 >                }
273                  int     sn = nsources;
274                  if (rtFlags & RTtraceSources) {
275                          srcFollowed.NewBitMap(nsources);
# Line 304 | Line 285 | RtraceSimulManager::UpdateMode()
285                                          source[sn].sflags &= ~SFOLLOW;
286                          srcFollowed.NewBitMap(0);
287                  }
288 +                if (nt > 1) SetThreadCount(nt);
289          }
290          if (misMatch & RTdoFIFO && FlushQueue() < 0)
291                  return false;
# Line 333 | Line 315 | extern "C" int m_normal(OBJREC *m, RAY *r);
315   static void
316   rayirrad(RAY *r)
317   {
318 <                                        /* pretend we hit surface */
319 <        r->rxt = r->rot = 1e-5;
320 <        VSUM(r->rop, r->rorg, r->rdir, r->rot);
321 <        r->ron[0] = -r->rdir[0];
322 <        r->ron[1] = -r->rdir[1];
323 <        r->ron[2] = -r->rdir[2];
318 >                                        /* orientation -> normal */
319 >        VCOPY(r->ron, r->rdir);
320 >                                        /* pretend normal incidence */
321 >        r->rdir[0] = -r->ron[0];
322 >        r->rdir[1] = -r->ron[1];
323 >        r->rdir[2] = -r->ron[2];
324          r->rod = 1.0;
325 +                                        /* counterfeit other params */
326 +        r->rxt = r->rot = 1e-4;
327 +                                        /* move comfortably above sample pos. */
328 +        VSUM(r->rop, r->rorg, r->ron, r->rot);
329 +                                        /* leap-frog for pretend origin */
330 +        VSUM(r->rorg, r->rop, r->ron, r->rot);
331                                          /* compute result */
332          r->revf = raytrace;
333          m_normal(&Lamb, r);
# Line 366 | Line 354 | RtraceSimulManager::EnqueueBundle(const FVECT orig_dir
354          int     nqueued = 0;
355          RAY     res;
356  
357 <        if (!Ready())
370 <                return -1;
357 >        if (!Ready()) return -1;
358  
359          if (castonly && !cookedCall)
360                  error(INTERNAL, "EnqueueBundle() called in castonly mode without cookedCall");
# Line 398 | Line 385 | RtraceSimulManager::EnqueueBundle(const FVECT orig_dir
385                                  if (ray_fifo_in(&res) < 0)
386                                          return -1;
387                                  sendRes = false;
388 <                        } else
389 <                                sendRes &= ProcessRay(&res);
388 >                        } else {
389 >                                int     rv = ProcessRay(&res);
390 >                                if (rv < 0)
391 >                                        return -1;
392 >                                sendRes &= (rv > 0);
393 >                        }
394                  } else if (ThreadsAvailable() < NThreads() &&
395                                  FlushQueue() < 0)
396                          return -1;

Diff Legend

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