Add support to C atomics for clang, gcc and msvc.

Author: viferga

CMakeLists.txt

@@ -94,6 +94,7 @@ option(OPTION_GIT_HOOKS			"Disable git hooks when running in CI/CD."					ON)
 option(OPTION_FORK_SAFE			"Enable fork safety."										ON)
 option(OPTION_THREAD_SAFE		"Enable thread safety."										OFF)
 option(OPTION_COVERAGE			"Enable coverage."											OFF)
+option(OPTION_MEMORY_TRACKER	"Enable memory tracking for reflect data."					ON)
 
 # Build type
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)

cmake/CompileOptions.cmake

@@ -34,21 +34,30 @@ include(Portability)
 # Project options
 #
 
+# Test for GNU, Clang or ((Visual Studio C++ or Clang with MSVC backend) and Visual Studio 2022 or superior)
+if(("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU") OR
+	("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") OR
+	("${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang") OR
+	(
+		(("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC") OR
+		(("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") AND ("${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC"))) AND
+		(MSVC_VERSION GREATER_EQUAL 1930)
+	)
+)
+	set(C_STANDARD 11) # TODO: Implement support for older standards
+else()
+	set(C_STANDARD 99)
+endif()
+
 set(DEFAULT_PROJECT_OPTIONS
 	DEBUG_POSTFIX				"d"
 	CXX_STANDARD				11
 	LINKER_LANGUAGE				"CXX"
 	POSITION_INDEPENDENT_CODE	ON
 	CXX_VISIBILITY_PRESET		"hidden"
+	C_STANDARD					${C_STANDARD}
 )
 
-if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-	set(DEFAULT_PROJECT_OPTIONS
-		${DEFAULT_PROJECT_OPTIONS}
-		C_STANDARD				11 # TODO: Provide support for older standards
-	)
-endif()
-
 #
 # Include directories
 #
@@ -106,8 +115,15 @@ else()
 	set(LOG_POLICY_FORMAT_PRETTY_VALUE 0)
 endif()
 
+if(OPTION_MEMORY_TRACKER)
+	set(REFLECT_MEMORY_TRACKER_VALUE 1)
+else()
+	set(REFLECT_MEMORY_TRACKER_VALUE 0)
+endif()
+
 set(DEFAULT_COMPILE_DEFINITIONS
 	LOG_POLICY_FORMAT_PRETTY=${LOG_POLICY_FORMAT_PRETTY_VALUE}
+	REFLECT_MEMORY_TRACKER=${REFLECT_MEMORY_TRACKER_VALUE}
 	SYSTEM_${SYSTEM_NAME_UPPER}
 	${SANITIZER_COMPILE_DEFINITIONS}
 )

source/metacall/source/metacall.c

@@ -2217,11 +2217,8 @@ int metacall_destroy(void)
 
 		metacall_initialize_flag = 1;
 
-		/* Print stats from functions, classes and objects */
-		function_stats_debug();
-		class_stats_debug();
-		object_stats_debug();
-		exception_stats_debug();
+		/* Print stats from functions, classes, objects and exceptions */
+		reflect_memory_tracker_debug();
 
 		/* Set to null the plugin extension */
 		plugin_extension_handle = NULL;

source/reflect/CMakeLists.txt

