Merge pull request #1757 from Idclip/vdb_asserts

Introduce OPENVDB_ASSERT macro to replace cassert usage

Author: Idclip

CMakeLists.txt

@@ -64,29 +64,42 @@ project(OpenVDB LANGUAGES CXX VERSION ${OpenVDB_VERSION})
 include(CMakeDependentOption)
 include(GNUInstallDirs)
 
-# todo epydoc and pdflatex
+# Components
 option(OPENVDB_BUILD_CORE "Enable the core OpenVDB library. Both static and shared versions are enabled by default" ON)
 option(OPENVDB_BUILD_BINARIES "Enable the vdb binaries. Only vdb_print is enabled by default" ON)
 option(OPENVDB_BUILD_PYTHON_MODULE "Build the pyopenvdb Python module" OFF)
 option(OPENVDB_BUILD_UNITTESTS "Build the OpenVDB unit tests" OFF)
 option(OPENVDB_BUILD_DOCS "Build the OpenVDB documentation" OFF)
 option(OPENVDB_BUILD_HOUDINI_PLUGIN "Build the Houdini plugin" OFF)
 option(OPENVDB_BUILD_HOUDINI_ABITESTS "Build the Houdini ABI tests" OFF)
-
+option(OPENVDB_BUILD_MAYA_PLUGIN "Build the Maya plugin" OFF)
 option(OPENVDB_BUILD_AX "Build the OpenVDB AX library. Turns ON if USE_AX is ON." ${USE_AX})
 option(OPENVDB_BUILD_AX_UNITTESTS "Build the OpenVDB AX unit tests" OFF)
-
 option(OPENVDB_BUILD_NANOVDB "Build the NanoVDB library. Turns ON if USE_NANOVDB is ON." ${USE_NANOVDB})
 
-option(OPENVDB_BUILD_MAYA_PLUGIN "Build the Maya plugin" OFF)
-option(OPENVDB_USE_DELAYED_LOADING "Build the core OpenVDB library with delayed-loading." ON)
+# Global options
 option(OPENVDB_ENABLE_RPATH "Build with RPATH information" ON)
+option(OPENVDB_ENABLE_ASSERTS "Build with asserts in OpenVDB code enabled" OFF)
+option(OPENVDB_USE_DELAYED_LOADING "Build the core OpenVDB library with delayed-loading." ON)
 option(OPENVDB_CXX_STRICT "Enable or disable pre-defined compiler warnings" OFF)
-
 cmake_dependent_option(OPENVDB_INSTALL_CMAKE_MODULES
   "Install the provided OpenVDB CMake modules when building the core library"
   ON "OPENVDB_BUILD_CORE" OFF)
