revision: more thorough benchmarking, change NDEBUG hardening default to IGNORE

Signed-off-by: Larry Gritz <lg@larrygritz.com>

Author: lgritz

src/build-scripts/ci-benchmark.bash

@@ -13,13 +13,14 @@ ls build
 ls $BUILD_BIN_DIR
 
 mkdir -p build/benchmarks
-for t in image_span_test ; do
+for t in image_span_test span_test ; do
     echo
     echo
     echo "$t"
     echo "========================================================"
-    ${BUILD_BIN_DIR}/$t > build/benchmarks/$t.out
-    cat build/benchmarks/$t.out
+    OpenImageIO_CI=0 ${BUILD_BIN_DIR}/$t | tee build/benchmarks/$t.out
+    # Note: set OpenImageIO_CI=0 to avoid CI-specific automatic reduction of
+    # the number of trials and iterations.
     echo "========================================================"
     echo "========================================================"
     echo

src/cmake/compiler.cmake

@@ -499,12 +499,12 @@ endif ()
 # https://cheatsheetseries.owasp.org/cheatsheets/C-Based_Toolchain_Hardening_Cheat_Sheet.html
 
 if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
-    set (${PROJ_NAME}_HARDENING_DEFAULT 2)
+    set (${PROJ_NAME}_HARDENING_DEFAULT 2)  # Extensive
 else ()
-    set (${PROJ_NAME}_HARDENING_DEFAULT 1)
+    set (${PROJ_NAME}_HARDENING_DEFAULT 1)  # Fast
 endif ()
 set_cache (${PROJ_NAME}_HARDENING ${${PROJ_NAME}_HARDENING_DEFAULT}
-           "Turn on security hardening features 0, 1, 2, 3")
+           "Turn on security hardening features 0=none, 1=fast, 2=extensive, 3=debug")
 # Implementation:
 add_compile_definitions (${PROJ_NAME}_HARDENING_DEFAULT=${${PROJ_NAME}_HARDENING})
 if (${PROJ_NAME}_HARDENING GREATER_EQUAL 1)

src/include/OpenImageIO/dassert.h

@@ -39,41 +39,44 @@
 #define OIIO_HARDENING_DEBUG 3
 
 // OIIO_HARDENING_DEFAULT defines the default hardening level we actually use.
-// By default, we use NONE for release builds and DEBUG for debug builds. But
-// any translation unit (including clients of OIIO) may override this by
-// defining OIIO_HARDENING_DEFAULT before including any OIIO headers. But note
-// that this only affects calls to inline functions or templates defined in
-// the headers. Non-inline functions compiled into the OIIO library, including
-// OIIO internal code itself, will have been compiled with whatever hardening
-// level was selected when the library was built.
+// By default, we use FAST for release builds and DEBUG for debug builds. But
+// it can be overridden:
+// - For OIIO internals, at OIIO build time with the `OIIO_HARDENING` CMake
+//   variable.
+// - For other projects using OIIO's headers, any translation unit may
+//   override this by defining OIIO_HARDENING_DEFAULT before including any
+//   OIIO headers. But note that this only affects calls to inline functions
+//   or templates defined in the headers. Non-inline functions compiled into
+//   the OIIO library itself will have been compiled with whatever hardening
+//   level was selected when the library was built.
 #ifndef OIIO_HARDENING_DEFAULT
 #    ifdef NDEBUG
-#        define OIIO_HARDENING_DEFAULT OIIO_HARDENING_NONE
+#        define OIIO_HARDENING_DEFAULT OIIO_HARDENING_FAST
 #    else
 #        define OIIO_HARDENING_DEFAULT OIIO_HARDENING_DEBUG
 #    endif
 #endif
 
 
-/// Choices for what to do when a contract assertion fails.
-/// This mimics the C++26 standard's std::contract behavior.
+// Choices for what to do when a contract assertion fails.
+// This mimics the C++26 standard's std::contract behavior.
 #define OIIO_ASSERTION_RESPONSE_IGNORE 0
 #define OIIO_ASSERTION_RESPONSE_OBSERVE 1
 #define OIIO_ASSERTION_RESPONSE_ENFORCE 2
 #define OIIO_ASSERTION_RESPONSE_QUICK_ENFORCE 3
 
 // OIIO_ASSERTION_RESPONSE_DEFAULT defines the default response to failed
