Improved ExperimentValue. Bug Fixes.

Breaking changes due to type of value being passed for ExperimentValue (object to pointer).

Author: DigitalInBlue

.gitignore

@@ -174,6 +174,7 @@ pip-log.txt
 *.png
 *.xcf
 [Bb]uild/
+[Bb]uildLinux/
 
 #############
 ## CMake

CMakeLists.txt

@@ -21,14 +21,44 @@
 # Cmake Configuration
 #
 
-CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.16)
+cmake_policy(SET CMP0128 NEW)
+
+enable_language(CXX)
+
+include(CheckFunctionExists)
+include(CheckCXXSourceCompiles)
+include(CheckIncludeFile)
+include(GenerateExportHeader)
+include(CMakePackageConfigHelpers)
+
+#
+# User Options
+#
+
+option(CELERO_COMPILE_DYNAMIC_LIBRARIES "Set to ON to build Celero for dynamic linking.  Use OFF for static." ON)
+option(CELERO_COMPILE_PIC "Set to ON to build Celero as a position-independent library." ON)
+option(CELERO_ENABLE_EXPERIMENTS "Set to ON to automatically build all examples." OFF)
+option(CELERO_ENABLE_FOLDERS "Enable to put Celero in its own solution folder under Visual Studio" ON)
+option(CELERO_ENABLE_TESTS "Enable building and running unit tests." OFF)
+option(CELERO_ENABLE_WARNINGS_AS_ERRORS "Treat compile warnings as errors." ON)
+option(CELERO_ENABLE_CLANG_TIDY_CHECKS "Compile with clang-tidy checks." OFF)
+option(CELERO_ENABLE_CLANG_ADDRESS_SANITIZER "Enable the Clang Address Sanitizer" OFF)
+
+#
+# Project configuration macro
+#
 
 macro(CeleroSetDefaultCompilerOptions)
+	message(STATUS "Celero: Setting default compiler options for ${PROJECT_NAME}")
+
 	set_target_properties(${PROJECT_NAME} PROPERTIES
 		POSITION_INDEPENDENT_CODE "${CELERO_COMPILE_PIC}"
 	)
 
-	if(CMAKE_CXX_COMPILER_ID STREQUAL MSVC)
+	if(${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC)
+		message(STATUS "Celero: Configuring Visual Studio for ${PROJECT_NAME}")
+
 		target_compile_options(${PROJECT_NAME} PRIVATE /D_VARIADIC_MAX=10 )
 		target_compile_options(${PROJECT_NAME} PRIVATE /D_CRT_SECURE_NO_WARNINGS)
 		target_compile_options(${PROJECT_NAME} PRIVATE /wd4251)
@@ -48,33 +78,65 @@ macro(CeleroSetDefaultCompilerOptions)
 			endif()
 		endif()
 
-        if(CELERO_TREAT_WARNINGS_AS_ERRORS)
+        if(CELERO_ENABLE_WARNINGS_AS_ERRORS)
             target_compile_options(${PROJECT_NAME} PRIVATE /WX)
 		endif()
 
-	elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+		if(CELERO_ENABLE_CLANG_TIDY_CHECKS)
+			message(STATUS "Celero: Enabling Clang-Tidy checks for ${PROJECT_NAME}")
+			set_target_properties(${PROJECT_NAME} PROPERTIES
+				VS_GLOBAL_RunCodeAnalysis true
+
+				# Use visual studio core guidelines
+				# VS_GLOBAL_EnableMicrosoftCodeAnalysis true
+
+				# Use clangtidy
+				VS_GLOBAL_EnableClangTidyCodeAnalysis true
+				VS_GLOBAL_ClangTidyChecks -*,modernize-*,boost-*,bugprone-*,clang-analyzer-*,concurrency-*,cppcoreguidelines-*,hicpp-*misc-*,modernize-*,performance-*,portability-*,-modernize-use-trailing-return-type,-bugprone-easily-swappable-parameters
+			)
+		endif()
+
+		if(CELERO_ENABLE_CLANG_ADDRESS_SANITIZER)
+			message(STATUS "Celero: Enabling Clang Address Sanitizer (ASAN) for the Release configuration of ${PROJECT_NAME}")
+			target_compile_options(${PROJECT_NAME} PRIVATE
+				$<$<CONFIG:Release>:-fsanitize=address /Zi>
+			)
+
+			target_link_libraries(${PROJECT_NAME} PUBLIC
+				$<$<CONFIG:Release>:clang_rt.asan_dynamic-x86_64>
+				$<$<CONFIG:Release>:clang_rt.asan_dynamic_runtime_thunk-x86_64>
+			)
+		endif()
+
+	elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
+		message(STATUS "Celero: Configuring GCC for ${PROJECT_NAME}")
+		
 		target_compile_options(${PROJECT_NAME} PRIVATE -Wall)
 
-	elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+	elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
+		message(STATUS "Celero: Configuring Clang for ${PROJECT_NAME}")
+		
 		if(${CMAKE_SYSTEM_NAME} STREQUAL Windows)
 			target_compile_options(${PROJECT_NAME} PRIVATE -Xclang)
 			target_compile_options(${PROJECT_NAME} PRIVATE -Wno-c++98-compat)
 			target_compile_options(${PROJECT_NAME} PRIVATE -Wno-c++98-compat-pedantic)
 			target_compile_options(${PROJECT_NAME} PRIVATE -Wno-reserved-id-macro)
-			if(CELERO_TREAT_WARNINGS_AS_ERRORS)
+			if(CELERO_ENABLE_WARNINGS_AS_ERRORS)
 				target_compile_options(${PROJECT_NAME} PRIVATE -Werror)
 			endif()
 		else()
 			target_compile_options(${PROJECT_NAME} PRIVATE -Wall)
-			if(CELERO_TREAT_WARNINGS_AS_ERRORS)
+			if(CELERO_ENABLE_WARNINGS_AS_ERRORS)
 				target_compile_options(${PROJECT_NAME} PRIVATE -Werror)
 			endif()
 		endif()
 
-	elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+	elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "AppleClang")
+		message(STATUS "Celero: Configuring Apple Clang for ${PROJECT_NAME}")
+		
 		target_compile_options(${PROJECT_NAME} PRIVATE -Wall)
 
