Add atomic reference counting for reflect objects.

viferga · viferga · commit 4f6881593d2d · 2023-01-05T17:07:51.000+01:00
diff --git a/source/reflect/source/reflect_class.c b/source/reflect/source/reflect_class.c
@@ -27,6 +27,8 @@
 
 #include <reflect/reflect_accessor.h>
 
+#include <threading/threading_atomic_ref_count.h>
+
 #include <reflect/reflect_memory_tracker.h>
 
 #include <log/log.h>
@@ -40,7 +42,7 @@ struct class_type
 	enum accessor_type_id accessor;
 	class_impl impl;
 	class_interface interface;
-	size_t ref_count;
+	struct threading_atomic_ref_count_type ref;
 	vector constructors;
 	map methods;
 	map static_methods;
@@ -106,7 +108,7 @@ klass class_create(const char *name, enum accessor_type_id accessor, class_impl
 
 	cls->impl = impl;
 	cls->accessor = accessor;
-	cls->ref_count = 0;
+	threading_atomic_ref_count_store(&cls->ref, 0);
 	cls->interface = singleton ? singleton() : NULL;
 	cls->constructors = vector_create_type(constructor);
 	cls->methods = map_create(&hash_callback_str, &comparable_callback_str);
@@ -144,12 +146,11 @@ int class_increment_reference(klass cls)
 		return 1;
 	}
 
-	if (cls->ref_count == SIZE_MAX)
+	if (threading_atomic_ref_count_increment(&cls->ref) == 1)
 	{
 		return 1;
 	}
 
-	++cls->ref_count;
 	reflect_memory_tracker_increment(class_stats);
 
 	return 0;
@@ -162,12 +163,11 @@ int class_decrement_reference(klass cls)
 		return 1;
 	}
 
-	if (cls->ref_count == 0)
+	if (threading_atomic_ref_count_decrement(&cls->ref) == 1)
 	{
 		return 1;
 	}
 
-	--cls->ref_count;
 	reflect_memory_tracker_decrement(class_stats);
 
 	return 0;
@@ -843,7 +843,7 @@ void class_destroy(klass cls)
 			log_write("metacall", LOG_LEVEL_ERROR, "Invalid reference counter in class: %s", cls->name ? cls->name : "<anonymous>");
 		}
 
-		if (cls->ref_count == 0)
+		if (threading_atomic_ref_count_load(&cls->ref) == 0)
 		{
 			if (cls->name == NULL)
 			{
diff --git a/source/reflect/source/reflect_exception.c b/source/reflect/source/reflect_exception.c
@@ -20,6 +20,7 @@
 
 #include <reflect/reflect_exception.h>
 
+#include <threading/threading_atomic_ref_count.h>
 #include <threading/threading_thread_id.h>
 
 #include <reflect/reflect_memory_tracker.h>
@@ -36,7 +37,7 @@ struct exception_type
 	int64_t code;	  /* Numeric code of error */
 	char *stacktrace; /* Stack trace of the error */
 	uint64_t id;	  /* Thread id where the error was raised */
-	size_t ref_count;
+	struct threading_atomic_ref_count_type ref;
 	/* TODO: value attributes; // This should implement a map for representing the extra attributes of an exception */
 };
 
@@ -56,7 +57,8 @@ exception exception_create(char *message, char *label, int64_t code, char *stack
 	ex->code = code;
 	ex->stacktrace = stacktrace;
 	ex->id = thread_id_get_current();
-	ex->ref_count = 0;
+
+	threading_atomic_ref_count_store(&ex->ref, 0);
 
 	reflect_memory_tracker_allocation(exception_stats);
 
@@ -128,7 +130,8 @@ exception exception_create_const(const char *message, const char *label, int64_t
 
 	ex->code = code;
 	ex->id = thread_id_get_current();
-	ex->ref_count = 0;
+
+	threading_atomic_ref_count_store(&ex->ref, 0);
 
 	reflect_memory_tracker_allocation(exception_stats);
 
@@ -151,12 +154,11 @@ int exception_increment_reference(exception ex)
 		return 1;
 	}
 
-	if (ex->ref_count == SIZE_MAX)
+	if (threading_atomic_ref_count_increment(&ex->ref) == 1)
 	{
 		return 1;
 	}
 
-	++ex->ref_count;
 	reflect_memory_tracker_increment(exception_stats);
 
 	return 0;
@@ -169,12 +171,11 @@ int exception_decrement_reference(exception ex)
 		return 1;
 	}
 
-	if (ex->ref_count == 0)
+	if (threading_atomic_ref_count_decrement(&ex->ref) == 1)
 	{
 		return 1;
 	}
 
-	--ex->ref_count;
 	reflect_memory_tracker_decrement(exception_stats);
 
 	return 0;
@@ -234,7 +235,7 @@ void exception_destroy(exception ex)
 			log_write("metacall", LOG_LEVEL_ERROR, "Invalid reference counter in exception: %s", ex->label ? ex->label : "<anonymous>");
 		}
 