@@ -45,6 +45,7 @@ set(headers
 	${include_path}/reflect_attribute.h
 	${include_path}/reflect_constructor_decl.h
 	${include_path}/reflect_constructor.h
+	${include_path}/reflect_memory_tracker.h
 	${include_path}/reflect_method_decl.h
 	${include_path}/reflect_method.h
 	${include_path}/reflect_class_decl.h
@@ -72,6 +73,7 @@ set(sources
 	${source_path}/reflect_function.c
 	${source_path}/reflect_attribute.c
 	${source_path}/reflect_constructor.c
+	${source_path}/reflect_memory_tracker.c
 	${source_path}/reflect_method.c
 	${source_path}/reflect_class_visibility.c
 	${source_path}/reflect_class.c

source/reflect/include/reflect/reflect.h

@@ -39,6 +39,10 @@
 #include <reflect/reflect_value_type_id_size.h>
 #include <reflect/reflect_value_type_promotion.h>
 
+#ifndef __cplusplus
+	#include <reflect/reflect_memory_tracker.h>
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif

source/reflect/include/reflect/reflect_memory_tracker.h

@@ -0,0 +1,126 @@
+/*
+ *	Reflect Library by Parra Studios
+ *	A library for provide reflection and metadata representation.
+ *
+ *	Copyright (C) 2016 - 2022 Vicente Eduardo Ferrer Garcia <[email protected]>
+ *
+ *	Licensed under the Apache License, Version 2.0 (the "License");
+ *	you may not use this file except in compliance with the License.
+ *	You may obtain a copy of the License at
+ *
+ *		http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *	Unless required by applicable law or agreed to in writing, software
+ *	distributed under the License is distributed on an "AS IS" BASIS,
+ *	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *	See the License for the specific language governing permissions and
+ *	limitations under the License.
+ *
+ */
+
+#ifndef REFLECT_MEMORY_TRACKER_H
+#define REFLECT_MEMORY_TRACKER_H 1
+
+#include <reflect/reflect_api.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(REFLECT_MEMORY_TRACKER) && REFLECT_MEMORY_TRACKER == 1
+
+	#include <threading/threading_atomic.h>
+
+	#include <format/format_specifier.h>
+
+	#include <stdio.h>
+
+	#define reflect_memory_tracker(name)    \
+		static struct                       \
+		{                                   \
+			atomic_uintmax_t allocations;   \
+			atomic_uintmax_t deallocations; \
+			atomic_uintmax_t increments;    \
+			atomic_uintmax_t decrements;    \
+		} name = { 0, 0, 0, 0 }
+
+	#define reflect_memory_tracker_allocation(name) \
+		atomic_fetch_add_explicit(&name.allocations, 1, memory_order_relaxed)
+
+	#define reflect_memory_tracker_deallocation(name) \
+		atomic_fetch_add_explicit(&name.deallocations, 1, memory_order_relaxed)
+
+	#define reflect_memory_tracker_increment(name) \
+		atomic_fetch_add_explicit(&name.increments, 1, memory_order_relaxed)
+
+	#define reflect_memory_tracker_decrement(name) \
+		atomic_fetch_add_explicit(&name.decrements, 1, memory_order_relaxed)
+
+	#if !defined(NDEBUG) || defined(DEBUG) || defined(_DEBUG) || defined(__DEBUG) || defined(__DEBUG__)
+		#define reflect_memory_tracker_print(name, title)                                                               \
+			do                                                                                                          \
+			{                                                                                                           \
+				printf("----------------- " title " -----------------\n");                                              \
+				printf("Allocations: %" PRIuS "\n", atomic_load_explicit(&name.allocations, memory_order_relaxed));     \
+				printf("Deallocations: %" PRIuS "\n", atomic_load_explicit(&name.deallocations, memory_order_relaxed)); \
+				printf("Increments: %" PRIuS "\n", atomic_load_explicit(&name.increments, memory_order_relaxed));       \
+				printf("Decrements: %" PRIuS "\n", atomic_load_explicit(&name.decrements, memory_order_relaxed));       \
+				fflush(stdout);                                                                                         \
+			} while (0)
+	#else
+		#define reflect_memory_tracker_print(name, title)                                                          \
+			do                                                                                                     \
+			{                                                                                                      \
+				uintmax_t allocations = atomic_load_explicit(&name.allocations, memory_order_relaxed);             \
+				uintmax_t deallocations = atomic_load_explicit(&name.deallocations, memory_order_relaxed);         \
+				uintmax_t increments = atomic_load_explicit(&name.increments, memory_order_relaxed);               \
+				uintmax_t decrements = atomic_load_explicit(&name.decrements, memory_order_relaxed);               \
+				/* This comparison is safe to be done like this because it is done once execution has finalized */ \
+				if (allocations != deallocations || increments != decrements)                                      \
+				{                                                                                                  \
+					printf("----------------- " title " -----------------\n");                                     \
+					printf("Allocations: %" PRIuS "\n", allocations);                                              \
+					printf("Deallocations: %" PRIuS "\n", deallocations);                                          \
+					printf("Increments: %" PRIuS "\n", increments);                                                \
+					printf("Decrements: %" PRIuS "\n", decrements);                                                \
+					fflush(stdout);                                                                                \
+				}                                                                                                  \
+			} while (0)
+	#endif
+#else
+	#define reflect_memory_tracker(name) \
+		typedef char reflect_memory_tracker_disabled
+
+	#define reflect_memory_tracker_allocation(name) \
+		do                                          \
+		{                                           \
+		} while (0)
+
+	#define reflect_memory_tracker_deallocation(name) \
+		do                                            \
+		{                                             \
+		} while (0)
+
+	#define reflect_memory_tracker_increment(name) \
+		do                                         \
+		{                                          \
+		} while (0)
+
+	#define reflect_memory_tracker_decrement(name) \
+		do                                         \
+		{                                          \
+		} while (0)
+
+	#define reflect_memory_tracker_print(name, title) \
+		do                                            \
+		{                                             \
+		} while (0)
+#endif
+
+void reflect_memory_tracker_debug(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* REFLECT_MEMORY_TRACKER_H */

source/reflect/source/reflect_class.c

@@ -27,9 +27,9 @@
 
 #include <reflect/reflect_accessor.h>
 
-#include <log/log.h>
+#include <reflect/reflect_memory_tracker.h>
 
-#include <threading/threading_atomic.h>
+#include <log/log.h>
 
 #include <stdlib.h>
 #include <string.h>
@@ -56,13 +56,7 @@ struct class_metadata_iterator_args_type
 
 typedef struct class_metadata_iterator_args_type *class_metadata_iterator_args;
 
-static struct
-{
-	threading_atomic size_t allocations;
-	threading_atomic size_t deallocations;
-	threading_atomic size_t increments;
-	threading_atomic size_t decrements;
-} class_stats = { 0, 0, 0, 0 };
+reflect_memory_tracker(class_stats);
 
 static value class_metadata_name(klass cls);
 static value class_metadata_constructors(klass cls);
@@ -138,7 +132,7 @@ klass class_create(const char *name, enum accessor_type_id accessor, class_impl
 		}
 	}
 
-	++class_stats.allocations;
+	reflect_memory_tracker_allocation(class_stats);
 
 	return cls;
 }
@@ -156,7 +150,7 @@ int class_increment_reference(klass cls)
 	}
 
 	++cls->ref_count;
