Fix locking issues

Author: Kelwan

.gitignore

@@ -8,3 +8,6 @@
 
 # clangd
 /.cache/
+
+# Visual Studio files
+/.vs

ecsact/runtime/async.h

@@ -208,12 +208,18 @@ ECSACT_ASYNC_API_FN(void, ecsact_async_disconnect)(void);
  */
 ECSACT_ASYNC_API_FN(ecsact_async_request_id, ecsact_async_create_entity)(void);
 
+/**
+ * Gets the current tick
+ */
+ECSACT_ASYNC_API_FN(int, ecsact_async_get_current_tick)(void);
+
 #define FOR_EACH_ECSACT_ASYNC_API_FN(fn, ...)              \
 	fn(ecsact_async_enqueue_execution_options, __VA_ARGS__); \
 	fn(ecsact_async_flush_events, __VA_ARGS__);              \
 	fn(ecsact_async_connect, __VA_ARGS__);                   \
 	fn(ecsact_async_disconnect, __VA_ARGS__);                \
-	fn(ecsact_async_create_entity, __VA_ARGS__);
+	fn(ecsact_async_create_entity, __VA_ARGS__);             \
+	fn(ecsact_async_get_current_tick, __VA_ARGS__);
 
 #undef ECSACT_ASYNC_API
 #undef ECSACT_ASYNC_API_FN

reference/async_reference/async.cc

@@ -13,23 +13,40 @@ ecsact_async_request_id ecsact_async_connect(const char* connection_string) {
 }
 
 void ecsact_async_disconnect() {
-	async::reference->disconnect();
-	async::reference.reset();
+	if(async::reference) {
+		async::reference->disconnect();
+		async::reference.reset();
+	}
 }
 
 void ecsact_async_flush_events(
 	const ecsact_execution_events_collector* execution_events,
 	const ecsact_async_events_collector*     async_events
 ) {
-	async::reference->flush_events(execution_events, async_events);
+	if(async::reference) {
+		async::reference->flush_events(execution_events, async_events);
+	}
 }
 
 ecsact_async_request_id ecsact_async_create_entity() {
-	return async::reference->create_entity_request();
+	if(async::reference) {
+		return async::reference->create_entity_request();
+	}
+	return static_cast<ecsact_async_request_id>(15);
 }
 
 ecsact_async_request_id ecsact_async_enqueue_execution_options(
 	const ecsact_execution_options options
 ) {
-	return async::reference->enqueue_execution_options(options);
+	if(async::reference) {
+		return async::reference->enqueue_execution_options(options);
+	}
+	return {};
+}
+
+int32_t ecsact_async_get_current_tick() {
+	if(async::reference) {
+		return async::reference->get_current_tick();
+	}
+	return {};
 }

reference/async_reference/async_reference.cc

@@ -135,6 +135,9 @@ void async_reference::execute_systems() {
 		while(is_connected == true) {
 			auto async_err = tick_manager.validate_pending_options();
 
+			// TESTING WITHOUT OPTIMIZATION
+			// std::this_thread::sleep_for(tick_rate);
+
 			const auto sleep_duration = tick_rate - execution_duration;
 
 			auto wait_start = clock::now();
@@ -217,6 +220,10 @@ ecsact_async_request_id async_reference::create_entity_request() {
 	return req_id;
 }
 
+int32_t async_reference::get_current_tick() {
+	return tick_manager.get_current_tick();
+}
+
 void async_reference::disconnect() {
 	is_connected = false;
 	if(execution_thread.joinable()) {

reference/async_reference/async_reference.hh

@@ -8,6 +8,7 @@
 #include <atomic>
 #include <optional>
 #include <variant>
+#include <condition_variable>
 #include "ecsact/runtime/core.hh"
 #include "ecsact/runtime/async.h"
 
@@ -33,6 +34,9 @@ public:
 	);
 
 	ecsact_async_request_id create_entity_request();
+
+	int32_t get_current_tick();
+
 	ecsact_async_request_id connect(const char* connection_string);
 
 	void disconnect();
@@ -53,6 +57,10 @@ private:
 	std::atomic_bool is_connected = false;
 	std::atomic_bool is_connected_notified = false;
 
+	std::condition_variable execute_cv;
+
+	std::atomic_bool has_executed = false;
+
 	std::chrono::milliseconds tick_rate = {};
 
 	ecsact_async_request_id next_request_id();

reference/async_reference/callbacks/async_callbacks.cc

@@ -7,6 +7,10 @@ void async_callbacks::add(const types::async_requests type) {
 
 void async_callbacks::invoke(const ecsact_async_events_collector* async_events
 ) {
+	if(requests.empty()) {
+		return;
+	}
+
 	if(async_events == nullptr) {
 		std::unique_lock lk(async_m);
 		requests.clear();
@@ -15,6 +19,7 @@ void async_callbacks::invoke(const ecsact_async_events_collector* async_events
 
 	std::vector<types::async_requests> pending_requests;
 
+	// Does it have no value? Don't lock!
 	std::unique_lock lk(async_m);
 	pending_requests = std::move(requests);
 	requests.clear();

reference/async_reference/callbacks/execution_callbacks.cc

@@ -17,11 +17,17 @@ void execution_callbacks::invoke(
 	const ecsact_execution_events_collector* execution_events,
 	ecsact_registry_id                       registry_id
 ) {
+	if(!has_callbacks()) {
+		return;
+	}
+
 	if(execution_events == nullptr) {
-		std::unique_lock lk(execution_m);
-		init_callbacks_info.clear();
-		update_callbacks_info.clear();
-		remove_callbacks_info.clear();
+		if(has_callbacks()) {
+			std::unique_lock lk(execution_m);
+			init_callbacks_info.clear();
+			update_callbacks_info.clear();
+			remove_callbacks_info.clear();
+		}
 		return;
 	}
 
@@ -105,6 +111,22 @@ void execution_callbacks::invoke(
 	}
 }
 
+bool execution_callbacks::has_callbacks() {
+	if(init_callbacks_info.size() > 0) {
+		return true;
+	}
+
+	if(update_callbacks_info.size() > 0) {
+		return true;
+	}
+
+	if(remove_callbacks_info.size() > 0) {
+		return true;
+	}
+
+	return false;
+}
+
 void execution_callbacks::init_callback(
 	ecsact_event        event,
 	ecsact_entity_id    entity_id,

reference/async_reference/callbacks/execution_callbacks.hh

@@ -33,6 +33,8 @@ private:
 	std::vector<types::callback_info> update_callbacks_info;
 	std::vector<types::callback_info> remove_callbacks_info;
 
+	bool has_callbacks();
+
 	static void init_callback(
 		ecsact_event        event,
 		ecsact_entity_id    entity_id,