int main(void) { #pragma STDC FENV_ACCESS ON long long yi; int e, i, err = 0; struct f_i *p; for (i = 0; i < sizeof t/sizeof *t; i++) { p = t + i; if (p->r < 0) continue; fesetround(p->r); feclearexcept(FE_ALL_EXCEPT); yi = ___(p->x); e = fetestexcept(INEXACT|INVALID|DIVBYZERO|UNDERFLOW|OVERFLOW); if (!checkexcept(e, p->e, p->r)) { printf("%s:%d: bad fp exception: %s ___(%a)=%lld, want %s", p->file, p->line, rstr(p->r), p->x, p->i, estr(p->e)); printf(" got %s\n", estr(e)); err++; } if (yi != p->i) { printf("%s:%d: %s ___(%a) want %lld got %lld\n", p->file, p->line, rstr(p->r), p->x, p->i, yi); err++; } } return !!err; }
int main(void) { #pragma STDC FENV_ACCESS ON float y; float d; int e, i, err = 0; struct f_f *p; for (i = 0; i < sizeof t/sizeof *t; i++) { p = t + i; if (p->r < 0) continue; fesetround(p->r); feclearexcept(FE_ALL_EXCEPT); y = ___(p->x); e = fetestexcept(INEXACT|INVALID|DIVBYZERO|UNDERFLOW|OVERFLOW); if (!checkexcept(e, p->e, p->r)) { printf("%s:%d: bad fp exception: %s ___(%a)=%a, want %s", p->file, p->line, rstr(p->r), p->x, p->y, estr(p->e)); printf(" got %s\n", estr(e)); err++; } d = ulperrf(y, p->y, p->dy); if (!checkulp(d, p->r)) { printf("%s:%d: %s ___(%a) want %a got %a ulperr %.3f = %a + %a\n", p->file, p->line, rstr(p->r), p->x, p->y, y, d, d-p->dy, p->dy); err++; } } return !!err; }
bool RuntimeQueue::Block(const ThreadId& targetThread, u64 taskId, rqe& ec) { if(context->shutdownFlag.load()) { ec = RQE::ShuttingDown; return false; } DProfContext __(RQ_API "Blocking task"); auto thread_id = targetThread.hash(); RuntimeQueue* pQueue = nullptr; { Lock _(context->globalMod); auto q_it = context->queues.find(thread_id); if(q_it == context->queues.end()) { ec = RQE::InvalidQueue; return false; } pQueue = &(*q_it).second; } auto& queue = *pQueue; RuntimeTask const* task = nullptr; szptr idx = 0; if(!(task = GetTask(queue.mTasks, taskId, ec, &idx))) { ec = RQE::InvalidTaskId; return false; } { /* We do this check in case we are executing in the queue */ /* Otherwise we deadlock */ RecLock ___(queue.mTasksLock); if(!queue.mTasks[idx].alive) { ec = RQE::TaskAlreadyBlocked; return false; } auto currentBase = RuntimeTask::clock::now(); auto previousNextTime = queue.timeTillNext(currentBase); queue.mTasks[idx].alive = false; NotifyThread(context, thread_id, previousNextTime, currentBase); } return true; }
STATICINLINE void ThreadQueueSleep( RuntimeQueue* queue, UqLock& thread_lock, RuntimeQueue::semaphore_t* sem_) { if(!sem_->running) return; DProfContext ___(RQ_API "Sleeping"); RuntimeTask::Duration sleepTime; { RecLock _(queue->mTasksLock); auto currentTime = RuntimeTask::clock::now(); sleepTime = queue->timeTillNext(currentTime); queue->mNextWakeup = currentTime + sleepTime; } sem_->condition.wait_for(thread_lock, sleepTime); }
const Distribution1D *SpatialLightDistribution::Lookup(const Point3f &p) const { ProfilePhase _(Prof::LightDistribLookup); ++nLookups; // Compute integer voxel coordinates for the given point |p| with // respect to the overall voxel grid. Vector3f offset = scene.WorldBound().Offset(p); // offset in [0,1]. Point3i pi; for (int i = 0; i < 3; ++i) pi[i] = int(offset[i] * nVoxels[i]); // Create the per-thread cache of sampling distributions if needed. LocalBucketHash *localVoxelDistribution = localVoxelDistributions[ThreadIndex].get(); if (!localVoxelDistribution) { LOG(INFO) << "Created per-thread SpatialLightDistribution for thread" << ThreadIndex; localVoxelDistribution = new LocalBucketHash; localVoxelDistributions[ThreadIndex].reset(localVoxelDistribution); } else { // Otherwise see if we have a sampling distribution for the voxel // that |p| is in already available in the local cache. auto iter = localVoxelDistribution->find(pi); if (iter != localVoxelDistribution->end()) return iter->second; } // Now we need to either get the distribution from the shared hash // table (if another thread has already created it), or create it // ourselves and add it to the shared table. ProfilePhase __(Prof::LightDistribLookupL2); // First, compute a hash into the first-level hash table. size_t hash = std::hash<int>{}(pi[0] + nVoxels[0] * pi[1] + nVoxels[0] * nVoxels[1] * pi[2]); hash &= (nBuckets - 1); // Acquire the lock for the corresponding second-level hash table. std::lock_guard<std::mutex> lock(mutexes[hash]); // See if we can find it. auto iter = voxelDistribution[hash].find(pi); if (iter != voxelDistribution[hash].end()) { // Success. Add the pointer to the thread-specific hash table so // that we can look up this distribution more efficiently in the // future. (*localVoxelDistribution)[pi] = iter->second.get(); return iter->second.get(); } // We need to compute a new sampling distriibution for this voxel. Note // that we're holding the lock for the first-level hash table bucket // throughout the following; in general, we'd like to do the following // quickly so that other threads don't get held up waiting for that // lock (for this or other voxels that share it). ProfilePhase ___(Prof::LightDistribCreation); ++nCreated; ++nDistributions; // Compute the world-space bounding box of the voxel. Point3f p0(Float(pi[0]) / Float(nVoxels[0]), Float(pi[1]) / Float(nVoxels[1]), Float(pi[2]) / Float(nVoxels[2])); Point3f p1(Float(pi[0] + 1) / Float(nVoxels[0]), Float(pi[1] + 1) / Float(nVoxels[1]), Float(pi[2] + 1) / Float(nVoxels[2])); Bounds3f voxelBounds(scene.WorldBound().Lerp(p0), scene.WorldBound().Lerp(p1)); // Compute the sampling distribution. Sample a number of points inside // voxelBounds using a 3D Halton sequence; at each one, sample each // light source and compute a weight based on Li/pdf for the light's // sample (ignoring visibility between the point in the voxel and the // point on the light source) as an approximation to how much the light // is likely to contribute to illumination in the voxel. int nSamples = 128; std::vector<Float> lightContrib(scene.lights.size(), Float(0)); for (int i = 0; i < nSamples; ++i) { Point3f po = voxelBounds.Lerp(Point3f( RadicalInverse(0, i), RadicalInverse(1, i), RadicalInverse(2, i))); Interaction intr(po, Normal3f(), Vector3f(), Vector3f(1, 0, 0), 0 /* time */, MediumInterface()); // Use the next two Halton dimensions to sample a point on the // light source. Point2f u(RadicalInverse(3, i), RadicalInverse(4, i)); for (size_t j = 0; j < scene.lights.size(); ++j) { Float pdf; Vector3f wi; VisibilityTester vis; Spectrum Li = scene.lights[j]->Sample_Li(intr, u, &wi, &pdf, &vis); if (pdf > 0) { // TODO: look at tracing shadow rays / computing beam // transmittance. Probably shouldn't give those full weight // but instead e.g. have an occluded shadow ray scale down // the contribution by 10 or something. lightContrib[j] += Li.y() / pdf; } } } // We don't want to leave any lights with a zero probability; it's // possible that a light contributes to points in the voxel even though // we didn't find such a point when sampling above. Therefore, compute // a minimum (small) weight and ensure that all lights are given at // least the corresponding probability. Float sumContrib = std::accumulate(lightContrib.begin(), lightContrib.end(), Float(0)); Float avgContrib = sumContrib / (nSamples * lightContrib.size()); Float minContrib = (avgContrib > 0) ? .001 * avgContrib : 1; for (size_t i = 0; i < lightContrib.size(); ++i) { VLOG(2) << "Voxel pi = " << pi << ", light " << i << " contrib = " << lightContrib[i]; lightContrib[i] = std::max(lightContrib[i], minContrib); } LOG(INFO) << "Initialized light distribution in voxel pi= " << pi << ", avgContrib = " << avgContrib; // Compute a sampling distribution from the accumulated // contributions. std::unique_ptr<Distribution1D> distrib( new Distribution1D(&lightContrib[0], lightContrib.size())); // Store a pointer to it in the per-thread cache for the future. (*localVoxelDistribution)[pi] = distrib.get(); // Store the canonical unique_ptr for it in the global hash table so // other threads can use it. voxelDistribution[hash][pi] = std::move(distrib); return (*localVoxelDistribution)[pi]; }
int q[2] = {5,4}; \ for(int i=0; i<2; i++) \ { \ for(int j=0; j<3; j++) \ { \ lua_pushinteger(L, 1+j); \ lua_gettable(L, q[i]); \ p[i][j] = lua_tonumber(L, -1); \ lua_pop(L, 1); \ } \ } \ lua_pushnumber(L, F(X, Y, Z, p[0], p[1])); \ return 1; \ static int l_xx(lua_State* L){ ___(magnetostatic_Nxx) } static int l_xy(lua_State* L){ ___(magnetostatic_Nxy) } static int l_xz(lua_State* L){ ___(magnetostatic_Nxz) } static int l_yx(lua_State* L){ ___(magnetostatic_Nyx) } static int l_yy(lua_State* L){ ___(magnetostatic_Nyy) } static int l_yz(lua_State* L){ ___(magnetostatic_Nyz) } static int l_zx(lua_State* L){ ___(magnetostatic_Nzx) } static int l_zy(lua_State* L){ ___(magnetostatic_Nzy) } static int l_zz(lua_State* L){ ___(magnetostatic_Nzz) } #endif #include "pointfunc_demag.h" #define __p(F) \