-		if(CELERO_TREAT_WARNINGS_AS_ERRORS)
+		if(CELERO_ENABLE_WARNINGS_AS_ERRORS)
 			target_compile_options(${PROJECT_NAME} PRIVATE -Werror)
 		endif()
 	endif()
@@ -90,17 +152,6 @@ include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
 include(CMakeFindDependencyMacro)
 
-#
-# User Options
-#
-
-option(CELERO_COMPILE_DYNAMIC_LIBRARIES "Set to ON to build Celero for dynamic linking.  Use OFF for static." ON)
-option(CELERO_COMPILE_PIC "Set to ON to build Celero as a position-independent library." ON)
-option(CELERO_ENABLE_EXPERIMENTS "Set to ON to automatically build all examples." OFF)
-option(CELERO_ENABLE_FOLDERS "Enable to put Celero in its own solution folder under Visual Studio" ON)
-option(CELERO_ENABLE_TESTS "Enable building and running unit tests." OFF)
-option(CELERO_TREAT_WARNINGS_AS_ERRORS "Treat compile warnings as errors." ON)
-
 if(CELERO_COMPILE_DYNAMIC_LIBRARIES)
 	SET(CELERO_USER_DEFINED_SHARED_OR_STATIC "SHARED")
 else()
@@ -190,6 +241,7 @@ target_sources(${PROJECT_NAME} PRIVATE
 	src/Timer.cpp
 	src/UserDefinedMeasurementCollector.cpp
 	src/Utilities.cpp
+	README.md
 )
 
 if(WIN32)

README.md

