| 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 |
|
|
| 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) |
| 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 |
|
|
| 254 |
|
bool |
| 255 |
|
RtraceSimulManager::UpdateMode() |
| 256 |
|
{ |
| 282 |
– |
rtFlags &= RTmask; |
| 257 |
|
if (!cookedCall) |
| 258 |
|
rtFlags &= ~RTdoFIFO; |
| 259 |
|
if (!traceCall) |
| 261 |
|
if (rtFlags & RTimmIrrad) |
| 262 |
|
rtFlags &= ~RTlimDist; |
| 263 |
|
|
| 264 |
< |
int misMatch = rtFlags ^ curFlags; |
| 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); |
| 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; |
| 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); |
| 354 |
|
int nqueued = 0; |
| 355 |
|
RAY res; |
| 356 |
|
|
| 357 |
< |
if (!Ready()) |
| 371 |
< |
return -1; |
| 357 |
> |
if (!Ready()) return -1; |
| 358 |
|
|
| 359 |
|
if (castonly && !cookedCall) |
| 360 |
|
error(INTERNAL, "EnqueueBundle() called in castonly mode without cookedCall"); |
| 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; |
