Sshirokov/benchmark

cetlvast/CMakeLists.txt

@@ -162,6 +162,7 @@ add_project_library(
 )
 
 find_package(clangformat)
+find_package(benchmark)
 
 if(clangformat_FOUND)
     # define a dry-run version that we always run.
@@ -198,7 +199,9 @@ endif()
 add_subdirectory(${CMAKE_SOURCE_DIR}/suites/unittest)
 add_subdirectory(${CMAKE_SOURCE_DIR}/suites/docs)
 add_subdirectory(${CMAKE_SOURCE_DIR}/suites/compile)
-
+if(benchmark_FOUND)
+    add_subdirectory(${CMAKE_SOURCE_DIR}/suites/benchmark)
+endif()
 # +---------------------------------------------------------------------------+
 # | BUILD TARGET ALIASES
 # +---------------------------------------------------------------------------+

cetlvast/suites/benchmark/CMakeLists.txt

@@ -0,0 +1,36 @@
+#
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: MIT
+#
+
+cmake_minimum_required(VERSION 3.22.0)
+
+project(cetlvast_benchmark CXX)
+
+find_package(benchmark REQUIRED)
+
+file(GLOB_RECURSE TEST_SOURCES
+        LIST_DIRECTORIES false
+        CONFIGURE_DEPENDS
+        RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+        benchmark_*.cpp **/benchmark_*.cpp
+)
+
+set(ALL_TESTS_BUILD "")
+
+foreach(TEST_SOURCE ${TEST_SOURCES})
+
+    cmake_path(GET TEST_SOURCE STEM TEST_NAME)
+
+    add_executable(${TEST_NAME} ${TEST_SOURCE})
+    target_link_libraries(${TEST_NAME} cetl benchmark::benchmark)
+
+    list(APPEND ALL_TESTS_BUILD ${TEST_NAME})
+
+endforeach()
+
+add_custom_target(
+        build_benchmarks
+        DEPENDS
+        ${ALL_TESTS_BUILD}
+)

cetlvast/suites/benchmark/pmr/benchmark_pmr_function.cpp

@@ -0,0 +1,69 @@
+#include <cetl/pmr/function.hpp>
+
+#include <benchmark/benchmark.h>
+
+namespace
+{
+
+void BM_CetlFn_call(benchmark::State& state)
+{
+    cetl::pmr::function<int64_t(int64_t), 16> fn = [](int64_t i) {
+        benchmark::DoNotOptimize(i);
+        return i;
+    };
+    for (auto _ : state)
+    {
+        int64_t    res = 0;
+        const auto lim = state.range();
+        for (int i = 0; i < lim; ++i)
+        {
+            res += fn(i);
+        }
+        benchmark::DoNotOptimize(res);
+    }
+}
+
+void BM_StdFn_call(benchmark::State& state)
+{
+    std::function<int64_t(int64_t)> fn = [](int64_t i) {
+        benchmark::DoNotOptimize(i);
+        return i;
+    };
+    for (auto _ : state)
+    {
+        int64_t    res = 0;
+        const auto lim = state.range();
+        for (int i = 0; i < lim; ++i)
+        {
+            res += fn(i);
+        }
+        benchmark::DoNotOptimize(res);
+    }
+}
+
+void BM_Lambda_call(benchmark::State& state)
+{
+    auto fn = [](int64_t i) {
+        benchmark::DoNotOptimize(i);
+        return i;
+    };
+    for (auto _ : state)
+    {
+        int64_t    res = 0;
+        const auto lim = state.range();
+        for (int i = 0; i < lim; ++i)
+        {
+            res += fn(i);
+        }
+        benchmark::DoNotOptimize(res);
+    }
+    (void) fn;
+}
+
+}  // namespace
+
+BENCHMARK(BM_CetlFn_call)->Arg(1000);
+BENCHMARK(BM_StdFn_call)->Arg(1000);
+BENCHMARK(BM_Lambda_call)->Arg(1000);
+
+BENCHMARK_MAIN();

include/cetl/unbounded_variant.hpp

@@ -657,7 +657,9 @@ struct base_access : base_storage<Pmr, Footprint, Alignment>
         // Non-PMR storage can store any value as long as it fits into the footprint.
         static_assert((Footprint > 0) || IsPmr<Pmr>::value, "Make non-zero footprint, or enable PMR support.");
 
-        if (has_value())
+        // `has_value()` already checks for `value_destroyer_` not being `nullptr`,
+        // but clang-tidy doesn't see it, so we get false positive here - hence the explicit double check.
+        if (has_value() && (nullptr != value_destroyer_))
         {
             value_destroyer_(base::get_raw_storage());
         }