void State::verify()
{
/* CPU has to support at least SSE2 */
#if !defined (__MIC__)
if (!hasISA(SSE2))
throw_RTCError(RTC_UNSUPPORTED_CPU,"CPU does not support SSE2");
#endif
#if defined(__MIC__)
if (!(numThreads == 1 || (numThreads % 4) == 0))
throw_RTCError(RTC_INVALID_OPERATION,"Xeon Phi supports only number of threads % 4 == 0, or threads == 1");
#endif
/* verify that calculations stay in range */
assert(rcp(min_rcp_input)*FLT_LARGE+FLT_LARGE < 0.01f*FLT_MAX);
/* here we verify that CPP files compiled for a specific ISA only
* call that same or lower ISA version of non-inlined class member
* functions */
#if !defined (__MIC__) && defined(DEBUG)
assert(isa::getISA() == ISA);
#if defined(__TARGET_SSE41__)
assert(sse41::getISA() <= SSE41);
#endif
#if defined(__TARGET_SSE42__)
assert(sse42::getISA() <= SSE42);
#endif
#if defined(__TARGET_AVX__)
assert(avx::getISA() <= AVX);
#endif
#if defined(__TARGET_AVX2__)
assert(avx2::getISA() <= AVX2);
#endif
#if defined (__TARGET_AVX512__)
assert(avx512::getISA() <= AVX512KNL);
#endif
#endif
}
Device::Device (const char* cfg)
{
/* check CPU */
if (!hasISA(ISA))
throw_RTCError(RTC_ERROR_UNSUPPORTED_CPU,"CPU does not support " ISA_STR);
/* initialize global state */
State::parseString(cfg);
if (!ignore_config_files && FileName::executableFolder() != FileName(""))
State::parseFile(FileName::executableFolder()+FileName(".embree" TOSTRING(RTC_VERSION_MAJOR)));
if (!ignore_config_files && FileName::homeFolder() != FileName(""))
State::parseFile(FileName::homeFolder()+FileName(".embree" TOSTRING(RTC_VERSION_MAJOR)));
State::verify();
/*! do some internal tests */
assert(isa::Cylinder::verify());
/*! enable huge page support if desired */
#if defined(__WIN32__)
if (State::enable_selockmemoryprivilege)
State::hugepages_success &= win_enable_selockmemoryprivilege(State::verbosity(3));
#endif
State::hugepages_success &= os_init(State::hugepages,State::verbosity(3));
/*! set tessellation cache size */
setCacheSize( State::tessellation_cache_size );
/*! enable some floating point exceptions to catch bugs */
if (State::float_exceptions)
{
int exceptions = _MM_MASK_MASK;
//exceptions &= ~_MM_MASK_INVALID;
exceptions &= ~_MM_MASK_DENORM;
exceptions &= ~_MM_MASK_DIV_ZERO;
//exceptions &= ~_MM_MASK_OVERFLOW;
//exceptions &= ~_MM_MASK_UNDERFLOW;
//exceptions &= ~_MM_MASK_INEXACT;
_MM_SET_EXCEPTION_MASK(exceptions);
}
/* print info header */
if (State::verbosity(1))
print();
if (State::verbosity(2))
State::print();
/* register all algorithms */
bvh4_factory = make_unique(new BVH4Factory(enabled_builder_cpu_features, enabled_cpu_features));
#if defined(EMBREE_TARGET_SIMD8)
bvh8_factory = make_unique(new BVH8Factory(enabled_builder_cpu_features, enabled_cpu_features));
#endif
/* setup tasking system */
initTaskingSystem(numThreads);
/* ray stream SOA to AOS conversion */
#if defined(EMBREE_RAY_PACKETS)
RayStreamFilterFuncsType rayStreamFilterFuncs;
SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512KNL_AVX512SKX(enabled_cpu_features,rayStreamFilterFuncs);
rayStreamFilters = rayStreamFilterFuncs();
#endif
}
ssize_t Device::getProperty(const RTCDeviceProperty prop)
{
size_t iprop = (size_t)prop;
/* get name of internal regression test */
if (iprop >= 2000000 && iprop < 3000000)
{
RegressionTest* test = getRegressionTest(iprop-2000000);
if (test) return (ssize_t) test->name.c_str();
else return 0;
}
/* run internal regression test */
if (iprop >= 3000000 && iprop < 4000000)
{
RegressionTest* test = getRegressionTest(iprop-3000000);
if (test) return test->run();
else return 0;
}
/* documented properties */
switch (prop)
{
case RTC_DEVICE_PROPERTY_VERSION_MAJOR: return RTC_VERSION_MAJOR;
case RTC_DEVICE_PROPERTY_VERSION_MINOR: return RTC_VERSION_MINOR;
case RTC_DEVICE_PROPERTY_VERSION_PATCH: return RTC_VERSION_PATCH;
case RTC_DEVICE_PROPERTY_VERSION : return RTC_VERSION;
#if defined(EMBREE_TARGET_SIMD4) && defined(EMBREE_RAY_PACKETS)
case RTC_DEVICE_PROPERTY_NATIVE_RAY4_SUPPORTED: return hasISA(SSE2);
#else
case RTC_DEVICE_PROPERTY_NATIVE_RAY4_SUPPORTED: return 0;
#endif
#if defined(EMBREE_TARGET_SIMD8) && defined(EMBREE_RAY_PACKETS)
case RTC_DEVICE_PROPERTY_NATIVE_RAY8_SUPPORTED: return hasISA(AVX);
#else
case RTC_DEVICE_PROPERTY_NATIVE_RAY8_SUPPORTED: return 0;
#endif
#if defined(EMBREE_TARGET_SIMD16) && defined(EMBREE_RAY_PACKETS)
case RTC_DEVICE_PROPERTY_NATIVE_RAY16_SUPPORTED: return hasISA(AVX512KNL) | hasISA(AVX512SKX);
#else
case RTC_DEVICE_PROPERTY_NATIVE_RAY16_SUPPORTED: return 0;
#endif
#if defined(EMBREE_RAY_PACKETS)
case RTC_DEVICE_PROPERTY_RAY_STREAM_SUPPORTED: return 1;
#else
case RTC_DEVICE_PROPERTY_RAY_STREAM_SUPPORTED: return 0;
#endif
#if defined(EMBREE_RAY_MASK)
case RTC_DEVICE_PROPERTY_RAY_MASK_SUPPORTED: return 1;
#else
case RTC_DEVICE_PROPERTY_RAY_MASK_SUPPORTED: return 0;
#endif
#if defined(EMBREE_BACKFACE_CULLING)
case RTC_DEVICE_PROPERTY_BACKFACE_CULLING_ENABLED: return 1;
#else
case RTC_DEVICE_PROPERTY_BACKFACE_CULLING_ENABLED: return 0;
#endif
#if defined(EMBREE_FILTER_FUNCTION)
case RTC_DEVICE_PROPERTY_FILTER_FUNCTION_SUPPORTED: return 1;
#else
case RTC_DEVICE_PROPERTY_FILTER_FUNCTION_SUPPORTED: return 0;
#endif
#if defined(EMBREE_IGNORE_INVALID_RAYS)
case RTC_DEVICE_PROPERTY_IGNORE_INVALID_RAYS_ENABLED: return 1;
#else
case RTC_DEVICE_PROPERTY_IGNORE_INVALID_RAYS_ENABLED: return 0;
#endif
#if defined(TASKING_INTERNAL)
case RTC_DEVICE_PROPERTY_TASKING_SYSTEM: return 0;
#endif
#if defined(TASKING_TBB)
case RTC_DEVICE_PROPERTY_TASKING_SYSTEM: return 1;
#endif
#if defined(TASKING_PPL)
case RTC_DEVICE_PROPERTY_TASKING_SYSTEM: return 2;
#endif
#if defined(EMBREE_GEOMETRY_TRIANGLE)
case RTC_DEVICE_PROPERTY_TRIANGLE_GEOMETRY_SUPPORTED: return 1;
#else
case RTC_DEVICE_PROPERTY_TRIANGLE_GEOMETRY_SUPPORTED: return 0;
#endif
#if defined(EMBREE_GEOMETRY_QUAD)
case RTC_DEVICE_PROPERTY_QUAD_GEOMETRY_SUPPORTED: return 1;
#else
case RTC_DEVICE_PROPERTY_QUAD_GEOMETRY_SUPPORTED: return 0;
#endif
#if defined(EMBREE_GEOMETRY_CURVE)
case RTC_DEVICE_PROPERTY_CURVE_GEOMETRY_SUPPORTED: return 1;
#else
case RTC_DEVICE_PROPERTY_CURVE_GEOMETRY_SUPPORTED: return 0;
#endif
#if defined(EMBREE_GEOMETRY_SUBDIVISION)
case RTC_DEVICE_PROPERTY_SUBDIVISION_GEOMETRY_SUPPORTED: return 1;
#else
case RTC_DEVICE_PROPERTY_SUBDIVISION_GEOMETRY_SUPPORTED: return 0;
#endif
#if defined(EMBREE_GEOMETRY_USER)
case RTC_DEVICE_PROPERTY_USER_GEOMETRY_SUPPORTED: return 1;
#else
case RTC_DEVICE_PROPERTY_USER_GEOMETRY_SUPPORTED: return 0;
#endif
#if defined(TASKING_PPL)
case RTC_DEVICE_PROPERTY_JOIN_COMMIT_SUPPORTED: return 0;
#elif defined(TASKING_TBB) && (TBB_INTERFACE_VERSION_MAJOR < 8)
case RTC_DEVICE_PROPERTY_JOIN_COMMIT_SUPPORTED: return 0;
#else
case RTC_DEVICE_PROPERTY_JOIN_COMMIT_SUPPORTED: return 1;
#endif
default: throw_RTCError(RTC_ERROR_INVALID_ARGUMENT, "unknown readable property"); break;
};
}
ssize_t Device::getParameter1i(const RTCParameter parm)
{
size_t iparm = (size_t)parm;
/* get name of internal regression test */
if (iparm >= 2000000 && iparm < 3000000)
{
RegressionTest* test = getRegressionTest(iparm-2000000);
if (test) return (ssize_t) test->name.c_str();
else return 0;
}
/* run internal regression test */
if (iparm >= 3000000 && iparm < 4000000)
{
RegressionTest* test = getRegressionTest(iparm-3000000);
if (test) return test->run();
else return 0;
}
/* documented parameters */
switch (parm)
{
case RTC_CONFIG_VERSION_MAJOR: return RTCORE_VERSION_MAJOR;
case RTC_CONFIG_VERSION_MINOR: return RTCORE_VERSION_MINOR;
case RTC_CONFIG_VERSION_PATCH: return RTCORE_VERSION_PATCH;
case RTC_CONFIG_VERSION : return RTCORE_VERSION;
case RTC_CONFIG_INTERSECT1: return 1;
#if defined(EMBREE_TARGET_SIMD4) && defined(EMBREE_RAY_PACKETS)
case RTC_CONFIG_INTERSECT4: return hasISA(SSE2);
#else
case RTC_CONFIG_INTERSECT4: return 0;
#endif
#if defined(EMBREE_TARGET_SIMD8) && defined(EMBREE_RAY_PACKETS)
case RTC_CONFIG_INTERSECT8: return hasISA(AVX);
#else
case RTC_CONFIG_INTERSECT8: return 0;
#endif
#if defined(EMBREE_TARGET_SIMD16) && defined(EMBREE_RAY_PACKETS)
case RTC_CONFIG_INTERSECT16: return hasISA(AVX512KNL) | hasISA(AVX512SKX);
#else
case RTC_CONFIG_INTERSECT16: return 0;
#endif
#if defined(EMBREE_RAY_PACKETS)
case RTC_CONFIG_INTERSECT_STREAM: return 1;
#else
case RTC_CONFIG_INTERSECT_STREAM: return 0;
#endif
#if defined(EMBREE_RAY_MASK)
case RTC_CONFIG_RAY_MASK: return 1;
#else
case RTC_CONFIG_RAY_MASK: return 0;
#endif
#if defined(EMBREE_BACKFACE_CULLING)
case RTC_CONFIG_BACKFACE_CULLING: return 1;
#else
case RTC_CONFIG_BACKFACE_CULLING: return 0;
#endif
#if defined(EMBREE_INTERSECTION_FILTER)
case RTC_CONFIG_INTERSECTION_FILTER: return 1;
#else
case RTC_CONFIG_INTERSECTION_FILTER: return 0;
#endif
#if defined(EMBREE_INTERSECTION_FILTER_RESTORE)
case RTC_CONFIG_INTERSECTION_FILTER_RESTORE: return 1;
#else
case RTC_CONFIG_INTERSECTION_FILTER_RESTORE: return 0;
#endif
#if defined(EMBREE_IGNORE_INVALID_RAYS)
case RTC_CONFIG_IGNORE_INVALID_RAYS: return 1;
#else
case RTC_CONFIG_IGNORE_INVALID_RAYS: return 0;
#endif
#if defined(TASKING_INTERNAL)
case RTC_CONFIG_TASKING_SYSTEM: return 0;
#endif
#if defined(TASKING_TBB)
case RTC_CONFIG_TASKING_SYSTEM: return 1;
#endif
#if defined(TASKING_PPL)
case RTC_CONFIG_TASKING_SYSTEM: return 2;
#endif
#if defined(EMBREE_GEOMETRY_TRIANGLES)
case RTC_CONFIG_TRIANGLE_GEOMETRY: return 1;
#else
case RTC_CONFIG_TRIANGLE_GEOMETRY: return 0;
#endif
#if defined(EMBREE_GEOMETRY_QUADS)
case RTC_CONFIG_QUAD_GEOMETRY: return 1;
#else
case RTC_CONFIG_QUAD_GEOMETRY: return 0;
#endif
#if defined(EMBREE_GEOMETRY_LINES)
case RTC_CONFIG_LINE_GEOMETRY: return 1;
#else
case RTC_CONFIG_LINE_GEOMETRY: return 0;
#endif
#if defined(EMBREE_GEOMETRY_HAIR)
case RTC_CONFIG_HAIR_GEOMETRY: return 1;
#else
case RTC_CONFIG_HAIR_GEOMETRY: return 0;
#endif
#if defined(EMBREE_GEOMETRY_SUBDIV)
case RTC_CONFIG_SUBDIV_GEOMETRY: return 1;
#else
case RTC_CONFIG_SUBDIV_GEOMETRY: return 0;
#endif
#if defined(EMBREE_GEOMETRY_USER)
case RTC_CONFIG_USER_GEOMETRY: return 1;
#else
case RTC_CONFIG_USER_GEOMETRY: return 0;
#endif
#if defined(TASKING_TBB) && (TBB_INTERFACE_VERSION_MAJOR < 8)
case RTC_CONFIG_COMMIT_JOIN: return 0;
case RTC_CONFIG_COMMIT_THREAD: return 0;
#else
case RTC_CONFIG_COMMIT_JOIN: return 1;
case RTC_CONFIG_COMMIT_THREAD: return 1;
#endif
default: throw_RTCError(RTC_INVALID_ARGUMENT, "unknown readable parameter"); break;
};
}