-// contract assertions. By default, in NONE hardening mode and in release
-// builds, we do nothing. In all other cases, we abort. But any translation
+// contract assertions. By default, we enforce them, UNLESS we are a release
+// mode build that has set the hardening mode to NONE.  But any translation
 // unit (including clients of OIIO) may override this by defining
 // OIIO_ASSERTION_RESPONSE_DEFAULT before including any OIIO headers. But note
 // that this only affects calls to inline functions or templates defined in
-// the headers. Non-inline functions compiled into the OIIO library, including
-// OIIO internal code itself, will have been compiled with whatever response
-// was selected when the library was built.
+// the headers. Non-inline functions compiled into the OIIO library itself
+// will have been compiled with whatever response was selected when the
+// library was built.
 #ifndef OIIO_ASSERTION_RESPONSE_DEFAULT
 #    if OIIO_HARDENING_DEFAULT == OIIO_HARDENING_NONE && defined(NDEBUG)
-#        define OIIO_ASSERTION_RESPONSE_DEFAULT OIIO_ASSERTION_RESPONSE_ENFORCE
+#        define OIIO_ASSERTION_RESPONSE_DEFAULT OIIO_ASSERTION_RESPONSE_IGNORE
 #    else
 #        define OIIO_ASSERTION_RESPONSE_DEFAULT OIIO_ASSERTION_RESPONSE_ENFORCE
 #    endif

src/libutil/span_test.cpp

@@ -485,21 +485,38 @@ benchmark_span()
 {
     Benchmarker bench;
     bench.iterations(iterations).trials(ntrials);
-    bench.work(1000);
-    std::array<float, 1000> f;
-    std::fill(f.begin(), f.end(), 1.0f);
-    int sum = 0;
+    const size_t N = 1000;
+    // bench.work(N);
+    std::array<float, N> fstdarr;
+    std::fill(fstdarr.begin(), fstdarr.end(), 1.0f);
+    bench("pointer operator[]", [&]() {
+        float* fptr(fstdarr.data());
+        float t = 0.0f;
+        for (size_t i = 0; i < N; ++i)
+            DoNotOptimize(t += fptr[i]);
+    });
+    bench("std::array operator[]", [&]() {
+        float t = 0.0f;
+        for (size_t i = 0; i < N; ++i)
+            DoNotOptimize(t += fstdarr[i]);
+    });
     bench("span operator[]", [&]() {
-        int t = 0;
-        for (size_t i = 0; i < f.size(); ++i)
-            DoNotOptimize(t += f[i]);
-        sum += t;
+        span<float> fspan(fstdarr);
+        float t = 0.0f;
+        for (size_t i = 0; i < N; ++i)
+            DoNotOptimize(t += fspan[i]);
+    });
+    bench("span unsafe indexing", [&]() {
+        span<float> fspan(fstdarr);
+        float t = 0.0f;
+        for (size_t i = 0; i < N; ++i)
+            DoNotOptimize(t += fspan.data()[i]);
     });
     bench("span range", [&]() {
-        int t = 0;
-        for (auto x : f)
+        span<float> fspan(fstdarr);
+        float t = 0.0f;
+        for (auto x : fspan)
             DoNotOptimize(t += x);
-        sum += t;
     });
 }
 
@@ -508,13 +525,18 @@ benchmark_span()
 int
 main(int argc, char* argv[])
 {
-#if !defined(NDEBUG) || defined(OIIO_CI) || defined(OIIO_CODE_COVERAGE)
-    // For the sake of test time, reduce the default iterations for DEBUG,
-    // CI, and code coverage builds. Explicit use of --iters or --trials
-    // will override this, since it comes before the getargs() call.
-    iterations /= 10;
-    ntrials = 1;
+    // For the sake of test time, reduce the default number of benchmarking
+    // trials and iterations for DEBUG, CI, and code coverage builds. Explicit
+    // use of --iters or --trials will override this, since it comes before
+    // the getargs() call.
+    if (Strutil::eval_as_bool(Sysutil::getenv("OpenImageIO_CI"))
+#if !defined(NDEBUG) || defined(OIIO_CODE_COVERAGE)
+        || true
 #endif
+    ) {
+        iterations /= 10;
+        ntrials = 1;
+    }
 
     getargs(argc, argv);