-		if (ex->ref_count == 0)
+		if (threading_atomic_ref_count_load(&ex->ref) == 0)
 		{
 			if (ex->message != NULL)
 			{
diff --git a/source/reflect/source/reflect_function.c b/source/reflect/source/reflect_function.c
@@ -21,6 +21,8 @@
 #include <reflect/reflect_function.h>
 #include <reflect/reflect_value_type.h>
 
+#include <threading/threading_atomic_ref_count.h>
+
 #include <reflect/reflect_memory_tracker.h>
 
 #include <log/log.h>
@@ -34,7 +36,7 @@ struct function_type
 	signature s;
 	function_impl impl;
 	function_interface interface;
-	size_t ref_count;
+	struct threading_atomic_ref_count_type ref;
 	enum async_id async;
 	void *data;
 };
@@ -77,7 +79,6 @@ function function_create(const char *name, size_t args_count, function_impl impl
 	}
 
 	func->impl = impl;
-	func->ref_count = 0;
 	func->async = SYNCHRONOUS;
 	func->data = NULL;
 
@@ -87,12 +88,11 @@ function function_create(const char *name, size_t args_count, function_impl impl
 	{
 		log_write("metacall", LOG_LEVEL_ERROR, "Invalid function signature allocation");
 
-		free(func->name);
-		free(func);
-
-		return NULL;
+		goto function_create_error;
 	}
 
+	threading_atomic_ref_count_store(&func->ref, 0);
+
 	func->interface = singleton ? singleton() : NULL;
 
 	if (func->interface != NULL && func->interface->create != NULL)
@@ -101,16 +101,19 @@ function function_create(const char *name, size_t args_count, function_impl impl
 		{
 			log_write("metacall", LOG_LEVEL_ERROR, "Invalid function (%s) create callback <%p>", func->name, func->interface->create);
 
-			free(func->name);
-			free(func);
-
-			return NULL;
+			goto function_create_error;
 		}
 	}
 
 	reflect_memory_tracker_allocation(function_stats);
 
 	return func;
+
+function_create_error:
+	free(func->name);
+	free(func);
+
+	return NULL;
 }
 
 int function_increment_reference(function func)
@@ -120,12 +123,11 @@ int function_increment_reference(function func)
 		return 1;
 	}
 
-	if (func->ref_count == SIZE_MAX)
+	if (threading_atomic_ref_count_increment(&func->ref) == 1)
 	{
 		return 1;
 	}
 
-	++func->ref_count;
 	reflect_memory_tracker_increment(function_stats);
 
 	return 0;
@@ -138,12 +140,11 @@ int function_decrement_reference(function func)
 		return 1;
 	}
 
-	if (func->ref_count == 0)
+	if (threading_atomic_ref_count_decrement(&func->ref) == 1)
 	{
 		return 1;
 	}
 
