From cc8d2161624aa1eb30deb761584b0c56c16b894f Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Tue, 7 Jun 2022 13:46:04 -0600 Subject: [PATCH 01/18] CI: run additional tutorials for release binary tests. --- gitlab/release/linux-test.sh | 9 ++++++++- gitlab/release/macos-test.sh | 9 ++++++++- gitlab/release/windows-test.ps1 | 6 +++++- 3 files changed, 21 insertions(+), 3 deletions(-) diff --git a/gitlab/release/linux-test.sh b/gitlab/release/linux-test.sh index ff432ce3..d4c9b113 100755 --- a/gitlab/release/linux-test.sh +++ b/gitlab/release/linux-test.sh @@ -2,6 +2,9 @@ ## Copyright 2020 Intel Corporation ## SPDX-License-Identifier: Apache-2.0 +# abort on any error +set -e + ROOT_DIR=$PWD #### Extract release package #### @@ -22,8 +25,12 @@ cmake ../examples/from_openvkl_install cmake --build . -#### Run tutorial to verify functionality ### +#### Run tutorial to verify functionality #### export LD_LIBRARY_PATH=${openvkl_DIR}/lib:${LD_LIBRARY_PATH} ./vklTutorial + +#### Run binaries from release package to verify functionality #### + +${openvkl_DIR}/bin/vklMinimal_06 diff --git a/gitlab/release/macos-test.sh b/gitlab/release/macos-test.sh index d56221a3..529b892b 100755 --- a/gitlab/release/macos-test.sh +++ b/gitlab/release/macos-test.sh @@ -2,6 +2,9 @@ ## Copyright 2020 Intel Corporation ## SPDX-License-Identifier: Apache-2.0 +# abort on any error +set -e + ROOT_DIR=$PWD #### Extract release package #### @@ -22,8 +25,12 @@ cmake ../examples/from_openvkl_install cmake --build . -#### Run tutorial to verify functionality ### +#### Run tutorial to verify functionality #### export DYLD_LIBRARY_PATH=${openvkl_DIR}/lib:${DYLD_LIBRARY_PATH} ./vklTutorial + +#### Run binaries from release package to verify functionality #### + +${openvkl_DIR}/bin/vklMinimal_06 diff --git a/gitlab/release/windows-test.ps1 b/gitlab/release/windows-test.ps1 index 1777f911..c5c415a5 100755 --- a/gitlab/release/windows-test.ps1 +++ b/gitlab/release/windows-test.ps1 @@ -24,10 +24,14 @@ cmake -L ` cmake --build . --config Release --target ALL_BUILD -- /m /nologo -#### Run tutorial to verify functionality ### +#### Run tutorial to verify functionality #### $env:PATH += ";$env:openvkl_DIR\bin" .\Release\vklTutorial.exe +#### Run binaries from release package to verify functionality #### + +vklMinimal_06.exe + exit $LASTEXITCODE From 62fcd5c9445e3bc50c41c1a94d7c6c7d1cd295c9 Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Wed, 8 Jun 2022 14:37:34 -0600 Subject: [PATCH 02/18] superbuild: enable OpenVDB build on Windows (for TBB 2020 only). --- superbuild/CMakeLists.txt | 11 ++++------- superbuild/dependencies/dep_boost.cmake | 5 +++++ 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/superbuild/CMakeLists.txt b/superbuild/CMakeLists.txt index ae13e6aa..04ba5948 100644 --- a/superbuild/CMakeLists.txt +++ b/superbuild/CMakeLists.txt @@ -206,17 +206,11 @@ endif() # enabled, and to not attempt to find them in the environment. set(BUILD_OPENVDB_DEFAULT ON) mark_as_advanced(BUILD_OPENVDB_DEFAULT) -if (WIN32) - set(BUILD_OPENVDB_DEFAULT OFF) -endif() option(BUILD_OPENVDB "Enable OpenVDB to support loading .vdb files?" ${BUILD_OPENVDB_DEFAULT}) option(BUILD_BLOSC "Support loading compressed .vdb files using c-BLOSC? (Only used when BUILD_OPENVDB=ON)" ON) if (BUILD_OPENVDB) - if (WIN32) - message(FATAL_ERROR "Open VKL superbuild currently does not support building on Windows.") - set(BUILD_OPENVDB OFF) - elseif (CMAKE_VERSION VERSION_LESS 3.12) + if (CMAKE_VERSION VERSION_LESS 3.12) message(WARNING "Disabling OpenVDB support because the cmake version is too low (3.12 is required)") set(BUILD_OPENVDB OFF) elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.3) @@ -225,6 +219,9 @@ if (BUILD_OPENVDB) elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Intel" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.1) message(WARNING "Disabling OpenVDB support because the icc compiler version is too low (19.1 is required)") set(BUILD_OPENVDB OFF) + elseif (WIN32 AND BUILD_TBB AND (NOT TBB_VERSION VERSION_LESS 2021)) + message(WARNING "Open VKL superbuild currently does not support building OpenVDB on Windows with TBB 2021") + set(BUILD_OPENVDB OFF) else() set(ILMBASE_VERSION "2.5.8") set(ILMBASE_URL "https://github.com/AcademySoftwareFoundation/openexr/archive/v${ILMBASE_VERSION}.zip" diff --git a/superbuild/dependencies/dep_boost.cmake b/superbuild/dependencies/dep_boost.cmake index 099cef94..a160ae60 100644 --- a/superbuild/dependencies/dep_boost.cmake +++ b/superbuild/dependencies/dep_boost.cmake @@ -12,6 +12,11 @@ set(BOOST_CONF "./bootstrap.sh") set(BOOST_BUILD "./b2") set(BOOST_LINK "shared") +if (WIN32) + set(BOOST_CONF "bootstrap.bat") + set(BOOST_BUILD "b2.exe") +endif() + if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm64|aarch64") set(BOOST_ARCH "arm") else() From 3980b978f19a43004706b35553a45412f22ec145 Mon Sep 17 00:00:00 2001 From: Will Usher Date: Fri, 17 Jun 2022 19:09:32 +0000 Subject: [PATCH 03/18] Rework object creation registry to overwrite on plugin load This resolves an issue where we would end up with stale object creation function pointers in the registry after unloading and reloading the OpenVKL module --- openvkl/api/Device.cpp | 12 +++-- openvkl/api/Device.h | 2 + openvkl/common/ManagedObject.h | 11 ++-- openvkl/common/ObjectFactory.h | 58 +++++++++++++++++++++ openvkl/common/objectFactory.h | 61 ---------------------- openvkl/devices/cpu/api/CPUDevice.cpp | 66 ++++++++++++++++++++++++ openvkl/devices/cpu/exports.cpp | 74 ++------------------------- openvkl/devices/cpu/volume/Volume.h | 19 ++++++- 8 files changed, 163 insertions(+), 140 deletions(-) create mode 100644 openvkl/common/ObjectFactory.h delete mode 100644 openvkl/common/objectFactory.h diff --git a/openvkl/api/Device.cpp b/openvkl/api/Device.cpp index 576595a5..2a28c665 100644 --- a/openvkl/api/Device.cpp +++ b/openvkl/api/Device.cpp @@ -3,13 +3,15 @@ #include "Device.h" #include -#include "../common/objectFactory.h" #include "ispc_util_ispc.h" #include "rkcommon/tasking/tasking_system_init.h" #include "rkcommon/utility/StringManip.h" #include "rkcommon/utility/getEnvVar.h" namespace openvkl { + + static ObjectFactory g_devicesFactory; + namespace api { // helper functions @@ -110,10 +112,14 @@ namespace openvkl { std::stringstream ss; ss << cpuDeviceName << "_" << requestedDeviceWidth; - return objectFactory(nullptr, ss.str()); + return g_devicesFactory.createInstance(nullptr, ss.str()); } + return g_devicesFactory.createInstance(nullptr, deviceName); + } - return objectFactory(nullptr, deviceName); + void Device::registerType(const std::string &type, FactoryFcn f) + { + g_devicesFactory.registerType(type, f); } void Device::commit() diff --git a/openvkl/api/Device.h b/openvkl/api/Device.h index 581b437a..5937902d 100644 --- a/openvkl/api/Device.h +++ b/openvkl/api/Device.h @@ -5,6 +5,7 @@ #include #include +#include "../common/ObjectFactory.h" #include "../common/VKLCommon.h" #include "../common/simd.h" #include "openvkl/openvkl.h" @@ -33,6 +34,7 @@ namespace openvkl { virtual ~Device() override = default; static Device *createDevice(const std::string &deviceName); + static void registerType(const std::string &type, FactoryFcn f); // error tracking VKLError lastErrorCode = VKL_NO_ERROR; diff --git a/openvkl/common/ManagedObject.h b/openvkl/common/ManagedObject.h index 4e1d89f0..6068b707 100644 --- a/openvkl/common/ManagedObject.h +++ b/openvkl/common/ManagedObject.h @@ -4,8 +4,8 @@ #pragma once #include "../api/Device.h" +#include "ObjectFactory.h" #include "VKLCommon.h" -#include "objectFactory.h" #include "rkcommon/memory/IntrusivePtr.h" #include "rkcommon/memory/RefCount.h" #include "rkcommon/utility/ParameterizedObject.h" @@ -68,7 +68,6 @@ namespace openvkl { size_t expectedSize, T valIfNotFound); - // throws an error if the named Data parameter is present and not compact void requireParamDataIsCompact(const char *name); @@ -87,14 +86,16 @@ namespace openvkl { }; template - inline OPENVKL_CLASS *createInstanceHelper(Device *device, - const std::string &type) + inline OPENVKL_CLASS *createInstanceHelper( + Device *device, + const std::string &type, + ObjectFactory &factory) { static_assert(std::is_base_of::value, "createInstanceHelper<>() is only for VKL classes, not" " generic types!"); - auto *object = objectFactory(device, type); + auto *object = factory.createInstance(device, type); // denote the subclass type in the ManagedObject base class. if (object) { diff --git a/openvkl/common/ObjectFactory.h b/openvkl/common/ObjectFactory.h new file mode 100644 index 00000000..89f499ae --- /dev/null +++ b/openvkl/common/ObjectFactory.h @@ -0,0 +1,58 @@ +// Copyright 2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include "VKLCommon.h" +#include "logging.h" +#include "openvkl/VKLDataType.h" + +namespace openvkl { + + // Function pointer type for creating a concrete instance of a subtype of + // this class. + template + using FactoryFcn = T *(*)(); + + template + struct ObjectFactory + { + T *createInstance(Device *device, const std::string &type); + + void registerType(const std::string &type, FactoryFcn f); + + private: + std::map> registry; + }; + + template + T *ObjectFactory::createInstance(Device *device, + const std::string &type) + { + const auto type_string = stringFor(VKL_TYPE); + + T *object = nullptr; + if (registry.count(type) != 0) { + // Create a concrete instance of the requested subtype. + object = (*registry[type])(); + } + + if (object == nullptr) { + registry.erase(type); + throw std::runtime_error( + "Could not find " + type_string + " of type: " + type + + ". Make sure you have the correct VKL libraries linked."); + } + + return object; + } + + template + void ObjectFactory::registerType(const std::string &type, + FactoryFcn f) + { + registry[type] = f; + } + +} // namespace openvkl diff --git a/openvkl/common/objectFactory.h b/openvkl/common/objectFactory.h deleted file mode 100644 index c739ebd7..00000000 --- a/openvkl/common/objectFactory.h +++ /dev/null @@ -1,61 +0,0 @@ -// Copyright 2019 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 - -#pragma once - -#include -#include "VKLCommon.h" -#include "logging.h" -#include "openvkl/VKLDataType.h" -#include "rkcommon/os/library.h" - -namespace openvkl { - - template - inline T *objectFactory(Device *device, const std::string &type) - { - // Function pointer type for creating a concrete instance of a subtype of - // this class. - using creationFunctionPointer = T *(*)(); - - // Function pointers corresponding to each subtype. - static std::map symbolRegistry; - const auto type_string = stringFor(VKL_TYPE); - - // Find the creation function for the subtype if not already known. - if (symbolRegistry.count(type) == 0) { - postLogMessage(device, VKL_LOG_DEBUG) - << "trying to look up " << type_string << " type '" << type - << "' for the first time"; - - // Construct the name of the creation function to look for. - std::string creationFunctionName = - "openvkl_create_" + type_string + "__" + type; - - // Look for the named function. - symbolRegistry[type] = - (creationFunctionPointer)rkcommon::getSymbol(creationFunctionName); - - // The named function may not be found if the requested subtype is not - // known. - if (!symbolRegistry[type]) { - postLogMessage(device, VKL_LOG_WARNING) - << "WARNING: unrecognized " << type_string << " type '" << type - << "'."; - } - } - - // Create a concrete instance of the requested subtype. - auto *object = symbolRegistry[type] ? (*symbolRegistry[type])() : nullptr; - - if (object == nullptr) { - symbolRegistry.erase(type); - throw std::runtime_error( - "Could not find " + type_string + " of type: " + type + - ". Make sure you have the correct VKL libraries linked."); - } - - return object; - } - -} // namespace openvkl diff --git a/openvkl/devices/cpu/api/CPUDevice.cpp b/openvkl/devices/cpu/api/CPUDevice.cpp index 6d5ada53..55518714 100644 --- a/openvkl/devices/cpu/api/CPUDevice.cpp +++ b/openvkl/devices/cpu/api/CPUDevice.cpp @@ -3,6 +3,7 @@ #include "CPUDevice.h" #include "../common/Data.h" +#include "../common/ObjectFactory.h" #include "../common/export_util.h" #include "../common/ispc_isa.h" #include "../iterator/Iterator.h" @@ -810,7 +811,72 @@ namespace openvkl { } // namespace cpu_device } // namespace openvkl +#define VKL_MAKE_TARGET_WIDTH_NAME(name) \ + CONCAT1(name, CONCAT1(_, VKL_TARGET_WIDTH)) + +#define VKL_WRAP_DEVICE_REGISTRATION(internal_name) \ + extern "C" OPENVKL_DLLEXPORT openvkl::api::Device *CONCAT1( \ + openvkl_create_device__, internal_name)(); + +#define VKL_WRAP_VOLUME_REGISTRATION(internal_name) \ + extern "C" OPENVKL_DLLEXPORT openvkl::cpu_device::Volume \ + *CONCAT1(openvkl_create_volume__, internal_name)(); + +VKL_WRAP_DEVICE_REGISTRATION(VKL_MAKE_TARGET_WIDTH_NAME(internal_cpu)) + +VKL_WRAP_VOLUME_REGISTRATION(VKL_MAKE_TARGET_WIDTH_NAME(internal_amr)) +VKL_WRAP_VOLUME_REGISTRATION( + VKL_MAKE_TARGET_WIDTH_NAME(internal_structuredRegular)) +VKL_WRAP_VOLUME_REGISTRATION( + VKL_MAKE_TARGET_WIDTH_NAME(internal_structuredSpherical)) +VKL_WRAP_VOLUME_REGISTRATION(VKL_MAKE_TARGET_WIDTH_NAME(internal_unstructured)) +VKL_WRAP_VOLUME_REGISTRATION(VKL_MAKE_TARGET_WIDTH_NAME(internal_vdb)) +VKL_WRAP_VOLUME_REGISTRATION(VKL_MAKE_TARGET_WIDTH_NAME(internal_particle)) + +#define VKL_REGISTER_DEVICE_FACTORY_FCN(internal_name, external_name) \ + openvkl::Device::registerType( \ + TOSTRING(external_name), \ + CONCAT1(openvkl_create_device__, internal_name)) + +#define VKL_REGISTER_VOLUME_FACTORY_FCN(internal_name, external_name) \ + openvkl::cpu_device::Volume::registerType( \ + TOSTRING(external_name), \ + CONCAT1(openvkl_create_volume__, internal_name)) + extern "C" OPENVKL_DLLEXPORT void CONCAT1(openvkl_init_module_cpu_device_, VKL_TARGET_WIDTH)() { + VKL_REGISTER_DEVICE_FACTORY_FCN(VKL_MAKE_TARGET_WIDTH_NAME(internal_cpu), + VKL_MAKE_TARGET_WIDTH_NAME(cpu)); + + VKL_REGISTER_VOLUME_FACTORY_FCN(VKL_MAKE_TARGET_WIDTH_NAME(internal_amr), + VKL_MAKE_TARGET_WIDTH_NAME(amr)); + + VKL_REGISTER_VOLUME_FACTORY_FCN( + VKL_MAKE_TARGET_WIDTH_NAME(internal_structuredRegular), + VKL_MAKE_TARGET_WIDTH_NAME(structuredRegular)); + + VKL_REGISTER_VOLUME_FACTORY_FCN( + VKL_MAKE_TARGET_WIDTH_NAME(internal_structuredSpherical), + VKL_MAKE_TARGET_WIDTH_NAME(structuredSpherical)); + + VKL_REGISTER_VOLUME_FACTORY_FCN( + VKL_MAKE_TARGET_WIDTH_NAME(internal_unstructured), + VKL_MAKE_TARGET_WIDTH_NAME(unstructured)); + + VKL_REGISTER_VOLUME_FACTORY_FCN(VKL_MAKE_TARGET_WIDTH_NAME(internal_vdb), + VKL_MAKE_TARGET_WIDTH_NAME(vdb)); + + VKL_REGISTER_VOLUME_FACTORY_FCN(VKL_MAKE_TARGET_WIDTH_NAME(internal_particle), + VKL_MAKE_TARGET_WIDTH_NAME(particle)); + + // support deprecated snake case names (a warning will be triggered if these + // are used) + VKL_REGISTER_VOLUME_FACTORY_FCN( + VKL_MAKE_TARGET_WIDTH_NAME(internal_structuredRegular), + VKL_MAKE_TARGET_WIDTH_NAME(structured_regular)); + + VKL_REGISTER_VOLUME_FACTORY_FCN( + VKL_MAKE_TARGET_WIDTH_NAME(internal_structuredSpherical), + VKL_MAKE_TARGET_WIDTH_NAME(structured_spherical)); } diff --git a/openvkl/devices/cpu/exports.cpp b/openvkl/devices/cpu/exports.cpp index 00673689..7c377902 100644 --- a/openvkl/devices/cpu/exports.cpp +++ b/openvkl/devices/cpu/exports.cpp @@ -8,83 +8,19 @@ // available in the top level module library, as exports from dependencies will // not be visible. -#define VKL_WRAP_DEVICE_REGISTRATION( \ - module_name, internal_name, external_name) \ - extern "C" OPENVKL_DLLEXPORT void openvkl_init_module_##module_name(); \ - \ - extern "C" OPENVKL_DLLEXPORT ::openvkl::api::Device \ - *openvkl_create_device__##internal_name(); \ - \ - extern "C" OPENVKL_DLLEXPORT ::openvkl::api::Device \ - *openvkl_create_device__##external_name() \ - { \ - return openvkl_create_device__##internal_name(); \ - } - -#define VKL_WRAP_VOLUME_REGISTRATION(internal_name, external_name) \ - extern "C" OPENVKL_DLLEXPORT ::openvkl::ManagedObject \ - *openvkl_create_volume__##internal_name(); \ - \ - extern "C" OPENVKL_DLLEXPORT ::openvkl::ManagedObject \ - *openvkl_create_volume__##external_name() \ - { \ - return openvkl_create_volume__##internal_name(); \ - } +#define VKL_WRAP_MODULE_REGISTRATION(module_name) \ + extern "C" OPENVKL_DLLEXPORT void openvkl_init_module_##module_name(); #if VKL_TARGET_WIDTH_ENABLED_4 -VKL_WRAP_DEVICE_REGISTRATION(cpu_device_4, internal_cpu_4, cpu_4) - -VKL_WRAP_VOLUME_REGISTRATION(internal_amr_4, amr_4) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredRegular_4, structuredRegular_4) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredSpherical_4, - structuredSpherical_4) -VKL_WRAP_VOLUME_REGISTRATION(internal_unstructured_4, unstructured_4) -VKL_WRAP_VOLUME_REGISTRATION(internal_vdb_4, vdb_4) -VKL_WRAP_VOLUME_REGISTRATION(internal_particle_4, particle_4) - -// support deprecated snake case names (a warning will be triggered if these are -// used) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredRegular_4, structured_regular_4) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredSpherical_4, - structured_spherical_4) +VKL_WRAP_MODULE_REGISTRATION(cpu_device_4) #endif #if VKL_TARGET_WIDTH_ENABLED_8 -VKL_WRAP_DEVICE_REGISTRATION(cpu_device_8, internal_cpu_8, cpu_8) - -VKL_WRAP_VOLUME_REGISTRATION(internal_amr_8, amr_8) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredRegular_8, structuredRegular_8) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredSpherical_8, - structuredSpherical_8) -VKL_WRAP_VOLUME_REGISTRATION(internal_unstructured_8, unstructured_8) -VKL_WRAP_VOLUME_REGISTRATION(internal_vdb_8, vdb_8) -VKL_WRAP_VOLUME_REGISTRATION(internal_particle_8, particle_8) - -// support deprecated snake case names (a warning will be triggered if these are -// used) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredRegular_8, structured_regular_8) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredSpherical_8, - structured_spherical_8) +VKL_WRAP_MODULE_REGISTRATION(cpu_device_8) #endif #if VKL_TARGET_WIDTH_ENABLED_16 -VKL_WRAP_DEVICE_REGISTRATION(cpu_device_16, internal_cpu_16, cpu_16) - -VKL_WRAP_VOLUME_REGISTRATION(internal_amr_16, amr_16) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredRegular_16, - structuredRegular_16) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredSpherical_16, - structuredSpherical_16) -VKL_WRAP_VOLUME_REGISTRATION(internal_unstructured_16, unstructured_16) -VKL_WRAP_VOLUME_REGISTRATION(internal_vdb_16, vdb_16) -VKL_WRAP_VOLUME_REGISTRATION(internal_particle_16, particle_16) - -// support deprecated snake case names (a warning will be triggered if these are -// used) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredRegular_16, - structured_regular_16) -VKL_WRAP_VOLUME_REGISTRATION(internal_structuredSpherical_16, - structured_spherical_16) +VKL_WRAP_MODULE_REGISTRATION(cpu_device_16) #endif // calls init functions in [4, 8, 16] devices to ensure proper linkage diff --git a/openvkl/devices/cpu/volume/Volume.h b/openvkl/devices/cpu/volume/Volume.h index 6978e14c..4843f77b 100644 --- a/openvkl/devices/cpu/volume/Volume.h +++ b/openvkl/devices/cpu/volume/Volume.h @@ -4,8 +4,8 @@ #pragma once #include "../common/ManagedObject.h" +#include "../common/ObjectFactory.h" #include "../common/export_util.h" -#include "../common/objectFactory.h" #include "../iterator/Iterator.h" #include "../sampler/Sampler.h" #include "Volume_ispc.h" @@ -42,6 +42,8 @@ namespace openvkl { virtual ~Volume() override = default; static Volume *createInstance(Device *device, const std::string &type); + static void registerType(const std::string &type, + FactoryFcn> f); virtual Sampler *newSampler() = 0; @@ -60,6 +62,8 @@ namespace openvkl { protected: void *ispcEquivalent{nullptr}; + + static ObjectFactory volumeFactory; }; // Inlined definitions //////////////////////////////////////////////////// @@ -68,7 +72,15 @@ namespace openvkl { inline Volume *Volume::createInstance(Device *device, const std::string &type) { - return createInstanceHelper, VKL_VOLUME>(device, type); + return createInstanceHelper, VKL_VOLUME>( + device, type, volumeFactory); + } + + template + inline void Volume::registerType(const std::string &type, + FactoryFcn> f) + { + volumeFactory.registerType(type, f); } template @@ -77,6 +89,9 @@ namespace openvkl { return ispcEquivalent; } + template + ObjectFactory, VKL_VOLUME> Volume::volumeFactory; + #define VKL_REGISTER_VOLUME(InternalClass, external_name) \ VKL_REGISTER_OBJECT( \ ::openvkl::ManagedObject, volume, InternalClass, external_name) From c5a5b386da86efeffb40f6f032c44401d63e8d7f Mon Sep 17 00:00:00 2001 From: Krishnan Ramachandran Date: Tue, 2 Aug 2022 13:34:27 +0100 Subject: [PATCH 04/18] Use CMAKE_BUILD_TYPE in the OpenVDB install command --- superbuild/dependencies/dep_openvdb.cmake | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/superbuild/dependencies/dep_openvdb.cmake b/superbuild/dependencies/dep_openvdb.cmake index 82b56595..43468985 100644 --- a/superbuild/dependencies/dep_openvdb.cmake +++ b/superbuild/dependencies/dep_openvdb.cmake @@ -19,7 +19,6 @@ endif() set(OPENVKL_EXTRA_OPENVDB_OPTIONS -DCMAKE_NO_SYSTEM_FROM_IMPORTED=ON) mark_as_advanced(OPENVKL_EXTRA_OPENVDB_OPTIONS) - ExternalProject_Add(${COMPONENT_NAME} PREFIX ${COMPONENT_NAME} DOWNLOAD_DIR ${COMPONENT_NAME} @@ -35,7 +34,7 @@ ExternalProject_Add(${COMPONENT_NAME} -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR} -DCMAKE_INSTALL_DOCDIR=${CMAKE_INSTALL_DOCDIR} -DCMAKE_INSTALL_BINDIR=${CMAKE_INSTALL_BINDIR} - -DCMAKE_BUILD_TYPE=Release + -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DOPENVDB_BUILD_BINARIES:BOOL=OFF -DOPENVDB_BUILD_CORE:BOOL=ON -DOPENVDB_BUILD_DOCS:BOOL=OFF @@ -54,7 +53,7 @@ ExternalProject_Add(${COMPONENT_NAME} -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET} ${OPENVKL_EXTRA_OPENVDB_OPTIONS} BUILD_COMMAND ${DEFAULT_BUILD_COMMAND} - INSTALL_COMMAND ${CMAKE_COMMAND} --build . --target install + INSTALL_COMMAND ${CMAKE_COMMAND} --build . --target install --config ${CMAKE_BUILD_TYPE} BUILD_ALWAYS OFF ) From 6f2f6ad137d191e136703aa2514ba917d7bff904 Mon Sep 17 00:00:00 2001 From: Krzysztof Raszkowski Date: Mon, 1 Aug 2022 17:07:57 +0200 Subject: [PATCH 05/18] ci: Remove Ubuntu 16.04 build & testing --- gitlab/.gitlab-ci.yml | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/gitlab/.gitlab-ci.yml b/gitlab/.gitlab-ci.yml index c88fc3c0..b40f0036 100644 --- a/gitlab/.gitlab-ci.yml +++ b/gitlab/.gitlab-ci.yml @@ -234,12 +234,6 @@ build-centos8-module-cmake: - docker - modules -build-ubuntu16.04: - <<: *build_job_docker - image: $DOCKER_REGISTRY/ospray/docker-images:ubuntu16.04 - script: - - gitlab/build.sh -G Ninja - build-ubuntu18.04: <<: *build_job_docker image: $DOCKER_REGISTRY/ospray/docker-images:ubuntu18.04 @@ -401,12 +395,6 @@ test-functional-centos8-module-cmake: needs: - build-centos8-module-cmake -test-functional-ubuntu16.04: - <<: *test_functional_job_docker_ubuntu - image: $DOCKER_REGISTRY/ospray/docker-images:ubuntu16.04 - needs: - - build-ubuntu16.04 - test-functional-ubuntu18.04: <<: *test_functional_job_docker_ubuntu image: $DOCKER_REGISTRY/ospray/docker-images:ubuntu18.04 From c0271ba41d3203b492e0ec8de29204dc4ac05a6d Mon Sep 17 00:00:00 2001 From: Krzysztof Raszkowski Date: Tue, 2 Aug 2022 19:51:08 +0200 Subject: [PATCH 06/18] boost: Disable support for the zstd filters. --- superbuild/dependencies/dep_boost.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/superbuild/dependencies/dep_boost.cmake b/superbuild/dependencies/dep_boost.cmake index a160ae60..9e94d6a7 100644 --- a/superbuild/dependencies/dep_boost.cmake +++ b/superbuild/dependencies/dep_boost.cmake @@ -34,7 +34,7 @@ ExternalProject_Add(${COMPONENT_NAME} URL_HASH SHA256=${BOOST_HASH} CONFIGURE_COMMAND ${BOOST_CONF} BUILD_COMMAND ${BOOST_BUILD} -d0 --with-system --with-iostreams --with-regex --layout=system - --prefix=${COMPONENT_PATH} variant=release threading=multi address-model=64 + --prefix=${COMPONENT_PATH} variant=release threading=multi address-model=64 -s NO_ZSTD=1 link=${BOOST_LINK} architecture=${BOOST_ARCH} install INSTALL_COMMAND "" BUILD_ALWAYS OFF From 8f730ec27f5383b785d97539103e2ed54045528e Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Tue, 23 Aug 2022 15:58:15 -0600 Subject: [PATCH 07/18] CI: set Git safe directory for release and scan jobs. --- gitlab/.gitlab-ci.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/gitlab/.gitlab-ci.yml b/gitlab/.gitlab-ci.yml index b40f0036..f07ab755 100644 --- a/gitlab/.gitlab-ci.yml +++ b/gitlab/.gitlab-ci.yml @@ -99,6 +99,7 @@ stages: <<: *master_release_devel_only stage: release before_script: + - git config --global --add safe.directory $CI_PROJECT_DIR - git submodule sync - git submodule init - git submodule update @@ -658,6 +659,7 @@ build-kw-scan: script: - gitlab/build-kw-scan.sh before_script: + - git config --global --add safe.directory $CI_PROJECT_DIR - git submodule sync - git submodule init - git submodule update From 546869dbc1128d0222fa5bf84a14e4265b1540d7 Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Tue, 20 Sep 2022 11:04:12 -0600 Subject: [PATCH 08/18] CI: allow failure of some scan jobs. --- gitlab/.gitlab-ci.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/gitlab/.gitlab-ci.yml b/gitlab/.gitlab-ci.yml index f07ab755..5468ea1d 100644 --- a/gitlab/.gitlab-ci.yml +++ b/gitlab/.gitlab-ci.yml @@ -795,6 +795,7 @@ scan-bdba-bin: paths: - openvkl-*.pdf - openvkl-*.csv + allow_failure: true av: <<: *master_release_devel_only @@ -806,3 +807,4 @@ av: - freshclam | tee -a /tmp/av_scan.log - clamscan -va --max-filesize=1024M --max-scansize=1024M --alert-broken --alert-exceeds-max openvkl-* | tee -a /tmp/av_scan.log - gitlab/store-files.sh $CI_PROJECT_NAME $CI_PIPELINE_ID av /tmp/av_scan.log + allow_failure: true From b6c3b821a885a57f661ba5e2fc6d65fccc52689a Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Tue, 20 Sep 2022 11:09:53 -0600 Subject: [PATCH 09/18] CI: remove unused benchmark jobs. --- gitlab/.gitlab-ci.yml | 68 ------------------------------------------- 1 file changed, 68 deletions(-) diff --git a/gitlab/.gitlab-ci.yml b/gitlab/.gitlab-ci.yml index 5468ea1d..fcd80924 100644 --- a/gitlab/.gitlab-ci.yml +++ b/gitlab/.gitlab-ci.yml @@ -564,58 +564,6 @@ vdb-multi-a-1: examples-a-1: <<: [*manual_benchmark_a-1, *benchmark_select_examples] -# vis-sdp-adl-1-perf - -.job_template: &manual_benchmark_adl-1 - <<: *base_benchmark_job - when: manual - tags: - - vis-sdp-adl-1-perf - -all-adl-1: - <<: *manual_benchmark_adl-1 - -structured-adl-1: - <<: [*manual_benchmark_adl-1, *benchmark_select_structured] - -structured-multi-adl-1: - <<: [*manual_benchmark_adl-1, *benchmark_select_structured-multi] - -vdb-adl-1: - <<: [*manual_benchmark_adl-1, *benchmark_select_vdb] - -vdb-multi-adl-1: - <<: [*manual_benchmark_adl-1, *benchmark_select_vdb-multi] - -examples-adl-1: - <<: [*manual_benchmark_adl-1, *benchmark_select_examples] - -# vis-sdp-dg2-01-perf - -.job_template: &manual_benchmark_tgl-1 - <<: *base_benchmark_job - when: manual - tags: - - vis-sdp-dg2-01-perf - -all-tgl-1: - <<: *manual_benchmark_tgl-1 - -structured-tgl-1: - <<: [*manual_benchmark_tgl-1, *benchmark_select_structured] - -structured-multi-tgl-1: - <<: [*manual_benchmark_tgl-1, *benchmark_select_structured-multi] - -vdb-tgl-1: - <<: [*manual_benchmark_tgl-1, *benchmark_select_vdb] - -vdb-multi-tgl-1: - <<: [*manual_benchmark_tgl-1, *benchmark_select_vdb-multi] - -examples-tgl-1: - <<: [*manual_benchmark_tgl-1, *benchmark_select_examples] - # Benchmark jobs meant for scheduled (nightly, weekly, ...) builds. # The builds must define RUN_SCHEDULE_BENCHMARKS to run the job, and may use # environment variables to configure the benchmark behavior. @@ -635,22 +583,6 @@ benchmark-a-1-schedule: tags: - vis-perf-a-1 -benchmark-adl-1-schedule: - <<: *base_benchmark_job - only: - variables: - - $RUN_SCHEDULE_BENCHMARKS - tags: - - vis-sdp-adl-1-perf - -benchmark-tgl-1-schedule: - <<: *base_benchmark_job - only: - variables: - - $RUN_SCHEDULE_BENCHMARKS - tags: - - vis-sdp-dg2-01-perf - ## KW Jobs ## build-kw-scan: From d3d160fcd7fd176d554302646afc498fdc203c06 Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Thu, 22 Sep 2022 14:57:33 -0500 Subject: [PATCH 10/18] update CMake linkage for openvkl_module_cpu_device_[4,8,16] and rkcommon. --- openvkl/devices/cpu/CMakeLists.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/openvkl/devices/cpu/CMakeLists.txt b/openvkl/devices/cpu/CMakeLists.txt index edfecd15..3fb36e0b 100644 --- a/openvkl/devices/cpu/CMakeLists.txt +++ b/openvkl/devices/cpu/CMakeLists.txt @@ -111,9 +111,10 @@ foreach(TARGET_WIDTH 4 8 16) target_link_libraries(${TARGET_NAME} PUBLIC openvkl - rkcommon::rkcommon + $ PRIVATE embree + $ ) openvkl_install_library(${TARGET_NAME}) From 700507a44641140ea6339af694b514fc717622a5 Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Fri, 14 Oct 2022 08:53:50 -0600 Subject: [PATCH 11/18] CI: enable GitHub actions workflows from devel. --- .github/workflows/ci.linux.yml | 484 +++++++++++++++++++++++++++++++ .github/workflows/ci.mac.yml | 84 ++++++ .github/workflows/ci.windows.yml | 52 ++++ .github/workflows/release.yml | 145 +++++++++ 4 files changed, 765 insertions(+) create mode 100644 .github/workflows/ci.linux.yml create mode 100644 .github/workflows/ci.mac.yml create mode 100644 .github/workflows/ci.windows.yml create mode 100644 .github/workflows/release.yml diff --git a/.github/workflows/ci.linux.yml b/.github/workflows/ci.linux.yml new file mode 100644 index 00000000..c53feb1e --- /dev/null +++ b/.github/workflows/ci.linux.yml @@ -0,0 +1,484 @@ +## Copyright 2022 Intel Corporation +## SPDX-License-Identifier: Apache-2.0 + +name: CI Linux Workflow +on: + push: + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build-centos7: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: centos:7 + artifact-out: build-centos7 + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh + + test-centos7: + needs: build-centos7 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-centos7 + image: centos:7 + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-centos7-icc: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: centos:7 + artifact-out: build-centos7-icc + artifact-path: ./build/install ./build/openvkl/build + cmd: | + module load cmake + module load intel/2019.4 + export CC=icc + export CXX=icpc + export CXXFLAGS="-static-intel -fPIC" + gitlab/build.sh + + test-centos7-icc: + needs: build-centos7-icc + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-centos7-icc + image: centos:7 + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-centos7-icc15: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + #ICC 2015 req. old GCC (<7.0?) this is why we're using old docker image + image: ospray/docker-images:centos7-mod + cmd: | + module load cmake + module load intel/2015 + export CC=icc + export CXX=icpc + export CXXFLAGS="-static-intel -fPIC" + gitlab/build.sh + + build-centos7-icx: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: centos:7 + artifact-out: build-centos7-icx + artifact-path: ./build/install ./build/openvkl/build + cmd: | + module load cmake + module load intel/2022.1 + export CC=icx + export CXX=icpx + export CXXFLAGS="-fPIC -fp-model=precise" + export LDFLAGS="-static-intel" + gitlab/build.sh + + test-centos7-icx: + needs: build-centos7-icx + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-centos7-icx + image: centos:7 + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-centos7-icx-tbb2020: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: centos:7 + artifact-out: build-centos7-icx-tbb2020 + artifact-path: ./build/install ./build/openvkl/build + cmd: | + module load cmake + module load intel/2022.1 + export CC=icx + export CXX=icpx + export CXXFLAGS="-fPIC -fp-model=precise" + export LDFLAGS="-static-intel" + gitlab/build.sh -D TBB_VERSION=2020.3 -D TBB_HASH="" + + test-centos7-icx-tbb2020: + needs: build-centos7-icx-tbb2020 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-centos7-icx-tbb2020 + image: centos:7 + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-centos7-icx-tbb2020-avx512_8: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: centos:7 + artifact-out: build-centos7-icx-tbb2020-avx512_8 + artifact-path: ./build/install ./build/openvkl/build + cmd: | + module load cmake + module load intel/2022.1 + export CC=icx + export CXX=icpx + export CXXFLAGS="-fPIC -fp-model=precise" + export LDFLAGS="-static-intel" + gitlab/build.sh -D TBB_VERSION=2020.3 -D TBB_HASH="" -D OPENVKL_EXTRA_OPTIONS="-DOPENVKL_ISA_AVX512SKX_8_WIDE=ON -DOPENVKL_ISA_AVX512SKX=OFF" + + test-centos7-icx-tbb2020-avx512_8: + needs: build-centos7-icx-tbb2020-avx512_8 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-centos7-icx-tbb2020-avx512_8 + image: centos:7 + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-centos8: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: centos:8 + artifact-out: build-centos8 + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -G Ninja + + test-centos8: + needs: build-centos8 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-centos8 + image: centos:8 + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + # uses a newer CMake which allows OpenVDB to build + build-centos8-module-cmake: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: centos:8 + artifact-out: build-centos8-module-cmake + artifact-path: ./build/install ./build/openvkl/build + cmd: | + module load cmake + gitlab/build.sh -G Ninja -D TBB_VERSION=2020.3 -D TBB_HASH="" + + test-centos8-module-cmake: + needs: build-centos8-module-cmake + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-centos8-module-cmake + image: centos:8 + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-ubuntu18_04: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ubuntu:18.04 + artifact-out: build-ubuntu18_04 + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -G Ninja -D BUILD_GLFW=OFF + + build-ubuntu20_04: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ubuntu:20.04 + artifact-out: build-ubuntu20_04 + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -G Ninja -D BUILD_GLFW=OFF + + build-ubuntu22_04: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ubuntu:22.04 + artifact-out: build-ubuntu22_04 + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -G Ninja -D BUILD_GLFW=OFF + + test-ubuntu18_04: + needs: build-ubuntu18_04 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-ubuntu18_04 + image: ubuntu:18.04 + cmd: | + export LD_LIBRARY_PATH=./build/install/lib + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + test-ubuntu20_04: + needs: build-ubuntu20_04 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-ubuntu20_04 + image: ubuntu:20.04 + cmd: | + export LD_LIBRARY_PATH=./build/install/lib + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + test-ubuntu22_04: + needs: build-ubuntu22_04 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-ubuntu22_04 + image: ubuntu:22.04 + cmd: | + export LD_LIBRARY_PATH=./build/install/lib + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-arch: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ospray/docker-images:arch + artifact-out: build-arch + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh + + test-arch: + needs: build-arch + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-arch + image: ospray/docker-images:arch + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-arch-clang: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ospray/docker-images:arch + artifact-out: build-arch-clang + artifact-path: ./build/install ./build/openvkl/build + cmd: | + export CC=clang + export CXX=clang++ + gitlab/build.sh -G Ninja -D BUILD_GLFW=OFF + + test-arch-clang: + needs: build-arch-clang + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-arch-clang + image: ospray/docker-images:arch + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-arch-address-sanitizer: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ospray/docker-images:arch + artifact-out: build-arch-address-sanitizer + artifact-path: ./build/install ./build/openvkl/build + cmd: | + export CFLAGS=-fsanitize=address + export CXXFLAGS=-fsanitize=address + export LDFLAGS=-fsanitize=address + gitlab/build.sh -D BUILD_GLFW=OFF -D BUILD_OPENVDB=OFF + + test-arch-address-sanitizer: + needs: build-arch-address-sanitizer + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-arch-address-sanitizer + image: ospray/docker-images:arch + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-arch-debug: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ospray/docker-images:arch + artifact-out: build-arch-debug + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -D CMAKE_BUILD_TYPE=Debug -D BUILD_GLFW=OFF + + test-arch-debug: + needs: build-arch-debug + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-arch-debug + image: ospray/docker-images:arch + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-arch-TBB2020: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ospray/docker-images:arch + artifact-out: build-arch-TBB2020 + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -D TBB_VERSION=2020.3 -D TBB_HASH="" + + test-arch-TBB2020: + needs: build-arch-TBB2020 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-arch-TBB2020 + image: ospray/docker-images:arch + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-arch-devel-rkdeps: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ospray/docker-images:arch + artifact-out: build-arch-devel-rkdeps + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -D RKCOMMON_VERSION=devel -D RKCOMMON_HASH="" -D EMBREE_VERSION=devel -D EMBREE_HASH="" + + test-arch-devel-rkdeps: + needs: build-arch-devel-rkdeps + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-arch-devel-rkdeps + image: ospray/docker-images:arch + cmd: | + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-linux-arch: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + image: ospray/docker-images:arch + artifact-out: build-linux-arch + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -G Ninja -D BUILD_GLFW=OFF + + test-linux-arch: + needs: build-linux-arch + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + runs-on: '[ "Linux", "docker", "avx512" ]' + artifact-in: build-linux-arch + image: ospray/docker-images:arch + cmd: | + export LD_LIBRARY_PATH=./build/install/lib + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-from-install-centos7: + needs: build-centos7 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + artifact-in: build-centos7 + image: centos:7 + cmd: | + gitlab/build-from-install.sh + + kw-build-scan-report: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/static_analysis.yml@main + with: + project: openvkl + submodules: true + prebuild: | + mkdir build + cd build + export LD_LIBRARY_PATH=`pwd`/install/lib:${LD_LIBRARY_PATH} + cmake -DBUILD_JOBS=`nproc` -DBUILD_DEPENDENCIES_ONLY=ON -DBUILD_GLFW=OFF "$@" ../superbuild + cmake --build . + mkdir openvkl_build + cd openvkl_build + DEP_INSTALL_DIR=`pwd`/../install + export rkcommon_DIR=$DEP_INSTALL_DIR + export embree_DIR=$DEP_INSTALL_DIR + cmake -DISPC_EXECUTABLE=$DEP_INSTALL_DIR/bin/ispc -DBUILD_EXAMPLES=OFF -DRKCOMMON_TBB_ROOT=$DEP_INSTALL_DIR ../.. + cd ../.. + build: cmake --build ./build/openvkl_build diff --git a/.github/workflows/ci.mac.yml b/.github/workflows/ci.mac.yml new file mode 100644 index 00000000..f7f3972e --- /dev/null +++ b/.github/workflows/ci.mac.yml @@ -0,0 +1,84 @@ +## Copyright 2022 Intel Corporation +## SPDX-License-Identifier: Apache-2.0 + +name: CI Mac Workflow +on: + push: + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build-macOS: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/macos.yml@main + with: + submodules: true + runs-on: '[ "macOS", "build", "avx2", "x86_64" ]' + artifact-out: build-macOS + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh + + test-macOS: + needs: build-macOS + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/macos.yml@main + with: + runs-on: '[ "macOS", "build", "avx2", "x86_64" ]' + artifact-in: build-macOS + cmd: | + export DYLD_LIBRARY_PATH=./build/install/lib + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-macOS-TBB2020: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/macos.yml@main + with: + submodules: true + runs-on: '[ "macOS", "build", "avx2", "x86_64" ]' + artifact-out: build-macOS-TBB2020 + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -D TBB_VERSION=2020.3 -D TBB_HASH="" + + test-macOS-TBB2020: + needs: build-macOS-TBB2020 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/macos.yml@main + with: + runs-on: '[ "macOS", "build", "avx2", "x86_64" ]' + artifact-in: build-macOS-TBB2020 + cmd: | + export DYLD_LIBRARY_PATH=./build/install/lib + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes + + build-macOS-arm: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/macos.yml@main + with: + submodules: true + runs-on: '[ "macOS", "build", "arm" ]' + artifact-out: build-macOS-arm + artifact-path: ./build/install ./build/openvkl/build + cmd: | + gitlab/build.sh -DBUILD_TBB_FROM_SOURCE=ON + + test-macOS-arm: + needs: build-macOS-arm + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/macos.yml@main + with: + runs-on: '[ "macOS", "build", "arm" ]' + artifact-in: build-macOS-arm + cmd: | + export DYLD_LIBRARY_PATH=./build/install/lib + ./build/openvkl/build/vklTutorial + ./build/openvkl/build/vklTutorialISPC + ./build/openvkl/build/vklTests --durations yes diff --git a/.github/workflows/ci.windows.yml b/.github/workflows/ci.windows.yml new file mode 100644 index 00000000..701c1c6b --- /dev/null +++ b/.github/workflows/ci.windows.yml @@ -0,0 +1,52 @@ +## Copyright 2022 Intel Corporation +## SPDX-License-Identifier: Apache-2.0 + +name: CI Windows Workflow +on: + push: + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build-windows-msvc15: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/windows.yml@main + with: + submodules: true + runs-on: '[ "Windows", "build" ]' + artifact-out: build-windows-msvc15 + artifact-path: ./build/install + cmd: gitlab\build.bat "Visual Studio 15 2017 Win64" "v141" + + build-windows-msvc15-TBB2020: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/windows.yml@main + with: + submodules: true + runs-on: '[ "Windows", "build" ]' + artifact-out: build-windows-msvc15-TBB2020 + artifact-path: ./build/install + cmd: gitlab\build.bat "Visual Studio 15 2017 Win64" "v141" '"-DTBB_VERSION=2020.3"' '"-DTBB_HASH="""' + + test-windows-msvc15: + needs: build-windows-msvc15 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/windows.yml@main + with: + runs-on: '[ "Windows", "build" ]' + artifact-in: build-windows-msvc15 + cmd: | + gitlab\run_tests.bat + + test-windows-msvc15-TBB2020: + needs: build-windows-msvc15-TBB2020 + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/windows.yml@main + with: + runs-on: '[ "Windows", "build" ]' + artifact-in: build-windows-msvc15-TBB2020 + cmd: | + gitlab\run_tests.bat diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 00000000..bcc2653b --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,145 @@ +## Copyright 2022 Intel Corporation +## SPDX-License-Identifier: Apache-2.0 + +name: Release Workflow +on: + push: + branches: + - '*release*' + - 'devel' + - 'master' + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + kw-build-scan-report: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/static_analysis.yml@main + with: + project: openvkl + submodules: true + prebuild: | + mkdir build + cd build + export LD_LIBRARY_PATH=`pwd`/install/lib:${LD_LIBRARY_PATH} + cmake -DBUILD_JOBS=`nproc` -DBUILD_DEPENDENCIES_ONLY=ON -DBUILD_GLFW=OFF "$@" ../superbuild + cmake --build . + mkdir openvkl_build + cd openvkl_build + DEP_INSTALL_DIR=`pwd`/../install + export rkcommon_DIR=$DEP_INSTALL_DIR + export embree_DIR=$DEP_INSTALL_DIR + cmake -DISPC_EXECUTABLE=$DEP_INSTALL_DIR/bin/ispc -DBUILD_EXAMPLES=OFF -DRKCOMMON_TBB_ROOT=$DEP_INSTALL_DIR ../.. + cd ../.. + build: cmake --build ./build/openvkl_build + + + release-linux: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + submodules: true + runs-on: '[ "Linux", "docker" ]' + image: centos:7 + artifact-out: release-linux + artifact-path: ./*.gz + cmd: | + export OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + module load cmake + module load intel/2022.1 + export CC=icx + export CXX=icpx + export CXXFLAGS="-fPIC -fp-model=precise" + export LDFLAGS="-static-intel" + gitlab/release/linux.sh + + release-windows: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/windows.yml@main + with: + submodules: true + runs-on: '[ "Windows", "NAS", "build" ]' + artifact-out: release-windows + artifact-path: ./*.zip + cmd: | + $env:OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + $OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + gitlab/release/windows.ps1 "Visual Studio 15 2017 Win64" "v141" + + release-macos: + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/macos.yml@main + with: + submodules: true + runs-on: '[ "macOS", "sign", "avx2", "x86_64" ]' + artifact-out: release-macos + artifact-path: ./*.zip + cmd: | + export OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + gitlab/release/macos.sh + + release-linux-test: + needs: release-linux + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/docker.yml@main + with: + runs-on: '[ "Linux", "docker" ]' + image: centos:7 + artifact-in: release-linux + cmd: | + export OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + gitlab/release/linux-test.sh + + release-windows-test: + needs: release-windows + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/windows.yml@main + with: + runs-on: '[ "Windows" ]' + artifact-in: release-windows + cmd: | + $env:OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + $OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + gitlab/release/windows-test.ps1 "Visual Studio 15 2017 Win64" "v141" + + release-macos-test: + needs: release-macos + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/macos.yml@main + with: + runs-on: '[ "macOS", "avx2", "x86_64" ]' + artifact-in: release-macos + cmd: | + export OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + gitlab/release/macos-test.sh + + binary-analysis: + needs: + - release-linux + - release-macos + - release-windows + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/binary_analysis.yml@main + with: + project: openvkl + artifact-in-linux: release-linux + artifact-in-macos: release-macos + artifact-in-windows: release-windows + path: "*.zip *.gz" + + antivirus-scan: + needs: + - release-linux + - release-macos + - release-windows + secrets: inherit + uses: intel-innersource/libraries.devops.renderkit.workflows/.github/workflows/antivirus_scan.yml@main + with: + project: openvkl + artifact-in-linux: release-linux + artifact-in-macos: release-macos + artifact-in-windows: release-windows + path: "*.zip *.gz" From 250967ec5b412eaef04b089a78c5fdb8ad4bc61d Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Fri, 14 Oct 2022 09:48:42 -0600 Subject: [PATCH 12/18] CI: update release workflow wildcards. --- .github/workflows/release.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index bcc2653b..5185164e 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -5,7 +5,7 @@ name: Release Workflow on: push: branches: - - '*release*' + - '**release**' - 'devel' - 'master' workflow_dispatch: From 6b98d43028b8afc5bd31964858fd7efeee86a3ee Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Fri, 14 Oct 2022 08:59:09 -0600 Subject: [PATCH 13/18] update version to v1.3.1. --- .github/workflows/release.yml | 16 ++++++++-------- CMakeLists.txt | 2 +- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 5185164e..5cd8133d 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -47,7 +47,7 @@ jobs: artifact-out: release-linux artifact-path: ./*.gz cmd: | - export OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + export OPENVKL_RELEASE_PACKAGE_VERSION="1.3.1" module load cmake module load intel/2022.1 export CC=icx @@ -65,8 +65,8 @@ jobs: artifact-out: release-windows artifact-path: ./*.zip cmd: | - $env:OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" - $OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + $env:OPENVKL_RELEASE_PACKAGE_VERSION="1.3.1" + $OPENVKL_RELEASE_PACKAGE_VERSION="1.3.1" gitlab/release/windows.ps1 "Visual Studio 15 2017 Win64" "v141" release-macos: @@ -78,7 +78,7 @@ jobs: artifact-out: release-macos artifact-path: ./*.zip cmd: | - export OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + export OPENVKL_RELEASE_PACKAGE_VERSION="1.3.1" gitlab/release/macos.sh release-linux-test: @@ -90,7 +90,7 @@ jobs: image: centos:7 artifact-in: release-linux cmd: | - export OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + export OPENVKL_RELEASE_PACKAGE_VERSION="1.3.1" gitlab/release/linux-test.sh release-windows-test: @@ -101,8 +101,8 @@ jobs: runs-on: '[ "Windows" ]' artifact-in: release-windows cmd: | - $env:OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" - $OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + $env:OPENVKL_RELEASE_PACKAGE_VERSION="1.3.1" + $OPENVKL_RELEASE_PACKAGE_VERSION="1.3.1" gitlab/release/windows-test.ps1 "Visual Studio 15 2017 Win64" "v141" release-macos-test: @@ -113,7 +113,7 @@ jobs: runs-on: '[ "macOS", "avx2", "x86_64" ]' artifact-in: release-macos cmd: | - export OPENVKL_RELEASE_PACKAGE_VERSION="1.4.0" + export OPENVKL_RELEASE_PACKAGE_VERSION="1.3.1" gitlab/release/macos-test.sh binary-analysis: diff --git a/CMakeLists.txt b/CMakeLists.txt index 0b827dae..d1f90338 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,7 +19,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON) ## Establish project ## -project(openvkl VERSION 1.3.0 LANGUAGES C CXX) +project(openvkl VERSION 1.3.1 LANGUAGES C CXX) ## Add openvkl specific macros ## From 987ea6e6deb238319b37c89c651ce03fc7808cf4 Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Fri, 14 Oct 2022 13:30:26 -0600 Subject: [PATCH 14/18] superbuild: update to latest versions of dependencies (including latest zlib to resolve CVE). --- superbuild/CMakeLists.txt | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/superbuild/CMakeLists.txt b/superbuild/CMakeLists.txt index 04ba5948..30334799 100644 --- a/superbuild/CMakeLists.txt +++ b/superbuild/CMakeLists.txt @@ -230,18 +230,18 @@ if (BUILD_OPENVDB) CACHE STRING "SHA256 hash of the IlmBase archive.") include(dep_ilmbase) - set(ZLIB_VERSION "1.2.12") + set(ZLIB_VERSION "1.2.13") set(ZLIB_URL "https://www.zlib.net/fossils/zlib-${ZLIB_VERSION}.tar.gz" CACHE STRING "URL of the zlib archive.") - set(ZLIB_HASH "91844808532e5ce316b3c010929493c0244f3d37593afd6de04f71821d5136d9" + set(ZLIB_HASH "b3a24de97a8fdbc835b9833169501030b8977031bcb54b3b3ac13740f846ab30" CACHE STRING "SHA256 hash of the zlib archive.") include(dep_zlib) - set(BOOST_VERSION "1.79.0") + set(BOOST_VERSION "1.80.0") string(REPLACE "." "_" BOOST_FILE_BASE "${BOOST_VERSION}") set(BOOST_BASE_URL "https://boostorg.jfrog.io/artifactory/main/release/${BOOST_VERSION}/source/boost") set(_BOOST_URL "${BOOST_BASE_URL}_${BOOST_FILE_BASE}.tar.gz") - set(_BOOST_HASH "273f1be93238a068aba4f9735a4a2b003019af067b9c183ed227780b8f36062c") + set(_BOOST_HASH "4b2136f98bdd1f5857f1c3dea9ac2018effe65286cf251534b6ae20cc45e1847") set(BOOST_URL "${_BOOST_URL}" CACHE STRING "URL of the boost archive.") set(BOOST_HASH "${_BOOST_HASH}" CACHE STRING "SHA256 hash of the boost archive.") include(dep_boost) @@ -255,11 +255,11 @@ if (BUILD_OPENVDB) include(dep_blosc) endif() - set(OPENVDB_VERSION "9.0.0") + set(OPENVDB_VERSION "9.1.0") set(OPENVDB_BASE_URL "https://github.com/AcademySoftwareFoundation/openvdb/archive") set(OPENVDB_URL "${OPENVDB_BASE_URL}/v${OPENVDB_VERSION}.zip" CACHE STRING "URL of the OpenVDB archive.") - set(OPENVDB_HASH "631443144a1d584519e83d7e883ecf52ef6dd32260bf5435324b53453d2e095a" + set(OPENVDB_HASH "6a5e953e09828e371f8d05e20420ff182ed5149bfbcbdc92d9eca24f15093640" CACHE STRING "SHA256 hash of the OpenVDB archive.") include(dep_openvdb) endif() From 93df3d8767828d0ea8ab670ebbbf1262ea4124fe Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Mon, 17 Oct 2022 15:29:58 -0500 Subject: [PATCH 15/18] superbuild: c-blosc using external zlib instead of internally packaged version. --- superbuild/dependencies/dep_blosc.cmake | 2 ++ 1 file changed, 2 insertions(+) diff --git a/superbuild/dependencies/dep_blosc.cmake b/superbuild/dependencies/dep_blosc.cmake index a9bedffc..1690a83c 100644 --- a/superbuild/dependencies/dep_blosc.cmake +++ b/superbuild/dependencies/dep_blosc.cmake @@ -22,6 +22,8 @@ ExternalProject_Add(${COMPONENT_NAME} -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES} -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET} + -DPREFER_EXTERNAL_ZLIB=ON + -DZLIB_ROOT=${ZLIB_PATH} BUILD_COMMAND ${DEFAULT_BUILD_COMMAND} BUILD_ALWAYS OFF ) From 33a12a54054a7fd7e56bf2fabfc406ee8f88101b Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Tue, 18 Oct 2022 14:18:45 -0500 Subject: [PATCH 16/18] superbuild: update to Embree v3.13.5; resolve CMake issues with Embree+TBB. --- CMakeLists.txt | 4 ++++ superbuild/CMakeLists.txt | 10 +++++----- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index d1f90338..b0981f69 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,6 +17,8 @@ set(CMAKE_DISABLE_SOURCE_CHANGES ON) set(CMAKE_DISABLE_IN_SOURCE_BUILD ON) set(CMAKE_POSITION_INDEPENDENT_CODE ON) +cmake_policy(SET CMP0074 NEW) + ## Establish project ## project(openvkl VERSION 1.3.1 LANGUAGES C CXX) @@ -52,6 +54,8 @@ find_package(rkcommon ${RKCOMMON_VERSION_REQUIRED} REQUIRED) get_target_property(RKCOMMON_INCLUDE_DIRS rkcommon::rkcommon INTERFACE_INCLUDE_DIRECTORIES) +# rkcommon includes FindTBB.cmake, needed by Embree +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${rkcommon_DIR}) find_package(embree 3.13.1 REQUIRED) openvkl_create_embree_target() diff --git a/superbuild/CMakeLists.txt b/superbuild/CMakeLists.txt index 30334799..c5a5d467 100644 --- a/superbuild/CMakeLists.txt +++ b/superbuild/CMakeLists.txt @@ -166,23 +166,23 @@ endif() option(BUILD_EMBREE "Build Intel Embree or search in environment?" ON) option(BUILD_EMBREE_FROM_SOURCE "Build Embree from source or use pre-built version? (Only used when BUILD_EMBREE=ON)" ON) if (BUILD_EMBREE) - set(EMBREE_VERSION "v3.13.3" CACHE STRING "Embree version to download") + set(EMBREE_VERSION "v3.13.5" CACHE STRING "Embree version to download") if (BUILD_EMBREE_FROM_SOURCE) set(_EMBREE_URL "https://github.com/embree/embree/archive/${EMBREE_VERSION}.zip") - set(_EMBREE_HASH "e98db1522d377a1d47c04ff7db29ccb4207412751c33cb756de32b20ae66e9b1") + set(_EMBREE_HASH "036be94d1023ce8d31d3f054a7b00505dfda057f26f8f7fc1865392fbc50656d") else() # Embree binary package URLs do not use the "v" prefix string(REPLACE "v" "" EMBREE_VERSION_NUMBER ${EMBREE_VERSION}) set(EMBREE_BASE_URL "https://github.com/embree/embree/releases/download/${EMBREE_VERSION}") if (APPLE) set(_EMBREE_URL "${EMBREE_BASE_URL}/embree-${EMBREE_VERSION_NUMBER}.x86_64.macosx.zip") - set(_EMBREE_HASH "79f2e56b4697f833be9b5088bea9c7ce22119adacaf09390e23a7140f6383fd9") + set(_EMBREE_HASH "699c10a62b4440abd50b01ad2b8e855236ebae2029b6081c9627049ad886e6da") elseif (WIN32) set(_EMBREE_URL "${EMBREE_BASE_URL}/embree-${EMBREE_VERSION_NUMBER}.x64.vc14.windows.zip") - set(_EMBREE_HASH "1decef1ab8d0f5b2b4ef59bf70b303da05d0fe8d741d0e15bacaccd144055821") + set(_EMBREE_HASH "0ea932e2d5953c6816490a6c7e384646f7d35c59092286a00abf47cd931b8ac6") else() set(_EMBREE_URL "${EMBREE_BASE_URL}/embree-${EMBREE_VERSION_NUMBER}.x86_64.linux.tar.gz") - set(_EMBREE_HASH "0c5884a6d3dffa082c329327276b91cc686ae0374e91a4c2cbea8cf6f7ddfeb4") + set(_EMBREE_HASH "6454c9793e50213f681a34be3b0128f263caad0d663a1409f0bc2f98644bfa98") endif() endif() set(EMBREE_URL "${_EMBREE_URL}" CACHE STRING "URL of the Embree source archive.") From aecfede3c89cf9f7f2cd4f5f27c68d29316a6595 Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Tue, 18 Oct 2022 14:31:57 -0500 Subject: [PATCH 17/18] CI: set MACOSX_DEPLOYMENT_TARGET for macOS build and release jobs. --- gitlab/build.sh | 2 ++ gitlab/release/macos.sh | 2 ++ 2 files changed, 4 insertions(+) diff --git a/gitlab/build.sh b/gitlab/build.sh index 0daacda7..a1df95dd 100755 --- a/gitlab/build.sh +++ b/gitlab/build.sh @@ -2,6 +2,8 @@ ## Copyright 2019 Intel Corporation ## SPDX-License-Identifier: Apache-2.0 +MACOSX_DEPLOYMENT_TARGET="10.13" + mkdir build cd build diff --git a/gitlab/release/macos.sh b/gitlab/release/macos.sh index dd7290aa..6956c004 100755 --- a/gitlab/release/macos.sh +++ b/gitlab/release/macos.sh @@ -22,6 +22,8 @@ OPENVKL_PKG_BASE=openvkl-${OPENVKL_RELEASE_PACKAGE_VERSION}.x86_64.macos OPENVKL_BUILD_DIR=$ROOT_DIR/build_release OPENVKL_INSTALL_DIR=$ROOT_DIR/install_release/$OPENVKL_PKG_BASE +MACOSX_DEPLOYMENT_TARGET="10.13" + THREADS=`sysctl -n hw.logicalcpu` # to make sure we do not include nor link against wrong TBB From 5c3a8289c0d960b506615739c8798f9547b7917f Mon Sep 17 00:00:00 2001 From: Greg Johnson Date: Tue, 18 Oct 2022 14:22:00 -0600 Subject: [PATCH 18/18] update changelog and rebuild README.md. --- CHANGELOG.md | 5 + README.md | 1016 +++++++++++++++++++++++++------------------------- 2 files changed, 510 insertions(+), 511 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7a4ada6f..7f7e7912 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,11 @@ Version History --------------- +### Open VKL 1.3.1 + +- Superbuild updates to latest versions of dependencies +- Note that the update to zlib v1.2.13 remedies CVE-2022-37434 + ### Open VKL 1.3.0 - Added AVX512 8-wide CPU device mode, enabled via the diff --git a/README.md b/README.md index e2f8e2a1..870cc129 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Intel® Open Volume Kernel Library -This is release v1.3.0 of Intel® Open VKL. For changes and new features +This is release v1.3.1 of Intel® Open VKL. For changes and new features see the [changelog](CHANGELOG.md). Visit http://www.openvkl.org for more information. @@ -33,335 +33,327 @@ example renderers to demonstrate how to best use the Open VKL API. ## Version History +### Open VKL 1.3.1 + +- Superbuild updates to latest versions of dependencies +- Note that the update to zlib v1.2.13 remedies CVE-2022-37434 + ### Open VKL 1.3.0 - - Added AVX512 8-wide CPU device mode, enabled via the - `OPENVKL_ISA_AVX512SKX_8_WIDE` CMake option - - VDB volumes: added support for packed / contiguous data layouts for - temporally constant volumes, which can provide improved performance - (`nodesPackedDense`, `nodesPackedTile` parameters) - - VDB utility library: added `repackNodes` flag to toggle usage of - packed data layouts - - Particle volumes: general memory efficiency and performance - improvements - - Superbuild updates to latest versions of dependencies - - Minimum ISPC version is now v1.18.0 +- Added AVX512 8-wide CPU device mode, enabled via the + `OPENVKL_ISA_AVX512SKX_8_WIDE` CMake option +- VDB volumes: added support for packed / contiguous data layouts for + temporally constant volumes, which can provide improved performance + (`nodesPackedDense`, `nodesPackedTile` parameters) +- VDB utility library: added `repackNodes` flag to toggle usage of + packed data layouts +- Particle volumes: general memory efficiency and performance + improvements +- Superbuild updates to latest versions of dependencies +- Minimum ISPC version is now v1.18.0 ### Open VKL 1.2.0 - - Added `vklSetParam()` API function which can set parameters of any - supported type - - Structured regular volumes: - - Added support for cell-centered data via the `cellCentered` - parameter; vertex-centered remains the default - - Added support for more general transformations via the - `indexToObject` parameter - - Added `indexOrigin` parameter which applies an index-space vec3i - translation - - VDB volumes: - - Added `indexClippingBounds` parameter, which can restrict the - active voxel bounding box - - The `indexToObject` parameter can now be provided as a - `VKL_AFFINE3F` - - Corrected bounding box computations in `InnerNode` observer - - Particle volumes: - - Now ignoring particles with zero radius - - VDB utility library: added `commit` flag (default true) to volume - creation methods, allowing apps to set additional parameters before - first commit - - Examples: - - Added new set of minimal examples, which step through creation - of basic volume and isosurface renderers - - Exposing `intervalResolutionHint` parameter in `vklExamples` - application - - Superbuild updates to latest versions of dependencies +- Added `vklSetParam()` API function which can set parameters of any + supported type +- Structured regular volumes: + - Added support for cell-centered data via the `cellCentered` + parameter; vertex-centered remains the default + - Added support for more general transformations via the + `indexToObject` parameter + - Added `indexOrigin` parameter which applies an index-space vec3i + translation +- VDB volumes: + - Added `indexClippingBounds` parameter, which can restrict the active + voxel bounding box + - The `indexToObject` parameter can now be provided as a + `VKL_AFFINE3F` + - Corrected bounding box computations in `InnerNode` observer +- Particle volumes: + - Now ignoring particles with zero radius +- VDB utility library: added `commit` flag (default true) to volume + creation methods, allowing apps to set additional parameters before + first commit +- Examples: + - Added new set of minimal examples, which step through creation of + basic volume and isosurface renderers + - Exposing `intervalResolutionHint` parameter in `vklExamples` + application +- Superbuild updates to latest versions of dependencies ### Open VKL 1.1.0 - - vklExamples improvements: asynchronous rendering, multiple - viewports, docking, and more - - Fixed bug in `openvkl_utility_vdb` which could lead to crashes when - creating VDB volumes with temporally constant tiles - - Superbuild updates to latest versions of dependencies - - Minimum rkcommon version is now 1.8.0 +- vklExamples improvements: asynchronous rendering, multiple viewports, + docking, and more +- Fixed bug in `openvkl_utility_vdb` which could lead to crashes when + creating VDB volumes with temporally constant tiles +- Superbuild updates to latest versions of dependencies +- Minimum rkcommon version is now 1.8.0 ### Open VKL 1.0.1 - - Fixed issue in `structuredRegular` and `vdb` interval iterators that - could lead to erroneous initial intervals for certain ray inputs - - Fixed handling of `intervalResolutionHint` interval iterator context - parameter for `amr`, `particle`, and `unstructured` volumes with - small numbers of cells / primitives +- Fixed issue in `structuredRegular` and `vdb` interval iterators that + could lead to erroneous initial intervals for certain ray inputs +- Fixed handling of `intervalResolutionHint` interval iterator context + parameter for `amr`, `particle`, and `unstructured` volumes with small + numbers of cells / primitives ### Open VKL 1.0.0 - - The version 1.0 release marks long term API stability (until v2.0) - - Open VKL can now be built for ARM CPUs that support Neon - - Iterator API updates: - - Introducing interval and hit iterator contexts, which hold - iterator-specific configuration (eliminates value selector - objects) - - Interval and hit iteration is now supported on any volume - attribute - - Interval iterators now include a `time` parameter - - Interval iterators now support the `intervalResolutionHint` - parameter, replacing `maxIteratorDepth` and - `elementaryCellIteration` - - Supporting configurable background values; default is now - `VKL_BACKGROUND_UNDEFINED` (NaN) for all volume types - - `vklGetValueRange()` now supports all volume attributes - - Added ISPC-side API bindings for `vklGetNumAttributes()` and - `vklGetValueRange()` - - Structured regular volumes: - - Added support for tricubic filtering - - More accurate gradient computations respecting filter mode - - Hit iteration robustness improvements - - VDB volumes: - - Interval and hit iteration robustness improvements - - Corrected interval iterator `nominalDeltaT` computation for - non-normalized ray directions and non-uniform object-space grid - spacings - - Fixed bug which could cause incorrect value range computations - for temporally varying volumes - - vklExamples additions demonstrating: - - Multi-attribute interval / hit iteration - - Configurable background values - - Temporally varying volumes - - Superbuild updates to latest versions of dependencies - - Now requiring minimum versions: - - Embree 3.13.1 - - rkcommon 1.7.0 - - ISPC 1.16.0 +- The version 1.0 release marks long term API stability (until v2.0) +- Open VKL can now be built for ARM CPUs that support Neon +- Iterator API updates: + - Introducing interval and hit iterator contexts, which hold + iterator-specific configuration (eliminates value selector objects) + - Interval and hit iteration is now supported on any volume attribute + - Interval iterators now include a `time` parameter + - Interval iterators now support the `intervalResolutionHint` + parameter, replacing `maxIteratorDepth` and + `elementaryCellIteration` +- Supporting configurable background values; default is now + `VKL_BACKGROUND_UNDEFINED` (NaN) for all volume types +- `vklGetValueRange()` now supports all volume attributes +- Added ISPC-side API bindings for `vklGetNumAttributes()` and + `vklGetValueRange()` +- Structured regular volumes: + - Added support for tricubic filtering + - More accurate gradient computations respecting filter mode + - Hit iteration robustness improvements +- VDB volumes: + - Interval and hit iteration robustness improvements + - Corrected interval iterator `nominalDeltaT` computation for + non-normalized ray directions and non-uniform object-space grid + spacings + - Fixed bug which could cause incorrect value range computations for + temporally varying volumes +- vklExamples additions demonstrating: + - Multi-attribute interval / hit iteration + - Configurable background values + - Temporally varying volumes +- Superbuild updates to latest versions of dependencies +- Now requiring minimum versions: + - Embree 3.13.1 + - rkcommon 1.7.0 + - ISPC 1.16.0 ### Open VKL 0.13.0 - - Driver (now device) API changes: - - Renamed `VKLDriver` to `VKLDevice` and updated associated device - setup APIs - - Use of multiple concurrent devices is now supported; therefore - `vklNewVolume()` and `vklNewData()` now require a device handle - - Renamed the `ispc_device` module and `ispc` device to - `cpu_device` and `cpu`, respectively - - The `OPENVKL_CPU_DEVICE_DEFAULT_WIDTH` environment variable can - now be used to change the `cpu` device’s default SIMD width at - run time - - Added new `VKLTemporalFormat` enum used for temporally varying - volume parameterization - - VDB volumes: - - Support for temporally structured and temporally unstructured - (TUV) attribute data, which can be used for motion blurred - rendering - - Supporting tricubic filtering via `VKL_FILTER_TRICUBIC` filter - type - - Added support for half precision float-point (FP16) attribute - data via `VKL_HALF` data type - - Added a new `InnerNode` observer and associated utility - functions which allows applications to introspect inner nodes of - the internal tree structure, including bounding boxes and value - ranges - - Renamed `VKL_FORMAT_CONSTANT_ZYX` to `VKL_FORMAT_DENSE_ZYX` - - Structured regular and spherical volumes: - - Added support for half precision float-point (FP16) attribute - data via `VKL_HALF` data type - - Unstructured volumes: - - Added support for elementary cell iteration via the - `elementaryCellIteration` parameter - - Robustness improvements for hit iteration - - AMR volumes: - - Improved interval iterator implementation, resolving issues with - returned interval `nominalDeltaT` values - - Interval iterators now support `maxIteratorDepth` parameter - - Interval and hit iteration performance improvements when multiple - values ranges / values are selected - - Added new temporal compression utilities which applications can use - for processing temporally unstructured attribute data - - vklExamples additions demonstrating: - - Motion blurred rendering on temporally structured and temporally - unstructured `vdb` volumes - - Tricubic filtering on `vdb` volumes - - Half-precision floating-point (FP16) support for - `structuredRegular`, `structuredSpherical`, and `vdb` volumes - - Elementary cell interval iteration on `unstructured` volumes - - Use of the `InnerNode` observer on `vdb` volumes - - Superbuild updates to: - - Embree 3.13.0 - - rkcommon 1.6.1 - - Minimum rkcommon version is now 1.6.1 +- Driver (now device) API changes: + - Renamed `VKLDriver` to `VKLDevice` and updated associated device + setup APIs + - Use of multiple concurrent devices is now supported; therefore + `vklNewVolume()` and `vklNewData()` now require a device handle + - Renamed the `ispc_device` module and `ispc` device to `cpu_device` + and `cpu`, respectively + - The `OPENVKL_CPU_DEVICE_DEFAULT_WIDTH` environment variable can now + be used to change the `cpu` device’s default SIMD width at run time +- Added new `VKLTemporalFormat` enum used for temporally varying volume + parameterization +- VDB volumes: + - Support for temporally structured and temporally unstructured (TUV) + attribute data, which can be used for motion blurred rendering + - Supporting tricubic filtering via `VKL_FILTER_TRICUBIC` filter type + - Added support for half precision float-point (FP16) attribute data + via `VKL_HALF` data type + - Added a new `InnerNode` observer and associated utility functions + which allows applications to introspect inner nodes of the internal + tree structure, including bounding boxes and value ranges + - Renamed `VKL_FORMAT_CONSTANT_ZYX` to `VKL_FORMAT_DENSE_ZYX` +- Structured regular and spherical volumes: + - Added support for half precision float-point (FP16) attribute data + via `VKL_HALF` data type +- Unstructured volumes: + - Added support for elementary cell iteration via the + `elementaryCellIteration` parameter + - Robustness improvements for hit iteration +- AMR volumes: + - Improved interval iterator implementation, resolving issues with + returned interval `nominalDeltaT` values + - Interval iterators now support `maxIteratorDepth` parameter +- Interval and hit iteration performance improvements when multiple + values ranges / values are selected +- Added new temporal compression utilities which applications can use + for processing temporally unstructured attribute data +- vklExamples additions demonstrating: + - Motion blurred rendering on temporally structured and temporally + unstructured `vdb` volumes + - Tricubic filtering on `vdb` volumes + - Half-precision floating-point (FP16) support for + `structuredRegular`, `structuredSpherical`, and `vdb` volumes + - Elementary cell interval iteration on `unstructured` volumes + - Use of the `InnerNode` observer on `vdb` volumes +- Superbuild updates to: + - Embree 3.13.0 + - rkcommon 1.6.1 +- Minimum rkcommon version is now 1.6.1 ### Open VKL 0.12.1 - - Fixed bug in VDB volume interval iterator implementation which could - lead to missed intervals or incorrect value ranges in returned - intervals +- Fixed bug in VDB volume interval iterator implementation which could + lead to missed intervals or incorrect value ranges in returned + intervals ### Open VKL 0.12.0 - - Added support for temporally varying volumes with associated API - changes for sampling, gradients, and hit iteration. This feature can - be used to enable motion blurred rendering - - Structured regular volumes: - - Support for temporally structured and temporally unstructured - (TUV) input data - - Improved `nominalDeltaT` for interval iteration - - Interval iterator robustness improvements for axis-aligned rays - - Sampling performance improvements - - VDB volumes: - - Multi-attribute support (including three-component float grids) - - Interval iterator robustness improvements for axis-aligned rays - - Performance improvements for scalar sampling - - Now restricting volumes to exactly four levels - - Allowing leaf nodes on the lowest level only - - Unstructured volumes: - - Improved `nominalDeltaT` for interval iteration - - `vdb_util` updates: - - Support for loading multi-attribute .vdb files (`float` and - `Vec3s` grids) - - Fix order of rotation matrix coefficients loaded from .vdb files - - vklExamples additions demonstrating: - - Motion blurred rendering on temporally structured and temporally - unstructured volumes (`structuredRegular` only) - - Support for `vdb` multi-attribute volumes - - Hit iterator time support - - Superbuild updates to: - - Embree 3.12.2 - - rkcommon 1.6.0 - - ISPC 1.15.0 - - OpenVDB 8.0.0 - - Minimum rkcommon version is now 1.6.0 +- Added support for temporally varying volumes with associated API + changes for sampling, gradients, and hit iteration. This feature can + be used to enable motion blurred rendering +- Structured regular volumes: + - Support for temporally structured and temporally unstructured (TUV) + input data + - Improved `nominalDeltaT` for interval iteration + - Interval iterator robustness improvements for axis-aligned rays + - Sampling performance improvements +- VDB volumes: + - Multi-attribute support (including three-component float grids) + - Interval iterator robustness improvements for axis-aligned rays + - Performance improvements for scalar sampling + - Now restricting volumes to exactly four levels + - Allowing leaf nodes on the lowest level only +- Unstructured volumes: + - Improved `nominalDeltaT` for interval iteration +- `vdb_util` updates: + - Support for loading multi-attribute .vdb files (`float` and `Vec3s` + grids) + - Fix order of rotation matrix coefficients loaded from .vdb files +- vklExamples additions demonstrating: + - Motion blurred rendering on temporally structured and temporally + unstructured volumes (`structuredRegular` only) + - Support for `vdb` multi-attribute volumes + - Hit iterator time support +- Superbuild updates to: + - Embree 3.12.2 + - rkcommon 1.6.0 + - ISPC 1.15.0 + - OpenVDB 8.0.0 +- Minimum rkcommon version is now 1.6.0 ### Open VKL 0.11.0 - - Introduced API support for multi-attribute volumes, including APIs - for sampling multiple attributes simultaneously - - Initially only `structuredRegular` and `structuredSpherical` - volume types support multi-attribute data - - Iterator APIs now work on sampler objects rather than volumes, - supporting finer-grained configurability - - Observers can now be created for both volume and sampler objects - - `LeafNodeAccess` observers must now be created on sampler - objects - - Log and error callbacks now support a user pointer - - `vdb` volume interval iterators: - - Added support for elementary cell iteration when - `maxIteratorDepth` is set to `VKL_VDB_NUM_LEVELS`-1 - - Up to 2x faster iteration - - `unstructured` and `particle` volume interval iterators: - - Improved interior empty space skipping behavior - - Added support for configurable iterator depth via the - `maxIteratorDepth` parameter - - Added support for filter modes in `structuredRegular` and - `structuredSpherical` volumes - - `amr` volumes now support `method` parameter on sampler objects - - Added new `interval_iterator_debug` renderer in `vklExamples` to - visualize interval iteration behavior - - Hit iterator accuracy improvements for `unstructured` volumes - - Fixed bugs in `amr` and `vdb` volume bounding box computations - - Fixed bug in `unstructured` volume gradient computations near empty - regions - - Minimum ISPC version is now v1.14.1 +- Introduced API support for multi-attribute volumes, including APIs for + sampling multiple attributes simultaneously + - Initially only `structuredRegular` and `structuredSpherical` volume + types support multi-attribute data +- Iterator APIs now work on sampler objects rather than volumes, + supporting finer-grained configurability +- Observers can now be created for both volume and sampler objects + - `LeafNodeAccess` observers must now be created on sampler objects +- Log and error callbacks now support a user pointer +- `vdb` volume interval iterators: + - Added support for elementary cell iteration when `maxIteratorDepth` + is set to `VKL_VDB_NUM_LEVELS`-1 + - Up to 2x faster iteration +- `unstructured` and `particle` volume interval iterators: + - Improved interior empty space skipping behavior + - Added support for configurable iterator depth via the + `maxIteratorDepth` parameter +- Added support for filter modes in `structuredRegular` and + `structuredSpherical` volumes +- `amr` volumes now support `method` parameter on sampler objects +- Added new `interval_iterator_debug` renderer in `vklExamples` to + visualize interval iteration behavior +- Hit iterator accuracy improvements for `unstructured` volumes +- Fixed bugs in `amr` and `vdb` volume bounding box computations +- Fixed bug in `unstructured` volume gradient computations near empty + regions +- Minimum ISPC version is now v1.14.1 ### Open VKL 0.10.0 (alpha) - - Added new `particle` volume type supporting Gaussian radial basis - functions - - Introduced `VKLSampler` objects allowing configuration of sampling - and gradient behavior - - Added stream-wide sampling and gradient APIs - - Introduced a new way to allocate iterators, giving the user more - freedom in choosing allocation schemes and reducing iterator size - - Added support for strided data arrays - - Added gradient implementations for `amr` and `vdb` volumes - - Hit iterator accuracy improvements for `amr`, `structuredSpherical`, - `unstructured`, and `vdb` volumes - - Up to 4x performance improvement for `structuredRegular` and - `structuredSpherical` sampling for volumes in the 1-2GB range - - Up to 2x performance improvement for `structuredRegular` interval - iteration - - Improved commit speed for `unstructured` volumes - - Improved value range computation in `vdb` volumes - - Improved isosurface shading in `vklExamples` - - Improved parameter validation across all volume types - - Aligned `VKLHit[4,8,16]` and `VKLInterval[4,8,16]` structs - - Added hit epsilon to `VKLHit[4,8,16]` - - Updated parameter names for `vdb` volumes - - Renamed `VKLVdbLeafFormat` to `VKLFormat` - - Fixed incorrect use of system-installed CMake in superbuild while - building dependencies - - Fixed various memory leaks - - Fixed crashes which could occur in `VdbVolume::cleanup()` and - `vklShutdown()` - - Moved from ospcommon to rkcommon v1.4.1 +- Added new `particle` volume type supporting Gaussian radial basis + functions +- Introduced `VKLSampler` objects allowing configuration of sampling and + gradient behavior +- Added stream-wide sampling and gradient APIs +- Introduced a new way to allocate iterators, giving the user more + freedom in choosing allocation schemes and reducing iterator size +- Added support for strided data arrays +- Added gradient implementations for `amr` and `vdb` volumes +- Hit iterator accuracy improvements for `amr`, `structuredSpherical`, + `unstructured`, and `vdb` volumes +- Up to 4x performance improvement for `structuredRegular` and + `structuredSpherical` sampling for volumes in the 1-2GB range +- Up to 2x performance improvement for `structuredRegular` interval + iteration +- Improved commit speed for `unstructured` volumes +- Improved value range computation in `vdb` volumes +- Improved isosurface shading in `vklExamples` +- Improved parameter validation across all volume types +- Aligned `VKLHit[4,8,16]` and `VKLInterval[4,8,16]` structs +- Added hit epsilon to `VKLHit[4,8,16]` +- Updated parameter names for `vdb` volumes +- Renamed `VKLVdbLeafFormat` to `VKLFormat` +- Fixed incorrect use of system-installed CMake in superbuild while + building dependencies +- Fixed various memory leaks +- Fixed crashes which could occur in `VdbVolume::cleanup()` and + `vklShutdown()` +- Moved from ospcommon to rkcommon v1.4.1 ### Open VKL 0.9.0 (alpha) - - Added support for VDB sparse structured volumes (`"vdb"` volume - type) - - Added `vdb_util` library to simplify instantiation of VDB volumes, - and support loading of .vdb files using OpenVDB - - Added `VKLObserver` and associated APIs, which may used by volume - types to pass information back to the application - - A `LeafNodeAccess` observer is provided for VDB volumes to - support on-demand loading of leaf nodes - - Structured regular volumes: - - Up to 6x performance improvement for scalar iterator - initialization - - Up to 2x performance improvement for scalar iterator iteration - - General improvements to the CMake Superbuild for building Open VKL - and all associated dependencies - - Allowing instantiation of ISPC driver for any supported SIMD width - (in addition to the default automatically selected width) - - Volume type names are now camelCase (legacy snake\_case type names - are deprecated), impacting `structuredRegular` and - `structuredSpherical` volumes - - Enabling `flushDenormals` driver mode by default - - Aligning public `vkl_vvec3f[4,8,16]` and `vkl_vrange1f[4,8,16]` - types - - Added `VKL_LOG_NONE` log level - - Fixed bug in `vklExamples` which could lead to improper rendering on - macOS Catalina - - Fixed bug in unstructured volume interval iterator which could lead - to errors with some combinations of lane masks - - Now providing binary releases for Linux, macOS, and Windows +- Added support for VDB sparse structured volumes (`"vdb"` volume type) +- Added `vdb_util` library to simplify instantiation of VDB volumes, and + support loading of .vdb files using OpenVDB +- Added `VKLObserver` and associated APIs, which may used by volume + types to pass information back to the application + - A `LeafNodeAccess` observer is provided for VDB volumes to support + on-demand loading of leaf nodes +- Structured regular volumes: + - Up to 6x performance improvement for scalar iterator initialization + - Up to 2x performance improvement for scalar iterator iteration +- General improvements to the CMake Superbuild for building Open VKL and + all associated dependencies +- Allowing instantiation of ISPC driver for any supported SIMD width (in + addition to the default automatically selected width) +- Volume type names are now camelCase (legacy snake_case type names are + deprecated), impacting `structuredRegular` and `structuredSpherical` + volumes +- Enabling `flushDenormals` driver mode by default +- Aligning public `vkl_vvec3f[4,8,16]` and `vkl_vrange1f[4,8,16]` types +- Added `VKL_LOG_NONE` log level +- Fixed bug in `vklExamples` which could lead to improper rendering on + macOS Catalina +- Fixed bug in unstructured volume interval iterator which could lead to + errors with some combinations of lane masks +- Now providing binary releases for Linux, macOS, and Windows ### Open VKL 0.8.0 (alpha) - - Added support for structured volumes on spherical grids - (`"structured_spherical"` volume type) - - Structured regular volumes: - - Up to 8x performance improvement for scalar (single-wide) - sampling - - Fixed hit iterator bug which could lead to isosurfacing - artifacts - - Renamed `voxelData` parameter to `data` - - Unstructured volumes: - - Up to 4x performance improvement for scalar (single-wide) - sampling - - Improved interval iterator implementation for more efficient - space skipping and tighter value bounds on returned intervals - - Now using Embree for BVH builds for faster build times / volume - commits - - Renamed `vertex.value` and `cell.value` parameters to - `vertex.data` and `cell.data`, respectively - - AMR volumes: - - renamed `block.cellWidth` parameter to `cellWidth`, and - clarified API documentation - - Added `vklGetValueRange()` API for querying volume value ranges - - Added new driver parameters, APIs, and environment variables - allowing user control of log levels, log / error output redirection, - number of threads, and other options - - `vklIterateHit[4,8,16]()` and `vklIterateInterval[4,8,16]()` calls - now only populate hit / interval data for active lanes - - Changed `VKLDataType` enum values for better forward compatibility - - ISPC-side hit and interval iterator objects must now be declared - `varying` - - More flexible ISA build configuration through `OPENVKL_MAX_ISA` and - `OPENVKL_ISA_*` CMake build options - - Minimum ospcommon version is now 1.1.0 +- Added support for structured volumes on spherical grids + (`"structured_spherical"` volume type) +- Structured regular volumes: + - Up to 8x performance improvement for scalar (single-wide) sampling + - Fixed hit iterator bug which could lead to isosurfacing artifacts + - Renamed `voxelData` parameter to `data` +- Unstructured volumes: + - Up to 4x performance improvement for scalar (single-wide) sampling + - Improved interval iterator implementation for more efficient space + skipping and tighter value bounds on returned intervals + - Now using Embree for BVH builds for faster build times / volume + commits + - Renamed `vertex.value` and `cell.value` parameters to `vertex.data` + and `cell.data`, respectively +- AMR volumes: + - renamed `block.cellWidth` parameter to `cellWidth`, and clarified + API documentation +- Added `vklGetValueRange()` API for querying volume value ranges +- Added new driver parameters, APIs, and environment variables allowing + user control of log levels, log / error output redirection, number of + threads, and other options +- `vklIterateHit[4,8,16]()` and `vklIterateInterval[4,8,16]()` calls now + only populate hit / interval data for active lanes +- Changed `VKLDataType` enum values for better forward compatibility +- ISPC-side hit and interval iterator objects must now be declared + `varying` +- More flexible ISA build configuration through `OPENVKL_MAX_ISA` and + `OPENVKL_ISA_*` CMake build options +- Minimum ospcommon version is now 1.1.0 ### Open VKL 0.7.0 (alpha) - - Initial public alpha release, with support for structured, - unstructured, and AMR volumes. +- Initial public alpha release, with support for structured, + unstructured, and AMR volumes. ## Support and Contact @@ -431,7 +423,7 @@ to set parameters on the device. The following parameters are understood by all devices: | Type | Name | Description | -| :----- | :------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | +|:-------|:---------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------| | int | logLevel | logging level; valid values are `VKL_LOG_DEBUG`, `VKL_LOG_INFO`, `VKL_LOG_WARNING`, `VKL_LOG_ERROR` and `VKL_LOG_NONE` | | string | logOutput | convenience for setting where log messages go; valid values are `cout`, `cerr` and `none` | | string | errorOutput | convenience for setting where error messages go; valid values are `cout`, `cerr` and `none` | @@ -477,13 +469,13 @@ variables for easy changes to Open VKL’s behavior without needing to change the application (variables are prefixed by convention with “`OPENVKL_`”): -| Variable | Description | -| :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| OPENVKL\_LOG\_LEVEL | logging level; valid values are `debug`, `info`, `warning`, `error` and `none` | -| OPENVKL\_LOG\_OUTPUT | convenience for setting where log messages go; valid values are `cout`, `cerr` and `none` | -| OPENVKL\_ERROR\_OUTPUT | convenience for setting where error messages go; valid values are `cout`, `cerr` and `none` | -| OPENVKL\_THREADS | number of threads which Open VKL can use | -| OPENVKL\_FLUSH\_DENORMALS | sets the `Flush to Zero` and `Denormals are Zero` mode of the MXCSR control and status register (default: 1); see Performance Recommendations section for details | +| Variable | Description | +|:------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| OPENVKL_LOG_LEVEL | logging level; valid values are `debug`, `info`, `warning`, `error` and `none` | +| OPENVKL_LOG_OUTPUT | convenience for setting where log messages go; valid values are `cout`, `cerr` and `none` | +| OPENVKL_ERROR_OUTPUT | convenience for setting where error messages go; valid values are `cout`, `cerr` and `none` | +| OPENVKL_THREADS | number of threads which Open VKL can use | +| OPENVKL_FLUSH_DENORMALS | sets the `Flush to Zero` and `Denormals are Zero` mode of the MXCSR control and status register (default: 1); see Performance Recommendations section for details | Environment variables understood by all devices. @@ -501,14 +493,14 @@ variable is ignored. The following errors are currently used by Open VKL: -| Name | Description | -| :---------------------- | :---------------------------------------------------- | -| VKL\_NO\_ERROR | no error occurred | -| VKL\_UNKNOWN\_ERROR | an unknown error occurred | -| VKL\_INVALID\_ARGUMENT | an invalid argument was specified | -| VKL\_INVALID\_OPERATION | the operation is not allowed for the specified object | -| VKL\_OUT\_OF\_MEMORY | there is not enough memory to execute the command | -| VKL\_UNSUPPORTED\_CPU | the CPU is not supported (minimum ISA is SSE4.1) | +| Name | Description | +|:----------------------|:------------------------------------------------------| +| VKL_NO_ERROR | no error occurred | +| VKL_UNKNOWN_ERROR | an unknown error occurred | +| VKL_INVALID_ARGUMENT | an invalid argument was specified | +| VKL_INVALID_OPERATION | the operation is not allowed for the specified object | +| VKL_OUT_OF_MEMORY | there is not enough memory to execute the command | +| VKL_UNSUPPORTED_CPU | the CPU is not supported (minimum ISA is SSE4.1) | Possible error codes, i.e., valid named constants of type `VKLError`. @@ -676,11 +668,12 @@ VKLData vklNewData(VKLDevice device, size_t byteStride); ``` -Data objects can be created as Open VKL owned (`dataCreationFlags = -VKL_DATA_DEFAULT`), in which the library will make a copy of the data -for its use, or shared (`dataCreationFlags = VKL_DATA_SHARED_BUFFER`), -which will try to use the passed pointer for usage. The library is -allowed to copy data when a volume is committed. +Data objects can be created as Open VKL owned +(`dataCreationFlags = VKL_DATA_DEFAULT`), in which the library will make +a copy of the data for its use, or shared +(`dataCreationFlags = VKL_DATA_SHARED_BUFFER`), which will try to use +the passed pointer for usage. The library is allowed to copy data when a +volume is committed. The distance between consecutive elements in `source` is given in bytes with `byteStride`. If the provided `byteStride` is zero, then it will be @@ -696,29 +689,29 @@ can be represented in Open VKL. The types accepted vary per volume; see the volume section for specifics. Valid constants are listed in the table below. -| Type/Name | Description | -| :----------------------------- | :------------------------------------------------------------------------------------------- | -| VKL\_DEVICE | API device object reference | -| VKL\_DATA | data reference | -| VKL\_OBJECT | generic object reference | -| VKL\_VOLUME | volume object reference | -| VKL\_STRING | C-style zero-terminated character string | -| VKL\_CHAR, VKL\_VEC\[234\]C | 8 bit signed character scalar and \[234\]-element vector | -| VKL\_UCHAR, VKL\_VEC\[234\]UC | 8 bit unsigned character scalar and \[234\]-element vector | -| VKL\_SHORT, VKL\_VEC\[234\]S | 16 bit unsigned integer scalar and \[234\]-element vector | -| VKL\_USHORT, VKL\_VEC\[234\]US | 16 bit unsigned integer scalar and \[234\]-element vector | -| VKL\_INT, VKL\_VEC\[234\]I | 32 bit signed integer scalar and \[234\]-element vector | -| VKL\_UINT, VKL\_VEC\[234\]UI | 32 bit unsigned integer scalar and \[234\]-element vector | -| VKL\_LONG, VKL\_VEC\[234\]L | 64 bit signed integer scalar and \[234\]-element vector | -| VKL\_ULONG, VKL\_VEC\[234\]UL | 64 bit unsigned integer scalar and \[234\]-element vector | -| VKL\_HALF, VKL\_VEC\[234\]H | 16 bit half precision floating-point scalar and \[234\]-element vector (IEEE 754 `binary16`) | -| VKL\_FLOAT, VKL\_VEC\[234\]F | 32 bit single precision floating-point scalar and \[234\]-element vector | -| VKL\_DOUBLE, VKL\_VEC\[234\]D | 64 bit double precision floating-point scalar and \[234\]-element vector | -| VKL\_BOX\[1234\]I | 32 bit integer box (lower + upper bounds) | -| VKL\_BOX\[1234\]F | 32 bit single precision floating-point box (lower + upper bounds) | -| VKL\_LINEAR\[23\]F | 32 bit single precision floating-point linear transform (\[23\] vectors) | -| VKL\_AFFINE\[23\]F | 32 bit single precision floating-point affine transform (linear transform plus translation) | -| VKL\_VOID\_PTR | raw memory address | +| Type/Name | Description | +|:-----------------------------|:---------------------------------------------------------------------------------------------| +| VKL_DEVICE | API device object reference | +| VKL_DATA | data reference | +| VKL_OBJECT | generic object reference | +| VKL_VOLUME | volume object reference | +| VKL_STRING | C-style zero-terminated character string | +| VKL_CHAR, VKL_VEC\[234\]C | 8 bit signed character scalar and \[234\]-element vector | +| VKL_UCHAR, VKL_VEC\[234\]UC | 8 bit unsigned character scalar and \[234\]-element vector | +| VKL_SHORT, VKL_VEC\[234\]S | 16 bit unsigned integer scalar and \[234\]-element vector | +| VKL_USHORT, VKL_VEC\[234\]US | 16 bit unsigned integer scalar and \[234\]-element vector | +| VKL_INT, VKL_VEC\[234\]I | 32 bit signed integer scalar and \[234\]-element vector | +| VKL_UINT, VKL_VEC\[234\]UI | 32 bit unsigned integer scalar and \[234\]-element vector | +| VKL_LONG, VKL_VEC\[234\]L | 64 bit signed integer scalar and \[234\]-element vector | +| VKL_ULONG, VKL_VEC\[234\]UL | 64 bit unsigned integer scalar and \[234\]-element vector | +| VKL_HALF, VKL_VEC\[234\]H | 16 bit half precision floating-point scalar and \[234\]-element vector (IEEE 754 `binary16`) | +| VKL_FLOAT, VKL_VEC\[234\]F | 32 bit single precision floating-point scalar and \[234\]-element vector | +| VKL_DOUBLE, VKL_VEC\[234\]D | 64 bit double precision floating-point scalar and \[234\]-element vector | +| VKL_BOX\[1234\]I | 32 bit integer box (lower + upper bounds) | +| VKL_BOX\[1234\]F | 32 bit single precision floating-point box (lower + upper bounds) | +| VKL_LINEAR\[23\]F | 32 bit single precision floating-point linear transform (\[23\] vectors) | +| VKL_AFFINE\[23\]F | 32 bit single precision floating-point affine transform (linear transform plus translation) | +| VKL_VOID_PTR | raw memory address | Valid named constants for `VKLDataType`. @@ -824,8 +817,8 @@ their addresses in memory can be easily computed from a 3D position. Data can be provided either per cell or per vertex (the default), selectable via the `cellCentered` parameter. This parameter also affects the interpretation of the volume’s dimensions, which will be in units of -cells or vertices, respectively. A volume with \((x, y, z)\) vertices -will have \((x-1, y-1, z-1)\) cells. +cells or vertices, respectively. A volume with $(x, y, z)$ vertices will +have $(x-1, y-1, z-1)$ cells. #### Structured Regular Volumes @@ -835,8 +828,8 @@ parameters understood by structured regular volumes are summarized in the table below. | Type | Name | Default | Description | -| :-------------------- | :------------------------------- | :--------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| vec3i | dimensions | | number of values in each dimension \((x, y, z)\) | +|:----------------------|:---------------------------------|:-----------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| vec3i | dimensions | | number of values in each dimension $(x, y, z)$ | | VKLData VKLData\[\] | data | | VKLData object(s) of volume data, supported types are: | | | | | `VKL_UCHAR` | | | | | `VKL_SHORT` | @@ -846,10 +839,10 @@ the table below. | | | | `VKL_DOUBLE` | | | | | Multiple attributes are supported through passing an array of VKLData objects. | | bool | cellCentered | false | indicates if data is provided per cell (true) or per vertex (false) | -| vec3f | gridOrigin | \((0, 0, 0)\) | origin of the grid in object space | -| vec3f | gridSpacing | \((1, 1, 1)\) | size of the grid cells in object space | +| vec3f | gridOrigin | $(0, 0, 0)$ | origin of the grid in object space | +| vec3f | gridSpacing | $(1, 1, 1)$ | size of the grid cells in object space | | affine3f | indexToObject | 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 | Defines the transformation from index space to object space. In index space, the grid is an axis-aligned regular grid, and grid cells have size (1,1,1). This parameter takes precedence over `gridOrigin` and `gridSpacing`, if provided. | -| vec3i | indexOrigin | \((0, 0, 0)\) | Defines the index space origin of the volume. This translation is applied before any (`gridOrigin`, `gridSpacing`) or `indexToObject` transformation. | +| vec3i | indexOrigin | $(0, 0, 0)$ | Defines the index space origin of the volume. This translation is applied before any (`gridOrigin`, `gridSpacing`) or `indexToObject` transformation. | | uint32 | temporalFormat | `VKL_TEMPORAL_FORMAT_CONSTANT` | The temporal format for this volume. Use `VKLTemporalFormat` for named constants. Structured regular volumes support `VKL_TEMPORAL_FORMAT_CONSTANT`, `VKL_TEMPORAL_FORMAT_STRUCTURED`, and `VKL_TEMPORAL_FORMAT_UNSTRUCTURED`. | | int | temporallyStructuredNumTimesteps | | For temporally structured variation, number of timesteps per voxel. Only valid if `temporalFormat` is `VKL_TEMPORAL_FORMAT_STRUCTURED`. | | uint32\[\] uint64\[\] | temporallyUnstructuredIndices | | For temporally unstructured variation, indices to `data` time series beginning per voxel. Only valid if `temporalFormat` is `VKL_TEMPORAL_FORMAT_UNSTRUCTURED`. | @@ -868,7 +861,7 @@ The following additional parameters can be set both on parameters default to volume parameters. | Type | Name | Default | Description | -| :--- | :------------- | :--------------------- | :-------------------------------------------------------------------------------------------------------------- | +|:-----|:---------------|:-----------------------|:----------------------------------------------------------------------------------------------------------------| | int | filter | `VKL_FILTER_TRILINEAR` | The filter used for reconstructing the field. Use `VKLFilter` for named constants. | | int | gradientFilter | `filter` | The filter used for reconstructing the field during gradient computations. Use `VKLFilter` for named constants. | @@ -882,26 +875,26 @@ Structured regular volumes support the filter types for both `filter` and `gradientFilter`. Note that when `gradientFilter` is set to `VKL_FILTER_NEAREST`, -gradients are always \((0, 0, 0)\). +gradients are always $(0, 0, 0)$. #### Structured Spherical Volumes Structured spherical volumes are also supported, which are created by passing a type string of `"structuredSpherical"` to `vklNewVolume`. The grid dimensions and parameters are defined in terms of radial distance -(\(r\)), inclination angle (\(\theta\)), and azimuthal angle (\(\phi\)), +($r$), inclination angle ($\theta$), and azimuthal angle ($\phi$), conforming with the ISO convention for spherical coordinate systems. Structured spherical volumes currently only support vertex-centered data. The coordinate system and parameters understood by structured spherical volumes are summarized below. -![Structured spherical volume coordinate system: radial distance -(\(r\)), inclination angle (\(\theta\)), and azimuthal angle -(\(\phi\)).](https://openvkl.github.io/images/structured_spherical_coords.png) +![Structured spherical volume coordinate system: radial distance ($r$), +inclination angle ($\theta$), and azimuthal angle +($\phi$).](https://openvkl.github.io/images/structured_spherical_coords.png) | Type | Name | Default | Description | -| :------------------ | :---------- | :------------------------: | :---------------------------------------------------------------------------------------------------------- | -| vec3i | dimensions | | number of voxels in each dimension \((r, \theta, \phi)\) | +|:--------------------|:------------|:--------------------------:|:------------------------------------------------------------------------------------------------------------| +| vec3i | dimensions | | number of voxels in each dimension $(r, \theta, \phi)$ | | VKLData VKLData\[\] | data | | VKLData object(s) of voxel data, supported types are: | | | | | `VKL_UCHAR` | | | | | `VKL_SHORT` | @@ -910,8 +903,8 @@ spherical volumes are summarized below. | | | | `VKL_FLOAT` | | | | | `VKL_DOUBLE` | | | | | Multiple attributes are supported through passing an array of VKLData objects. | -| vec3f | gridOrigin | \((0, 0, 0)\) | origin of the grid in units of \((r, \theta, \phi)\); angles in degrees | -| vec3f | gridSpacing | \((1, 1, 1)\) | size of the grid cells in units of \((r, \theta, \phi)\); angles in degrees | +| vec3f | gridOrigin | $(0, 0, 0)$ | origin of the grid in units of $(r, \theta, \phi)$; angles in degrees | +| vec3f | gridSpacing | $(1, 1, 1)$ | size of the grid cells in units of $(r, \theta, \phi)$; angles in degrees | | float\[\] | background | `VKL_BACKGROUND_UNDEFINED` | For each attribute, the value that is returned when sampling an undefined region outside the volume domain. | Configuration parameters for structured spherical @@ -920,19 +913,19 @@ Configuration parameters for structured spherical These grid parameters support flexible specification of spheres, hemispheres, spherical shells, spherical wedges, and so forth. The grid extents (computed as -\([gridOrigin, gridOrigin + (dimensions - 1) * gridSpacing]\)) however +$[gridOrigin, gridOrigin + (dimensions - 1) * gridSpacing]$) however must be constrained such that: - - \(r \geq 0\) - - \(0 \leq \theta \leq 180\) - - \(0 \leq \phi \leq 360\) +- $r \geq 0$ +- $0 \leq \theta \leq 180$ +- $0 \leq \phi \leq 360$ The following additional parameters can be set both on `"structuredSpherical"` volumes and their sampler objects. Sampler object parameters default to volume parameters. | Type | Name | Default | Description | -| :--- | :------------- | :--------------------- | :-------------------------------------------------------------------------------------------------------------- | +|:-----|:---------------|:-----------------------|:----------------------------------------------------------------------------------------------------------------| | int | filter | `VKL_FILTER_TRILINEAR` | The filter used for reconstructing the field. Use `VKLFilter` for named constants. | | int | gradientFilter | `filter` | The filter used for reconstructing the field during gradient computations. Use `VKLFilter` for named constants. | @@ -962,13 +955,13 @@ AMR volumes are created by passing the type string `"amr"` to `vklNewVolume`, and have the following parameters: | Type | Name | Default | Description | -| :---------- | :----------- | :------------------------- | :----------------------------------------------------------------------------------------------------------------------------------- | +|:------------|:-------------|:---------------------------|:-------------------------------------------------------------------------------------------------------------------------------------| | float\[\] | cellWidth | | \[data\] array of each level’s cell width | | box3i\[\] | block.bounds | | \[data\] array of each block’s bounds (in voxels) | | int\[\] | block.level | | \[data\] array of each block’s refinement level | | VKLData\[\] | block.data | | \[data\] array of each block’s VKLData object containing the actual scalar voxel data. Currently only `VKL_FLOAT` data is supported. | -| vec3f | gridOrigin | \((0, 0, 0)\) | origin of the grid in object space | -| vec3f | gridSpacing | \((1, 1, 1)\) | size of the grid cells in object space | +| vec3f | gridOrigin | $(0, 0, 0)$ | origin of the grid in object space | +| vec3f | gridSpacing | $(1, 1, 1)$ | size of the grid cells in object space | | float | background | `VKL_BACKGROUND_UNDEFINED` | The value that is returned when sampling an undefined region outside the volume domain. | Configuration parameters for AMR (`"amr"`) volumes. @@ -982,7 +975,7 @@ and their sampler objects. Sampler object parameters default to volume parameters. | Type | Name | Default | Description | -| :------------- | :----- | ----------------: | :----------------------------------------------------- | +|:---------------|:-------|------------------:|:-------------------------------------------------------| | `VKLAMRMethod` | method | `VKL_AMR_CURRENT` | `VKLAMRMethod` sampling method. Supported methods are: | | | | | `VKL_AMR_CURRENT` | | | | | `VKL_AMR_FINEST` | @@ -995,14 +988,14 @@ Open VKL’s AMR implementation was designed to cover Berger-Colella \[1\] and Chombo \[2\] AMR data. The `method` parameter above determines the interpolation method used when sampling the volume. - - `VKL_AMR_CURRENT` finds the finest refinement level at that cell and - interpolates through this “current” level - - `VKL_AMR_FINEST` will interpolate at the closest existing cell in - the volume-wide finest refinement level regardless of the sample - cell’s level - - `VKL_AMR_OCTANT` interpolates through all available refinement - levels at that cell. This method avoids discontinuities at - refinement level boundaries at the cost of performance +- `VKL_AMR_CURRENT` finds the finest refinement level at that cell and + interpolates through this “current” level +- `VKL_AMR_FINEST` will interpolate at the closest existing cell in the + volume-wide finest refinement level regardless of the sample cell’s + level +- `VKL_AMR_OCTANT` interpolates through all available refinement levels + at that cell. This method avoids discontinuities at refinement level + boundaries at the cost of performance Gradients are computed using finite differences, using the `method` defined on the sampler. @@ -1056,9 +1049,9 @@ vertex. To maintain VTK data compatibility, the `index` array may be specified with cell sizes interleaved with vertex indices in the following format: -\(n, id_1, ..., id_n, m, id_1, ..., id_m\). This alternative `index` -array layout can be enabled through the `indexPrefixed` flag (in which -case, the `cell.type` parameter should be omitted). +$n, id_1, ..., id_n, m, id_1, ..., id_m$. This alternative `index` array +layout can be enabled through the `indexPrefixed` flag (in which case, +the `cell.type` parameter should be omitted). Gradients are computed using finite differences. @@ -1066,7 +1059,7 @@ Unstructured volumes are created by passing the type string `"unstructured"` to `vklNewVolume`, and have the following parameters: | Type | Name | Default | Description | -| :---------------------- | :----------------- | :------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------ | +|:------------------------|:-------------------|:---------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------| | vec3f\[\] | vertex.position | | \[data\] array of vertex positions | | float\[\] | vertex.data | | \[data\] array of vertex data values to be sampled | | uint32\[\] / uint64\[\] | index | | \[data\] array of indices (into the vertex array(s)) that form cells | @@ -1112,19 +1105,19 @@ interpretation. The VDB implementation in Open VKL follows the following goals: - - Efficient data structure traversal on vector architectures. +- Efficient data structure traversal on vector architectures. - - Enable the use of industry-standard .vdb files created through the - OpenVDB library. +- Enable the use of industry-standard .vdb files created through the + OpenVDB library. - - Compatibility with OpenVDB on a leaf data level, so that .vdb files - may be loaded with minimal overhead. +- Compatibility with OpenVDB on a leaf data level, so that .vdb files + may be loaded with minimal overhead. VDB volumes are created by passing the type string `"vdb"` to `vklNewVolume`, and have the following parameters: | Type | Name | Default | Description | -| :----------------- | :------------------------------------ | :--------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +|:-------------------|:--------------------------------------|:-----------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | affine3f float\[\] | indexToObject | 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 | Defines the transformation from index space to object space. In index space, the grid is an axis-aligned regular grid, and leaf voxels have size (1,1,1). A `vkl_affine3f` can be provided; alternatively an array of 12 values of type `float` can be used, where the first 9 values are interpreted as a row-major linear transformation matrix, and the last 3 values are the translation of the grid origin. | | uint32\[\] | node.format | | For each input node, the data format. Currently supported are `VKL_FORMAT_TILE` for tiles, and `VKL_FORMAT_DENSE_ZYX` for nodes that are dense regular grids. | | uint32\[\] | node.level | | For each input node, the level on which this node exists. Tiles may exist on levels \[1, `VKL_VDB_NUM_LEVELS-1`\], all other nodes may only exist on level `VKL_VDB_NUM_LEVELS-1`. | @@ -1155,7 +1148,7 @@ their sampler objects (sampler object parameters default to volume parameters). | Type | Name | Default | Description | -| :--- | :--------------- | :--------------------- | :-------------------------------------------------------------------------------------------------------------- | +|:-----|:-----------------|:-----------------------|:----------------------------------------------------------------------------------------------------------------| | int | filter | `VKL_FILTER_TRILINEAR` | The filter used for reconstructing the field. Use `VKLFilter` for named constants. | | int | gradientFilter | `filter` | The filter used for reconstructing the field during gradient computations. Use `VKLFilter` for named constants. | | int | maxSamplingDepth | `VKL_VDB_NUM_LEVELS`-1 | Do not descend further than to this depth during sampling. | @@ -1166,7 +1159,7 @@ objects. VDB volume objects support the following observers: | Name | Buffer Type | Description | -| :-------- | ----------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +|:----------|-------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | InnerNode | float\[\] | Return an array of bounding boxes, along with value ranges, of inner nodes in the data structure. The bounding box is given in object space. For a volume with M attributes, the entries in this array are (6+2\*M)-tuples `(minX, minY, minZ, maxX, maxY, maxZ, lower_0, upper_0, lower_1, upper_1, ...)`. This is in effect a low resolution representation of the volume. The InnerNode observer can be parametrized using `int maxDepth` to control the depth at which inner nodes are returned. Note that the observer will also return leaf nodes or tiles at lower levels if they exist. | Observers supported by VDB (`"vdb"`) volumes. @@ -1174,7 +1167,7 @@ Observers supported by VDB (`"vdb"`) volumes. VDB sampler objects support the following observers: | Name | Buffer Type | Description | -| :------------- | :---------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +|:---------------|:------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | LeafNodeAccess | uint32\[\] | This observer returns an array with as many entries as input nodes were passed. If the input node i was accessed during traversal, then the ith entry in this array has a nonzero value. This can be used for on-demand loading of leaf nodes. | Observers supported by sampler objects created on VDB (`"vdb"`) volumes. @@ -1186,39 +1179,39 @@ VDB volumes support the filter types `VKL_FILTER_NEAREST`, `gradientFilter`. Note that when `gradientFilter` is set to `VKL_FILTER_NEAREST`, -gradients are always \((0, 0, 0)\). +gradients are always $(0, 0, 0)$. #### Major differences to OpenVDB - - Open VKL implements sampling in ISPC, and can exploit wide SIMD - architectures. - - - VDB volumes in Open VKL are read-only once committed, and designed - for rendering only. Authoring or manipulating datasets is not in the - scope of this implementation. - - - The only supported field types are `VKL_HALF` and `VKL_FLOAT` at - this point. Other field types may be supported in the future. Note - that multi-attribute volumes may be used to represent - multi-component (e.g. vector) fields. - - - The root level in Open VKL has a single node with resolution 64^3 - (cp. \[1\]. OpenVDB uses a hash map, instead). - - - Open VKL supports four-level vdb volumes. The resolution of each - level can be configured at compile time using CMake variables. - - - `VKL_VDB_LOG_RESOLUTION_0` sets the base 2 logarithm of the root - level resolution. This variable defaults to 6, which means that - the root level has a resolution of \((2^6)^3 = 64^3\). - - `VKL_VDB_LOG_RESOLUTION_1` and `VKL_VDB_LOG_RESOLUTION_2` - default to 5 and 4, respectively. This matches the default Open - VDB resolution for inner levels. - - `VKL_VDB_LOG_RESOLUTION_3` set the base 2 logarithm of the leaf - level resolution, and defaults to 3. Therefore, leaf nodes have - a resolution of \(8^3\) voxels. Again, this matches the Open VDB - default. The default settings lead to a domain resolution of - \(2^18^3=262144^3\) voxels. +- Open VKL implements sampling in ISPC, and can exploit wide SIMD + architectures. + +- VDB volumes in Open VKL are read-only once committed, and designed for + rendering only. Authoring or manipulating datasets is not in the scope + of this implementation. + +- The only supported field types are `VKL_HALF` and `VKL_FLOAT` at this + point. Other field types may be supported in the future. Note that + multi-attribute volumes may be used to represent multi-component + (e.g. vector) fields. + +- The root level in Open VKL has a single node with resolution 64^3 + (cp. \[1\]. OpenVDB uses a hash map, instead). + +- Open VKL supports four-level vdb volumes. The resolution of each level + can be configured at compile time using CMake variables. + + - `VKL_VDB_LOG_RESOLUTION_0` sets the base 2 logarithm of the root + level resolution. This variable defaults to 6, which means that the + root level has a resolution of $(2^6)^3 = 64^3$. + - `VKL_VDB_LOG_RESOLUTION_1` and `VKL_VDB_LOG_RESOLUTION_2` default to + 5 and 4, respectively. This matches the default Open VDB resolution + for inner levels. + - `VKL_VDB_LOG_RESOLUTION_3` set the base 2 logarithm of the leaf + level resolution, and defaults to 3. Therefore, leaf nodes have a + resolution of $8^3$ voxels. Again, this matches the Open VDB + default. The default settings lead to a domain resolution of + $2^18^3=262144^3$ voxels. #### Loading OpenVDB .vdb files @@ -1268,7 +1261,7 @@ Particle volumes are created by passing the type string `"particle"` to `vklNewVolume`, and have the following parameters: | Type | Name | Default | Description | -| :-------- | :---------------------- | :------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +|:----------|:------------------------|:--------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | vec3f\[\] | particle.position | | \[data\] array of particle positions | | float\[\] | particle.radius | | \[data\] array of particle radii | | float\[\] | particle.weight | null | \[data\] (optional) array of particle weights, specifying the height of the kernel. | @@ -1315,22 +1308,22 @@ Temporally structured variation is configured by setting volume expects an additional parameter `[node.]temporallyStructuredNumTimesteps`, which specifies how many time steps are provided for all voxels, and must be at least 2. A volume, or -node, with \(N\) voxels expects \(N * temporallyStructuredNumTimesteps\) +node, with $N$ voxels expects $N * temporallyStructuredNumTimesteps$ values for each attribute. The values are assumed evenly spaced over -times \([0, 1]\): \(\{0, 1/(N-1), ..., 1\}\) +times $[0, 1]$: $\{0, 1/(N-1), ..., 1\}$ Temporally unstructured variation supports differing time step counts -and sample times per voxel. For \(N\) input voxels, -`temporallyUnstructuredIndices` is an array of \(N+1\) indices. Voxel -\(i\) has -\(N_i = [temporallyUnstructuredIndices[i+1]-temporallyUnstructuredIndices[i])\) -temporal samples starting at index \(temporallyUnstructuredIndices[i]\). +and sample times per voxel. For $N$ input voxels, +`temporallyUnstructuredIndices` is an array of $N+1$ indices. Voxel $i$ +has +$N_i = [temporallyUnstructuredIndices[i+1]-temporallyUnstructuredIndices[i])$ +temporal samples starting at index $temporallyUnstructuredIndices[i]$. `temporallyUnstructuredTimes` specifies the times corresponding to the sample values; the time values for each voxel must be between zero and -one and strictly increasing: \(t0 < t1 < ... < tN\). To return a value -at sample time t, \(t0 <= t <= tN\), Open VKL will interpolate linearly -from the two nearest time steps. Time values outside this range are -clamped to \([t0, tN]\). +one and strictly increasing: $t0 < t1 < ... < tN$. To return a value at +sample time t, $t0 <= t <= tN$, Open VKL will interpolate linearly from +the two nearest time steps. Time values outside this range are clamped +to $[t0, tN]$. ## Sampler Objects @@ -1582,11 +1575,11 @@ VKLIntervalIteratorContext vklNewIntervalIteratorContext(VKLSampler sampler); The parameters understood by interval iterator contexts are defined in the table below. -| Type | Name | Default | Description | -| :--------------- | :--------------------- | :------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| int | attributeIndex | 0 | Defines the volume attribute of interest. | -| vkl\_range1f\[\] | valueRanges | \[-inf, inf\] | Defines the value ranges of interest. Intervals not containing any of these values ranges may be skipped during iteration. | -| float | intervalResolutionHint | 0.5 | A value in the range \[0, 1\] affecting the resolution (size) of returned intervals. A value of 0 yields the lowest resolution (largest) intervals while 1 gives the highest resolution (smallest) intervals. This value is only a hint; it may not impact behavior for all volume types. | +| Type | Name | Default | Description | +|:----------------|:-----------------------|:--------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| int | attributeIndex | 0 | Defines the volume attribute of interest. | +| vkl_range1f\[\] | valueRanges | \[-inf, inf\] | Defines the value ranges of interest. Intervals not containing any of these values ranges may be skipped during iteration. | +| float | intervalResolutionHint | 0.5 | A value in the range \[0, 1\] affecting the resolution (size) of returned intervals. A value of 0 yields the lowest resolution (largest) intervals while 1 gives the highest resolution (smallest) intervals. This value is only a hint; it may not impact behavior for all volume types. | Configuration parameters for interval iterator contexts. @@ -1752,7 +1745,7 @@ The parameters understood by hit iterator contexts are defined in the table below. | Type | Name | Default | Description | -| :-------- | :------------- | :------ | :---------------------------------------- | +|:----------|:---------------|:--------|:------------------------------------------| | int | attributeIndex | 0 | Defines the volume attribute of interest. | | float\[\] | values | | Defines the value(s) of interest. | @@ -1877,17 +1870,18 @@ lifted in the future. ## MXCSR control and status register -It is strongly recommended to have the `Flush to Zero` and `Denormals -are Zero` mode of the MXCSR control and status register enabled for each -thread before calling the sampling, gradient, or interval API functions. -Otherwise, under some circumstances special handling of denormalized -floating point numbers can significantly reduce application and Open VKL -performance. The device parameter `flushDenormals` or environment -variable `OPENVKL_FLUSH_DENORMALS` can be used to toggle this mode; by -default it is enabled. Alternatively, when using Open VKL together with -the Intel® Threading Building Blocks, it is sufficient to execute the -following code at the beginning of the application main thread (before -the creation of the `tbb::task_scheduler_init` object): +It is strongly recommended to have the `Flush to Zero` and +`Denormals are Zero` mode of the MXCSR control and status register +enabled for each thread before calling the sampling, gradient, or +interval API functions. Otherwise, under some circumstances special +handling of denormalized floating point numbers can significantly reduce +application and Open VKL performance. The device parameter +`flushDenormals` or environment variable `OPENVKL_FLUSH_DENORMALS` can +be used to toggle this mode; by default it is enabled. Alternatively, +when using Open VKL together with the Intel® Threading Building Blocks, +it is sufficient to execute the following code at the beginning of the +application main thread (before the creation of the +`tbb::task_scheduler_init` object): ``` cpp #include @@ -2046,12 +2040,12 @@ Simple tutorials can be found in the [`examples/`](https://github.com/openvkl/openvkl/tree/master/examples) directory. These are: - - [`vklTutorial.c`](https://github.com/openvkl/openvkl/blob/master/examples/vklTutorial.c): - usage of the C API - - [`vklTutorialISPC.cpp`](https://github.com/openvkl/openvkl/blob/master/examples/ispc/vklTutorialISPC.cpp) - and - [`vklTutorialISPC.ispc`](https://github.com/openvkl/openvkl/blob/master/examples/ispc/vklTutorialISPC.ispc) - : combined usage of the C and ISPC APIs +- [`vklTutorial.c`](https://github.com/openvkl/openvkl/blob/master/examples/vklTutorial.c): + usage of the C API +- [`vklTutorialISPC.cpp`](https://github.com/openvkl/openvkl/blob/master/examples/ispc/vklTutorialISPC.cpp) + and + [`vklTutorialISPC.ispc`](https://github.com/openvkl/openvkl/blob/master/examples/ispc/vklTutorialISPC.ispc) + : combined usage of the C and ISPC APIs ## Interactive examples @@ -2485,26 +2479,26 @@ branch should always point to the latest tested bugfix release. Open VKL currently supports Linux, Mac OS X, and Windows. In addition, before you can build Open VKL you need the following prerequisites: - - You can clone the latest Open VKL sources via: - - git clone https://github.com/openvkl/openvkl.git +- You can clone the latest Open VKL sources via: - - To build Open VKL you need [CMake](http://www.cmake.org), any form - of C++11 compiler (we recommend using GCC, but also support Clang - and MSVC), and standard Linux development tools. To build the - examples, you should also have some version of OpenGL. + git clone https://github.com/openvkl/openvkl.git - - Additionally you require a copy of the [Intel® Implicit SPMD Program - Compiler (Intel® ISPC)](http://ispc.github.io), version 1.18.0 or - later. Please obtain a release of ISPC from the [ISPC downloads - page](https://ispc.github.io/downloads.html). +- To build Open VKL you need [CMake](http://www.cmake.org), any form of + C++11 compiler (we recommend using GCC, but also support Clang and + MSVC), and standard Linux development tools. To build the examples, + you should also have some version of OpenGL. - - Open VKL depends on the Intel RenderKit common library, rkcommon. - rkcommon is available at the [rkcommon GitHub - repository](https://github.com/ospray/rkcommon). +- Additionally you require a copy of the [Intel® Implicit SPMD Program + Compiler (Intel® ISPC)](http://ispc.github.io), version 1.18.0 or + later. Please obtain a release of ISPC from the [ISPC downloads + page](https://ispc.github.io/downloads.html). - - Open VKL depends on Embree, which is available at the [Embree GitHub - repository](https://github.com/embree/embree). +- Open VKL depends on the Intel RenderKit common library, rkcommon. + rkcommon is available at the [rkcommon GitHub + repository](https://github.com/ospray/rkcommon). + +- Open VKL depends on Embree, which is available at the [Embree GitHub + repository](https://github.com/embree/embree). Depending on your Linux distribution you can install these dependencies using `yum` or `apt-get`. Some of these packages might already be @@ -2531,14 +2525,14 @@ subdirectory per dependency. CMake options to note (all have sensible defaults): - - `CMAKE_INSTALL_PREFIX` will be the root directory where everything - gets installed. - - `BUILD_JOBS` sets the number given to `make -j` for parallel builds. - - `INSTALL_IN_SEPARATE_DIRECTORIES` toggles installation of all - libraries in separate or the same directory. - - `BUILD_TBB_FROM_SOURCE` specifies whether TBB should be built from - source or the releases on Gitub should be used. This must be ON when - compiling for ARM. +- `CMAKE_INSTALL_PREFIX` will be the root directory where everything + gets installed. +- `BUILD_JOBS` sets the number given to `make -j` for parallel builds. +- `INSTALL_IN_SEPARATE_DIRECTORIES` toggles installation of all + libraries in separate or the same directory. +- `BUILD_TBB_FROM_SOURCE` specifies whether TBB should be built from + source or the releases on Gitub should be used. This must be ON when + compiling for ARM. For the full set of options, run `ccmake [/superbuild]`. @@ -2547,39 +2541,39 @@ For the full set of options, run `ccmake [/superbuild]`. Assuming the above prerequisites are all fulfilled, building Open VKL through CMake is easy: - - Create a build directory, and go into it - - mkdir openvkl/build - cd openvkl/build - - (We do recommend having separate build directories for different - configurations such as release, debug, etc.). - - - The compiler CMake will use will default to whatever the `CC` and - `CXX` environment variables point to. Should you want to specify a - different compiler, run cmake manually while specifying the desired - compiler. The default compiler on most linux machines is `gcc`, but - it can be pointed to `clang` instead by executing the following: - - cmake -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang .. - - CMake will now use Clang instead of GCC. If you are ok with using - the default compiler on your system, then simply skip this step. - Note that the compiler variables cannot be changed after the first - `cmake` or `ccmake` run. - - - Open the CMake configuration dialog - - ccmake .. - - - Make sure to properly set build mode and enable the components you - need, etc.; then type ’c’onfigure and ’g’enerate. When back on the - command prompt, build it using - - make - - - You should now have `libopenvkl.so` as well as the tutorial / - example applications. +- Create a build directory, and go into it + + mkdir openvkl/build + cd openvkl/build + + (We do recommend having separate build directories for different + configurations such as release, debug, etc.). + +- The compiler CMake will use will default to whatever the `CC` and + `CXX` environment variables point to. Should you want to specify a + different compiler, run cmake manually while specifying the desired + compiler. The default compiler on most linux machines is `gcc`, but it + can be pointed to `clang` instead by executing the following: + + cmake -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang .. + + CMake will now use Clang instead of GCC. If you are ok with using the + default compiler on your system, then simply skip this step. Note that + the compiler variables cannot be changed after the first `cmake` or + `ccmake` run. + +- Open the CMake configuration dialog + + ccmake .. + +- Make sure to properly set build mode and enable the components you + need, etc.; then type ’c’onfigure and ’g’enerate. When back on the + command prompt, build it using + + make + +- You should now have `libopenvkl.so` as well as the tutorial / example + applications. # Projects that make use of Open VKL @@ -2590,13 +2584,13 @@ projects and related information. If you have a project that makes use of Open VKL and would like this to be listed here, please let us know. - - [Intel® OSPRay](http://www.ospray.org), a ray tracing based - rendering engine for high-fidelity visualization +- [Intel® OSPRay](http://www.ospray.org), a ray tracing based rendering + engine for high-fidelity visualization # Projects that are closely related to Open VKL - - The [Intel® oneAPI Rendering - Toolkit](https://software.intel.com/en-us/rendering-framework) +- The [Intel® oneAPI Rendering + Toolkit](https://software.intel.com/en-us/rendering-framework) - - The [Intel® Embree](http://embree.github.io) Ray Tracing Kernel - Framework +- The [Intel® Embree](http://embree.github.io) Ray Tracing Kernel + Framework