@@ -14,21 +14,16 @@ A Special Thanks to the following corporations for their support:
 -   [Araxis](https://www.araxis.com/)
 -   [Axosoft](https://www.gitkraken.com/)
 -   [Microsoft](https://www.microsoft.com)
--   [Travis.CI](https://travis-ci.org)
 
 #### Builds and Testing
 
-| Branch                 | Status                                                                                                                                 |
-|:-----------------------|:---------------------------------------------------------------------------------------------------------------------------------------|
-| ```origin/master: ```  | [![Build Status (Master)](https://travis-ci.org/DigitalInBlue/Celero.svg?branch=master)](https://travis-ci.org/DigitalInBlue/Celero)   |
-| ```origin/develop: ``` | [![Build Status (Develop)](https://travis-ci.org/DigitalInBlue/Celero.svg?branch=develop)](https://travis-ci.org/DigitalInBlue/Celero) |
-
-Celero has been successfully built on the following platforms during development.  See [Travis.CI](https://travis-ci.org/DigitalInBlue/Celero) for more details.
+Celero has been successfully built on the following platforms during development.
 
 - GCC v6.0.0
 - GCC v7.0.0
 - GCC v8.0.0
 - GCC v9.0.0
+- GCC v9.4.0
 - LLVM v3.9.0
 - LLVM v5.0.1
 - LLVM v7.0.0
@@ -38,6 +33,7 @@ Celero has been successfully built on the following platforms during development
 - Visual Studio 2019 (16.11.5)
 - Visual Studio 2022 (17.0.5)
 - Visual Studio 2022 (17.4.3)
+- Visual Studio 2022 (17.5.5)
 - XCode v10.1
 - XCode v10.3
 - XCode v11.0
@@ -56,13 +52,13 @@ As of v2.7, Celero requres the developer to provide GoogleTest in order to build
 
 Developing consistent and meaningful benchmark results for code is a complicated task. Measurement tools exist (Intel® VTune™ Amplifier, SmartBear AQTime, Valgrind, etc.) external to applications, but they are sometimes expensive for small teams or cumbersome to utilize. This project, Celero, aims to be a small library which can be added to a C++ project and perform benchmarks on code in a way which is easy to reproduce, share, and compare among individual runs, developers, or projects. Celero uses a framework similar to that of GoogleTest to make its API more natural to use and integrate into a project. Make automated benchmarking as much a part of your development process as automated testing.
 
-Celero uses CMake to provide cross-platform builds. It does require a modern compiler (Visual C++ 2012+, GCC 4.7+, Clang 2.9+) due to its use of C++11.
+Celero uses CMake to provide cross-platform builds. It does require a modern compiler (Visual C++ 2012+, GCC 4.7+, Clang 2.9+) due to its use of C++14.
 
 Once Celero is added to your project. You can create dedicated benchmark projects and source files. For convenience, there is single header file and a `CELERO_MAIN` macro that can be used to provide a `main()` for your benchmark project that will automatically execute all of your benchmark tests.
 
 ### Key Features
 
--   Supports Windows, Linux, and OSX using C++11.
+-   Supports Windows, Linux, and OSX using C++14.
 -   The timing utilities can be used directly in production code (independent of benchmarks).
 -   Automatically tracks RAM usage during the experiments
 -   Console table output is formatted as Markdown to easily copy/paste into documents.

experiments/DemoFileWrite/DemoFileWrite.cpp

@@ -5,17 +5,17 @@ CELERO_MAIN
 class BaseFixture : public celero::TestFixture
 {
 public:
-	std::vector<celero::TestFixture::ExperimentValue> getExperimentValues() const override
+	std::vector<std::shared_ptr<celero::TestFixture::ExperimentValue>> getExperimentValues() const override
 	{
-		std::vector<celero::TestFixture::ExperimentValue> bufferSizes;
-		bufferSizes.push_back(32);
-		bufferSizes.push_back(64);
-		bufferSizes.push_back(128);
-		bufferSizes.push_back(256);
-		bufferSizes.push_back(512);
-		bufferSizes.push_back(1024);
-		bufferSizes.push_back(2048);
-		bufferSizes.push_back(4096);
+		std::vector<std::shared_ptr<celero::TestFixture::ExperimentValue>> bufferSizes;
+		bufferSizes.push_back(std::make_shared<celero::TestFixture::ExperimentValue>(32));
+		bufferSizes.push_back(std::make_shared<celero::TestFixture::ExperimentValue>(64));
+		bufferSizes.push_back(std::make_shared<celero::TestFixture::ExperimentValue>(128));
+		bufferSizes.push_back(std::make_shared<celero::TestFixture::ExperimentValue>(256));
+		bufferSizes.push_back(std::make_shared<celero::TestFixture::ExperimentValue>(512));
+		bufferSizes.push_back(std::make_shared<celero::TestFixture::ExperimentValue>(1024));
+		bufferSizes.push_back(std::make_shared<celero::TestFixture::ExperimentValue>(2048));
+		bufferSizes.push_back(std::make_shared<celero::TestFixture::ExperimentValue>(4096));
 		return bufferSizes;
 	}
 
@@ -25,11 +25,11 @@ class BaseFixture : public celero::TestFixture
 		return 1024.0 * 1024.0;
 	}
 
-	void setUp(const celero::TestFixture::ExperimentValue& experimentValue) override
+	void setUp(const celero::TestFixture::ExperimentValue* const experimentValue) override
 	{
-		for(auto i = 0; i < experimentValue.Value; ++i)
+		for(auto i = 0; i < experimentValue->Value; ++i)
 		{
-			this->buffer.push_back(celero::Random() % 256);
+			this->buffer.push_back(std::abs(celero::Random()) % 256);
 		}
 	}
 
@@ -44,10 +44,15 @@ class BaseFixture : public celero::TestFixture
 class StdFileFixture : public BaseFixture
 {
 public:
-	void setUp(const celero::TestFixture::ExperimentValue& x) override
+	void setUp(const celero::TestFixture::ExperimentValue* const x) override
 	{
 		BaseFixture::setUp(x);
+
+		#ifdef WIN32
 		fopen_s(&this->file , "FileWrite.out", "wb");
+		#else
+		this->file = fopen("FileWrite.out", "wb");
+		#endif
 	}
 
 	void tearDown() override

experiments/DemoMultithread/DemoMultithread.cpp

@@ -10,7 +10,7 @@ class BaseFixture : public celero::ThreadTestFixture
 public:
 	int counter;
 
-	void setUp(const celero::TestFixture::ExperimentValue&) override
+	void setUp(const celero::TestFixture::ExperimentValue* const) override
 	{
 		this->counter = 0;
 	}
@@ -21,7 +21,7 @@ class AtomicFixture : public celero::ThreadTestFixture
 public:
 	std::atomic<int> counter;
 
-	void setUp(const celero::TestFixture::ExperimentValue&) override
+	void setUp(const celero::TestFixture::ExperimentValue* const) override
 	{
 		this->counter = 0;
 	}
@@ -33,7 +33,7 @@ class MutexFixture : public celero::ThreadTestFixture
 	int counter;
 	std::mutex mutex;
 
-	void setUp(const celero::TestFixture::ExperimentValue&) override
+	void setUp(const celero::TestFixture::ExperimentValue* const) override
 	{
 		this->counter = 0;
 	}

experiments/DemoTransform/DemoTransform.cpp

@@ -45,9 +45,9 @@ class DemoTransformFixture : public celero::TestFixture
 	{
 	}
 
-	std::vector<celero::TestFixture::ExperimentValue> getExperimentValues() const override
+	std::vector<std::shared_ptr<celero::TestFixture::ExperimentValue>> getExperimentValues() const override
 	{
-		std::vector<celero::TestFixture::ExperimentValue> problemSpaceValues;
+		std::vector<std::shared_ptr<celero::TestFixture::ExperimentValue>> problemSpaceValues;
 
 		// We will run some total number of sets of tests all together.
 		// Each one growing by a power of 2.
@@ -60,16 +60,17 @@ class DemoTransformFixture : public celero::TestFixture
 			// We make the number of iterations decrease as the size of our problem space increases
 			// to demonstrate how to adjust the number of iterations per sample based on the
 			// problem space size.
-			problemSpaceValues.push_back({int64_t(pow(2, i + 1)), int64_t(pow(2, totalNumberOfTests - i))});
+			problemSpaceValues.push_back(
+				std::make_shared<celero::TestFixture::ExperimentValue>(int64_t(pow(2, i + 1)), int64_t(pow(2, totalNumberOfTests - i))));
 		}
 
 		return problemSpaceValues;
 	}
 
 	/// Before each run, build a vector of random integers.
-	void setUp(const celero::TestFixture::ExperimentValue& experimentValue) override
+	void setUp(const celero::TestFixture::ExperimentValue* const experimentValue) override
 	{
-		this->arraySize = static_cast<int>(experimentValue.Value);
+		this->arraySize = static_cast<int>(experimentValue->Value);
 
 		for(int i = 0; i < this->arraySize; i++)
 		{