+option(USE_CCACHE "Build using Ccache if found on the path" ON)
+# Disable this on Windows due to linker OOM issues:
+#  LNK1248: image size (XXX) exceeds maximum allowable size (FFFFFFFF)
+#    https://github.com/AcademySoftwareFoundation/openvdb/issues/1718
+#    https://github.com/AcademySoftwareFoundation/openvdb/issues/1624
+cmake_dependent_option(USE_EXPLICIT_INSTANTIATION "Use explicit instantiation for all supported classes
+and methods against a pre-defined list of OpenVDB trees. This makes the core library larger and slower
+to compile, but speeds up the compilation of all dependent code by bypassing the expensive template
+instantation." ON "NOT WIN32" OFF)
+option(OPENVDB_FUTURE_DEPRECATION "Generate messages for upcoming deprecation" ON)
+option(OPENVDB_ENABLE_UNINSTALL "Adds a CMake uninstall target." ON)
+option(USE_COLORED_OUTPUT "Always produce ANSI-colored output (GNU/Clang only)." OFF)
 
+# Component dependency options
+cmake_dependent_option(USE_PKGCONFIG "Use pkg-config to search for dependent libraries." ON "NOT WIN32" OFF)
 option(USE_HOUDINI [=[
 Build the library against a Houdini installation. Turns on automatically if OPENVDB_BUILD_HOUDINI_PLUGIN is enabled.
 When enabled, you do not need to provide dependency locations for TBB, Blosc, Imath and OpenEXR. Boost must be
@@ -121,7 +134,6 @@ option(USE_NANOVDB "Use NanoVDB while building openvdb components." ${OPENVDB_BU
 
 cmake_dependent_option(OPENVDB_DISABLE_BOOST_IMPLICIT_LINKING
   "Disable the implicit linking of Boost libraries on Windows" ON "WIN32" OFF)
-option(USE_CCACHE "Build using Ccache if found on the path" ON)
 option(USE_STATIC_DEPENDENCIES [=[
 Only search for and use static libraries. If OFF the shared versions of requried libraries are prioritised, falling
 back to static libraries. Forcing individual static dependencies can be enabled by setting XXX_USE_STATIC_LIBS
@@ -136,20 +148,6 @@ its default system search routine if it cannot find a dependency with the provid
 paths provided through the Xxx_ROOT, supported XXX_INCLUDEDIR/XXX_LIBRARYDIR variables or the SYSTEM_LIBRARY_PATHS
 list will be searched.]=] OFF)
 
-option(OPENVDB_FUTURE_DEPRECATION "Generate messages for upcoming deprecation" ON)
-option(OPENVDB_ENABLE_UNINSTALL "Adds a CMake uninstall target." ON)
-option(USE_COLORED_OUTPUT "Always produce ANSI-colored output (GNU/Clang only)." OFF)
-cmake_dependent_option(USE_PKGCONFIG "Use pkg-config to search for dependent libraries." ON "NOT WIN32" OFF)
-
-# Disable this on Windows due to linker OOM issues:
-#  LNK1248: image size (XXX) exceeds maximum allowable size (FFFFFFFF)
-#    https://github.com/AcademySoftwareFoundation/openvdb/issues/1718
-#    https://github.com/AcademySoftwareFoundation/openvdb/issues/1624
-cmake_dependent_option(USE_EXPLICIT_INSTANTIATION "Use explicit instantiation for all supported classes
-and methods against a pre-defined list of OpenVDB trees. This makes the core library larger and slower
-to compile, but speeds up the compilation of all dependent code by bypassing the expensive template
-instantation." ON "NOT WIN32" OFF)
-
 set(SYSTEM_LIBRARY_PATHS "" CACHE STRING [=[
 A global list of library paths to additionally use into when searching for dependencies.]=])
 set(MSVC_MP_THREAD_COUNT "" CACHE STRING [=[

ci/build.sh

@@ -121,7 +121,15 @@ if HAS_PARM -v || HAS_PARM --verbose; then
     # support older versions of CMake.
     CMAKE_EXTRA+=("-DCMAKE_VERBOSE_MAKEFILE=ON")
 fi
-if HAS_PARM --build-type; then CMAKE_EXTRA+=("-DCMAKE_BUILD_TYPE=${PARMS[--build-type]}"); fi
+if HAS_PARM --build-type; then
+    CMAKE_EXTRA+=("-DCMAKE_BUILD_TYPE=${PARMS[--build-type]}")
+    build_type="${PARMS[--build-type]}"
+    debug="Debug"
+    # Ignore case - if the build-type is Debug, we enable asserts
+    if [ "${build_type,,}" = "${debug,,}" ]; then
+        CMAKE_EXTRA+=("-DOPENVDB_ENABLE_ASSERTS=ON")
+    fi
+fi
 
 # Available components. If a component is not provided it is
 # explicitly set to OFF.

ci/install_windows.sh

@@ -3,6 +3,6 @@
 set -ex
 
 vcpkg update
-vcpkg install zlib libpng openexr tbb gtest blosc glfw3 glew python3 jemalloc \
+vcpkg install zlib libpng openexr tbb gtest cppunit blosc glfw3 glew python3 jemalloc \
     boost-iostreams boost-interprocess boost-algorithm pybind11 \
     --clean-after-build

cmake/config/OpenVDBCXX.cmake

@@ -317,6 +317,9 @@ get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if(NOT _isMultiConfig)
   message(STATUS "CMake Build Type: ${CMAKE_BUILD_TYPE}")
 endif()
+if(OPENVDB_ENABLE_ASSERTS)
+  message(STATUS "OpenVDB asserts are ENABLED")
+endif()
 
 # Intialize extra build type targets where possible
 

openvdb/openvdb/CMakeLists.txt

@@ -375,6 +375,7 @@ set(OPENVDB_LIBRARY_SOURCE_FILES
   points/AttributeSet.cc
   points/StreamCompression.cc
   points/points.cc
+  util/Assert.cc
   util/Formats.cc
 )
 
@@ -543,6 +544,7 @@ set(OPENVDB_LIBRARY_TREE_INCLUDE_FILES
 )
 
 set(OPENVDB_LIBRARY_UTIL_INCLUDE_FILES
+  util/Assert.h
   util/CpuTimer.h
   util/ExplicitInstantiation.h
   util/Formats.h

openvdb/openvdb/Grid.h

@@ -10,9 +10,9 @@
 #include "io/io.h"
 #include "math/Transform.h"
 #include "tree/Tree.h"
+#include "util/Assert.h"
 #include "util/logging.h"
 #include "util/Name.h"
-#include <cassert>
 #include <iostream>
 #include <set>
 #include <type_traits>
@@ -1610,7 +1610,7 @@ Grid<TreeT>::readBuffers(std::istream& is)
         uint16_t numPasses = 1;
         is.read(reinterpret_cast<char*>(&numPasses), sizeof(uint16_t));
         const io::StreamMetadata::Ptr meta = io::getStreamMetadataPtr(is);
-        assert(bool(meta));
+        OPENVDB_ASSERT(bool(meta));
         for (uint16_t passIndex = 0; passIndex < numPasses; ++passIndex) {
             uint32_t pass = (uint32_t(numPasses) << 16) | uint32_t(passIndex);
             meta->setPass(pass);
@@ -1632,7 +1632,7 @@ Grid<TreeT>::readBuffers(std::istream& is, const CoordBBox& bbox)
         uint16_t numPasses = 1;
         is.read(reinterpret_cast<char*>(&numPasses), sizeof(uint16_t));
         const io::StreamMetadata::Ptr meta = io::getStreamMetadataPtr(is);
-        assert(bool(meta));
+        OPENVDB_ASSERT(bool(meta));
         for (uint16_t passIndex = 0; passIndex < numPasses; ++passIndex) {
             uint32_t pass = (uint32_t(numPasses) << 16) | uint32_t(passIndex);
             meta->setPass(pass);
@@ -1662,7 +1662,7 @@ Grid<TreeT>::writeBuffers(std::ostream& os) const
     } else {
         // Determine how many leaf buffer passes are required for this grid
         const io::StreamMetadata::Ptr meta = io::getStreamMetadataPtr(os);
-        assert(bool(meta));
+        OPENVDB_ASSERT(bool(meta));
         uint16_t numPasses = 1;
         meta->setCountingPasses(true);
         meta->setPass(0);

openvdb/openvdb/Metadata.h

@@ -9,6 +9,7 @@
 #include "Types.h"
 #include "math/Math.h" // for math::isZero()
 #include "util/Name.h"
+#include "util/Assert.h"
 #include <cstdint>
 #include <iostream>
 #include <string>
@@ -279,9 +280,9 @@ TypedMetadata<T>::copy(const Metadata &other)
 
 template<typename T>
 inline void
-TypedMetadata<T>::readValue(std::istream& is, Index32 /*numBytes*/)
+TypedMetadata<T>::readValue(std::istream& is, [[maybe_unused]] Index32 numBytes)
 {
-    //assert(this->size() == numBytes);
+    OPENVDB_ASSERT(this->size() == numBytes);
     is.read(reinterpret_cast<char*>(&mValue), this->size());
 }
 

openvdb/openvdb/io/Compression.cc

@@ -4,6 +4,7 @@
 #include "Compression.h"
 
 #include <openvdb/Exceptions.h>
+#include <openvdb/util/Assert.h>
 #include <openvdb/util/logging.h>
 #ifdef OPENVDB_USE_ZLIB
 #include <zlib.h>
@@ -101,7 +102,7 @@ zipToStream(std::ostream& os, const char* data, size_t numBytes)
     } else {
         // Write the size of the uncompressed data.
         // numBytes expected to be <= the max value + 1 of a signed int64
-        assert(numBytes < size_t(std::numeric_limits<Int64>::max()));
+        OPENVDB_ASSERT(numBytes < size_t(std::numeric_limits<Int64>::max()));
         Int64 negBytes = -Int64(numBytes);
         os.write(reinterpret_cast<char*>(&negBytes), 8);
         // Write the uncompressed data.
@@ -230,7 +231,7 @@ bloscToStream(std::ostream& os, const char* data, size_t valSize, size_t numVals
 {
     const size_t inBytes = valSize * numVals;
     // inBytes expected to be <= the max value + 1 of a signed int64
-    assert(inBytes < size_t(std::numeric_limits<Int64>::max()));
+    OPENVDB_ASSERT(inBytes < size_t(std::numeric_limits<Int64>::max()));
 
     int outBytes = int(inBytes) + BLOSC_MAX_OVERHEAD;
     std::unique_ptr<char[]> compressedData(new char[outBytes]);

openvdb/openvdb/io/Compression.h

@@ -7,6 +7,7 @@
 #include <openvdb/Types.h>
 #include <openvdb/MetaMap.h>
 #include <openvdb/math/Math.h> // for negative()
+#include <openvdb/util/Assert.h>
 #include "io.h" // for getDataCompression(), etc.
 #include "DelayedLoadMetadata.h"
 #include <algorithm>
@@ -249,7 +250,7 @@ readData(std::istream& is, T* data, Index count, uint32_t compression,
 {
     const bool seek = data == nullptr;
     if (seek) {
-        assert(!getStreamMetadataPtr(is) || getStreamMetadataPtr(is)->seekable());
+        OPENVDB_ASSERT(!getStreamMetadataPtr(is) || getStreamMetadataPtr(is)->seekable());
     }
     const bool hasCompression = compression & (COMPRESS_BLOSC | COMPRESS_ZIP);
 
@@ -471,7 +472,7 @@ readCompressedValues(std::istream& is, ValueT* destBuf, Index destCount,
     const bool maskCompressed = compression & COMPRESS_ACTIVE_MASK;
 
     const bool seek = (destBuf == nullptr);
-    assert(!seek || (!meta || meta->seekable()));
+    OPENVDB_ASSERT(!seek || (!meta || meta->seekable()));
 
     // Get delayed load metadata if it exists
 
@@ -732,7 +733,7 @@ writeCompressedValues(std::ostream& os, ValueT* srcBuf, Index srcCount,
                         } // else inactive value 0
                     }
                 }
-                assert(tempCount == valueMask.countOn());
+                OPENVDB_ASSERT(tempCount == valueMask.countOn());
 
                 // Write out the mask that selects between two inactive values.
                 selectionMask.save(os);

openvdb/openvdb/io/DelayedLoadMetadata.cc

@@ -4,6 +4,7 @@
 #include "DelayedLoadMetadata.h"
 
 #include <openvdb/points/StreamCompression.h>
+#include <openvdb/util/Assert.h>
 
 #ifdef OPENVDB_USE_BLOSC
 #include <blosc.h>
@@ -120,27 +121,27 @@ void DelayedLoadMetadata::resizeCompressedSize(size_t size)
 
 DelayedLoadMetadata::MaskType DelayedLoadMetadata::getMask(size_t index) const
 {
-    assert(DelayedLoadMetadata::isRegisteredType());
-    assert(index < mMask.size());
+    OPENVDB_ASSERT(DelayedLoadMetadata::isRegisteredType());
+    OPENVDB_ASSERT(index < mMask.size());
     return mMask[index];
 }
 
 void DelayedLoadMetadata::setMask(size_t index, const MaskType& value)
 {
-    assert(index < mMask.size());
+    OPENVDB_ASSERT(index < mMask.size());
     mMask[index] = value;
 }
 
 DelayedLoadMetadata::CompressedSizeType DelayedLoadMetadata::getCompressedSize(size_t index) const
 {
-    assert(DelayedLoadMetadata::isRegisteredType());
-    assert(index < mCompressedSize.size());
+    OPENVDB_ASSERT(DelayedLoadMetadata::isRegisteredType());
+    OPENVDB_ASSERT(index < mCompressedSize.size());
     return mCompressedSize[index];
 }
 
 void DelayedLoadMetadata::setCompressedSize(size_t index, const CompressedSizeType& value)
 {
-    assert(index < mCompressedSize.size());
+    OPENVDB_ASSERT(index < mCompressedSize.size());
     mCompressedSize[index] = value;
 }
 
@@ -174,7 +175,7 @@ void DelayedLoadMetadata::readValue(std::istream& is, Index32 numBytes)
         mMask.resize(count);
 
         // resize should never modify capacity for smaller vector sizes
-        assert(mMask.capacity() >= paddedCount);
+        OPENVDB_ASSERT(mMask.capacity() >= paddedCount);
 
         compression::bloscDecompress(reinterpret_cast<char*>(mMask.data()), count*sizeof(MaskType), mMask.capacity()*sizeof(MaskType), compressedBuffer.get());
 #endif
@@ -202,7 +203,7 @@ void DelayedLoadMetadata::readValue(std::istream& is, Index32 numBytes)
             mCompressedSize.resize(count);
 
             // resize should never modify capacity for smaller vector sizes
-            assert(mCompressedSize.capacity() >= paddedCount);
+            OPENVDB_ASSERT(mCompressedSize.capacity() >= paddedCount);
 
             compression::bloscDecompress(reinterpret_cast<char*>(mCompressedSize.data()), count*sizeof(CompressedSizeType), mCompressedSize.capacity()*sizeof(CompressedSizeType), compressedBuffer.get());
 #endif
@@ -231,12 +232,12 @@ void DelayedLoadMetadata::readValue(std::istream& is, Index32 numBytes)
 void DelayedLoadMetadata::writeValue(std::ostream& os) const
 {
     // metadata has a limit of 2^32 bytes
-    assert(mMask.size() < std::numeric_limits<Index32>::max());
-    assert(mCompressedSize.size() < std::numeric_limits<Index32>::max());
+    OPENVDB_ASSERT(mMask.size() < std::numeric_limits<Index32>::max());
+    OPENVDB_ASSERT(mCompressedSize.size() < std::numeric_limits<Index32>::max());
 
     if (mMask.empty() && mCompressedSize.empty())     return;
 
-    assert(mCompressedSize.empty() || (mMask.size() == mCompressedSize.size()));
+    OPENVDB_ASSERT(mCompressedSize.empty() || (mMask.size() == mCompressedSize.size()));
 
     Index32 count = static_cast<Index32>(mMask.size());
     os.write(reinterpret_cast<const char*>(&count), sizeof(Index32));
@@ -254,7 +255,7 @@ void DelayedLoadMetadata::writeValue(std::ostream& os) const
         }
 
         if (compressedBuffer) {
-            assert(compressedBytes < std::numeric_limits<Index32>::max());
+            OPENVDB_ASSERT(compressedBytes < std::numeric_limits<Index32>::max());
             Index32 bytes(static_cast<Index32>(compressedBytes));
             os.write(reinterpret_cast<const char*>(&bytes), sizeof(Index32));
             os.write(reinterpret_cast<const char*>(compressedBuffer.get()), compressedBytes);
@@ -281,7 +282,7 @@ void DelayedLoadMetadata::writeValue(std::ostream& os) const
         }
 
         if (compressedBuffer) {
-            assert(compressedBytes < std::numeric_limits<Index32>::max());
+            OPENVDB_ASSERT(compressedBytes < std::numeric_limits<Index32>::max());
             Index32 bytes(static_cast<Index32>(compressedBytes));
             os.write(reinterpret_cast<const char*>(&bytes), sizeof(Index32));
             os.write(reinterpret_cast<const char*>(compressedBuffer.get()), compressedBytes);