-	--func->ref_count;
 	reflect_memory_tracker_decrement(function_stats);
 
 	return 0;
@@ -639,7 +640,7 @@ void function_destroy(function func)
 			log_write("metacall", LOG_LEVEL_ERROR, "Invalid reference counter in function: %s", func->name ? func->name : "<anonymous>");
 		}
 
-		if (func->ref_count == 0)
+		if (threading_atomic_ref_count_load(&func->ref) == 0)
 		{
 			if (func->name == NULL)
 			{
diff --git a/source/reflect/source/reflect_object.c b/source/reflect/source/reflect_object.c
@@ -27,6 +27,8 @@
 
 #include <reflect/reflect_memory_tracker.h>
 
+#include <threading/threading_atomic_ref_count.h>
+
 #include <log/log.h>
 
 #include <stdlib.h>
@@ -38,7 +40,7 @@ struct object_type
 	enum accessor_type_id accessor;
 	object_impl impl;
 	object_interface interface;
-	size_t ref_count;
+	struct threading_atomic_ref_count_type ref;
 	klass cls;
 };
 
@@ -79,7 +81,8 @@ object object_create(const char *name, enum accessor_type_id accessor, object_im
 
 	obj->impl = impl;
 	obj->accessor = accessor;
-	obj->ref_count = 0;
+	threading_atomic_ref_count_store(&obj->ref, 0);
+
 	obj->interface = singleton ? singleton() : NULL;
 
 	obj->cls = cls;
@@ -109,12 +112,11 @@ int object_increment_reference(object obj)
 		return 1;
 	}
 
-	if (obj->ref_count == SIZE_MAX)
+	if (threading_atomic_ref_count_increment(&obj->ref) == 1)
 	{
 		return 1;
 	}
 
-	++obj->ref_count;
 	reflect_memory_tracker_increment(object_stats);
 
 	return 0;
@@ -127,12 +129,11 @@ int object_decrement_reference(object obj)
 		return 1;
 	}
 
-	if (obj->ref_count == 0)
+	if (threading_atomic_ref_count_decrement(&obj->ref) == 1)
 	{
 		return 1;
 	}
 
-	--obj->ref_count;
 	reflect_memory_tracker_decrement(object_stats);
 
 	return 0;
@@ -393,7 +394,7 @@ void object_destroy(object obj)
 			log_write("metacall", LOG_LEVEL_ERROR, "Invalid reference counter in object: %s", obj->name ? obj->name : "<anonymous>");
 		}
 
