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) \