-	++class_stats.increments;
+	reflect_memory_tracker_increment(class_stats);
 
 	return 0;
 }
@@ -174,7 +168,7 @@ int class_decrement_reference(klass cls)
 	}
 
 	--cls->ref_count;
-	++class_stats.decrements;
+	reflect_memory_tracker_decrement(class_stats);
 
 	return 0;
 }
@@ -837,17 +831,7 @@ void class_constructors_destroy(klass cls)
 
 void class_stats_debug(void)
 {
-#if !(!defined(NDEBUG) || defined(DEBUG) || defined(_DEBUG) || defined(__DEBUG) || defined(__DEBUG__))
-	if (class_stats.allocations != class_stats.deallocations || class_stats.increments != class_stats.decrements)
-#endif
-	{
-		printf("----------------- CLASSES -----------------\n");
-		printf("Allocations: %" PRIuS "\n", class_stats.allocations);
-		printf("Deallocations: %" PRIuS "\n", class_stats.deallocations);
-		printf("Increments: %" PRIuS "\n", class_stats.increments);
-		printf("Decrements: %" PRIuS "\n", class_stats.decrements);
-		fflush(stdout);
-	}
+	reflect_memory_tracker_print(class_stats, "CLASSES");
 }
 
 void class_destroy(klass cls)
@@ -915,7 +899,7 @@ void class_destroy(klass cls)
 
 			free(cls);
 
-			++class_stats.deallocations;
+			reflect_memory_tracker_deallocation(class_stats);
 		}
 	}
 }