-		if (obj->ref_count == 0)
+		if (threading_atomic_ref_count_load(&obj->ref) == 0)
 		{
 			if (obj->name == NULL)
 			{
diff --git a/source/threading/CMakeLists.txt b/source/threading/CMakeLists.txt
@@ -37,6 +37,7 @@ set(headers
 	${include_path}/threading.h
 	${include_path}/threading_atomic.h
 	${include_path}/threading_thread_id.h
+	${include_path}/threading_atomic_ref_count.h
 )
 
 set(sources
diff --git a/source/threading/include/threading/threading_atomic_ref_count.h b/source/threading/include/threading/threading_atomic_ref_count.h
diff --git a/source/threading/include/threading/threading_thread_id.h b/source/threading/include/threading/threading_thread_id.h

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,8 @@`
`27`	`27`
`28`	`28`	`#include <reflect/reflect_accessor.h>`
`29`	`29`
	`30`	`+#include <threading/threading_atomic_ref_count.h>`
	`31`	`+`
`30`	`32`	`#include <reflect/reflect_memory_tracker.h>`
`31`	`33`
`32`	`34`	`#include <log/log.h>`
`@@ -40,7 +42,7 @@ struct class_type`
`40`	`42`	`enum accessor_type_id accessor;`
`41`	`43`	`class_impl impl;`
`42`	`44`	`class_interface interface;`
`43`		`- size_t ref_count;`
	`45`	`+ struct threading_atomic_ref_count_type ref;`
`44`	`46`	`vector constructors;`
`45`	`47`	`map methods;`
`46`	`48`	`map static_methods;`
`@@ -106,7 +108,7 @@ klass class_create(const char *name, enum accessor_type_id accessor, class_impl`
`106`	`108`
`107`	`109`	`cls->impl = impl;`
`108`	`110`	`cls->accessor = accessor;`
`109`		`- cls->ref_count = 0;`
	`111`	`+ threading_atomic_ref_count_store(&cls->ref, 0);`
`110`	`112`	`cls->interface = singleton ? singleton() : NULL;`
`111`	`113`	`cls->constructors = vector_create_type(constructor);`
`112`	`114`	`cls->methods = map_create(&hash_callback_str, &comparable_callback_str);`
`@@ -144,12 +146,11 @@ int class_increment_reference(klass cls)`
`144`	`146`	`return 1;`
`145`	`147`	`}`
`146`	`148`
`147`		`- if (cls->ref_count == SIZE_MAX)`
	`149`	`+ if (threading_atomic_ref_count_increment(&cls->ref) == 1)`
`148`	`150`	`{`
`149`	`151`	`return 1;`
`150`	`152`	`}`
`151`	`153`
`152`		`- ++cls->ref_count;`
`153`	`154`	`reflect_memory_tracker_increment(class_stats);`
`154`	`155`
`155`	`156`	`return 0;`
`@@ -162,12 +163,11 @@ int class_decrement_reference(klass cls)`
`162`	`163`	`return 1;`
`163`	`164`	`}`
`164`	`165`
`165`		`- if (cls->ref_count == 0)`
	`166`	`+ if (threading_atomic_ref_count_decrement(&cls->ref) == 1)`
`166`	`167`	`{`
`167`	`168`	`return 1;`
`168`	`169`	`}`
`169`	`170`
`170`		`- --cls->ref_count;`
`171`	`171`	`reflect_memory_tracker_decrement(class_stats);`
`172`	`172`
`173`	`173`	`return 0;`
`@@ -843,7 +843,7 @@ void class_destroy(klass cls)`
`843`	`843`	`log_write("metacall", LOG_LEVEL_ERROR, "Invalid reference counter in class: %s", cls->name ? cls->name : "<anonymous>");`
`844`	`844`	`}`
`845`	`845`
`846`		`- if (cls->ref_count == 0)`
	`846`	`+ if (threading_atomic_ref_count_load(&cls->ref) == 0)`
`847`	`847`	`{`
`848`	`848`	`if (cls->name == NULL)`
`849`	`849`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,8 @@`
`21`	`21`	`#include <reflect/reflect_function.h>`
`22`	`22`	`#include <reflect/reflect_value_type.h>`
`23`	`23`
	`24`	`+#include <threading/threading_atomic_ref_count.h>`
	`25`	`+`
`24`	`26`	`#include <reflect/reflect_memory_tracker.h>`
`25`	`27`
`26`	`28`	`#include <log/log.h>`
`@@ -34,7 +36,7 @@ struct function_type`
`34`	`36`	`signature s;`
`35`	`37`	`function_impl impl;`
`36`	`38`	`function_interface interface;`
`37`		`- size_t ref_count;`
	`39`	`+ struct threading_atomic_ref_count_type ref;`
`38`	`40`	`enum async_id async;`
`39`	`41`	`void *data;`
`40`	`42`	`};`
`@@ -77,7 +79,6 @@ function function_create(const char *name, size_t args_count, function_impl impl`
`77`	`79`	`}`
`78`	`80`
`79`	`81`	`func->impl = impl;`
`80`		`- func->ref_count = 0;`
`81`	`82`	`func->async = SYNCHRONOUS;`
`82`	`83`	`func->data = NULL;`
`83`	`84`
`@@ -87,12 +88,11 @@ function function_create(const char *name, size_t args_count, function_impl impl`
`87`	`88`	`{`
`88`	`89`	`log_write("metacall", LOG_LEVEL_ERROR, "Invalid function signature allocation");`
`89`	`90`
`90`		`- free(func->name);`
`91`		`- free(func);`
`92`		`-`
`93`		`- return NULL;`
	`91`	`+ goto function_create_error;`
`94`	`92`	`}`
`95`	`93`
	`94`	`+ threading_atomic_ref_count_store(&func->ref, 0);`
	`95`	`+`
`96`	`96`	`func->interface = singleton ? singleton() : NULL;`
`97`	`97`
`98`	`98`	`if (func->interface != NULL && func->interface->create != NULL)`
`@@ -101,16 +101,19 @@ function function_create(const char *name, size_t args_count, function_impl impl`
`101`	`101`	`{`
`102`	`102`	`log_write("metacall", LOG_LEVEL_ERROR, "Invalid function (%s) create callback <%p>", func->name, func->interface->create);`
`103`	`103`
`104`		`- free(func->name);`
`105`		`- free(func);`
`106`		`-`
`107`		`- return NULL;`
	`104`	`+ goto function_create_error;`
`108`	`105`	`}`
`109`	`106`	`}`
`110`	`107`
`111`	`108`	`reflect_memory_tracker_allocation(function_stats);`
`112`	`109`
`113`	`110`	`return func;`
	`111`	`+`
	`112`	`+function_create_error:`
	`113`	`+ free(func->name);`
	`114`	`+ free(func);`
	`115`	`+`
	`116`	`+ return NULL;`
`114`	`117`	`}`
`115`	`118`
`116`	`119`	`int function_increment_reference(function func)`
`@@ -120,12 +123,11 @@ int function_increment_reference(function func)`
`120`	`123`	`return 1;`
`121`	`124`	`}`
`122`	`125`
`123`		`- if (func->ref_count == SIZE_MAX)`
	`126`	`+ if (threading_atomic_ref_count_increment(&func->ref) == 1)`
`124`	`127`	`{`
`125`	`128`	`return 1;`
`126`	`129`	`}`
`127`	`130`
`128`		`- ++func->ref_count;`
`129`	`131`	`reflect_memory_tracker_increment(function_stats);`
`130`	`132`
`131`	`133`	`return 0;`
`@@ -138,12 +140,11 @@ int function_decrement_reference(function func)`
`138`	`140`	`return 1;`
`139`	`141`	`}`
`140`	`142`
`141`		`- if (func->ref_count == 0)`
	`143`	`+ if (threading_atomic_ref_count_decrement(&func->ref) == 1)`
`142`	`144`	`{`
`143`	`145`	`return 1;`
`144`	`146`	`}`
`145`	`147`
`146`		`- --func->ref_count;`
`147`	`148`	`reflect_memory_tracker_decrement(function_stats);`
`148`	`149`
`149`	`150`	`return 0;`
`@@ -639,7 +640,7 @@ void function_destroy(function func)`
`639`	`640`	`log_write("metacall", LOG_LEVEL_ERROR, "Invalid reference counter in function: %s", func->name ? func->name : "<anonymous>");`
`640`	`641`	`}`
`641`	`642`
`642`		`- if (func->ref_count == 0)`
	`643`	`+ if (threading_atomic_ref_count_load(&func->ref) == 0)`
`643`	`644`	`{`
`644`	`645`	`if (func->name == NULL)`
`645`	`646`	`{`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,7 @@ set(headers`
`37`	`37`	`${include_path}/threading.h`
`38`	`38`	`${include_path}/threading_atomic.h`
`39`	`39`	`${include_path}/threading_thread_id.h`
	`40`	`+ ${include_path}/threading_atomic_ref_count.h`
`40`	`41`	`)`
`41`	`42`
`42`	`43`	`set(sources`