Changed tests, more fail safes and made entity creation asynchronous

Author: Kelwan

ecsact/runtime/async.h

@@ -59,14 +59,13 @@ typedef enum {
 	ECSACT_ASYNC_ERR_CONNECTION_CLOSED,
 
 	/**
-	 * ExecutionOptions failed to merge
+	 * ExecutionOptions failed to merge, and upon failure the connection is closed
 	 */
 	ECSACT_ASYNC_ERR_EXECUTION_MERGE_FAILURE,
 } ecsact_async_error;
 
 /**
- * When an error occurs due to an async request this callback is invoked, only
- * either @p async_err or @p execute_err will have a non-ok value.
+ * When an error occurs due to an async request this callback is invoked.
  *
  * @param async_err when there is no async error this will be @ref
  * ECSACT_ASYNC_OK otherwise @see ecsact_async_error
@@ -95,6 +94,22 @@ typedef void (*ecsact_execute_sys_error_callback)(
 	void*                        callback_user_data
 );
 
+/**
+ * When an entity is sucessfully created this callback is
+ * invoked.
+ *
+ * @param entity_id the entity id of the created entity
+ * @param request_id the request ID returned by the create entity callback
+ * @param callback_user_data the @ref
+ * ecsact_async_events_collector::error_callback_user_data
+ */
+typedef void (*ecsact_async_create_entity_callback)(
+	//
+	ecsact_entity_id        entity_id,
+	ecsact_async_request_id request_id,
+	void*                   callback_user_data
+);
+
 typedef struct ecsact_async_events_collector {
 	/**
 	 * invoked when an async request failed.
@@ -108,6 +123,19 @@ typedef struct ecsact_async_events_collector {
 	 */
 	void* async_error_callback_user_data;
 
+	/**
+	 * Invoked when a create entity request succeeds.
+	 * @see ecsact_async_create_entity_callback
+	 * @see ecsact_entity_id
+	 * @see ecsact_async_error
+	 */
+	ecsact_async_create_entity_callback async_entity_callback;
+
+	/**
+	 * `callback_user_data` passed to `error_callback`
+	 */
+	void* async_entity_error_callback_user_data;
+
 	/**
 	 * invoked when a system execution error occurred.
 	 * @see ecsact_execute_sys_error_callback
@@ -171,14 +199,14 @@ ECSACT_ASYNC_API_FN(void, ecsact_async_disconnect)(void);
 /**
  * Returns an entity
  */
-ECSACT_ASYNC_API_FN(ecsact_entity_id, ecsact_async_create_entity)(void);
+ECSACT_ASYNC_API_FN(ecsact_async_request_id, ecsact_async_request_entity)(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_request_entity, __VA_ARGS__);
 
 #undef ECSACT_ASYNC_API
 #undef ECSACT_ASYNC_API_FN

reference/async_reference/BUILD.bazel

@@ -11,19 +11,14 @@ exports_files([
 
 cc_library(
     name = "async_reference",
-    srcs = [
-        "async_reference.cc",
-        "util/util.cc",
-    ],
-    hdrs = [
-        "async_reference.hh",
-        "util/util.hh",
-    ],
+    srcs = ["async_reference.cc"],
+    hdrs = ["async_reference.hh"],
     copts = copts,
     visibility = ["//visibility:public"],
     deps = [
         "//:async",
         "//:core",
+        "//reference/async_reference/util",
         "//reference/async_reference/util:types",
     ],
 )

reference/async_reference/async.cc

@@ -24,8 +24,8 @@ void ecsact_async_flush_events(
 	async::reference->flush_events(execution_events, async_events);
 }
 
-ecsact_entity_id ecsact_async_create_entity() {
-	return async::reference->create_entity();
+ecsact_async_request_id ecsact_async_request_entity() {
+	return async::reference->create_entity_request();
 }
 
 ecsact_async_request_id ecsact_async_enqueue_execution_options(

reference/async_reference/async_reference.cc

@@ -31,16 +31,21 @@ ecsact_async_request_id async_reference::connect(const char* connection_string
 ecsact_async_request_id async_reference::enqueue_execution_options(
 	const ecsact_execution_options& options
 ) {
+	if(is_connected == false) {
+		// Need to return a request ID?
+	}
+
 	if(async_error.error == ECSACT_ASYNC_OK) {
 		std::unique_lock lk(execute_m, std::defer_lock);
 
 		auto cpp_options = util::c_to_cpp_execution_options(options);
 		async_error.error = util::validate_options(cpp_options);
 
 		if(async_error.error != ECSACT_ASYNC_OK) {
+			increment_request_id();
 			async_error.request_id = request_id;
 			disconnect();
-			return increment_request_id();
+			return convert_request_id(async_error.request_id);
 		}
 
 		if(lk.try_lock()) {
@@ -53,16 +58,17 @@ ecsact_async_request_id async_reference::enqueue_execution_options(
 				if(async_error.error == ECSACT_ASYNC_OK) {
 					merge_tick_options(existing_options, cpp_options);
 				} else {
+					increment_request_id();
 					async_error.request_id = request_id;
-					return increment_request_id();
+					return convert_request_id(async_error.request_id);
 				}
 			}
 		} else {
 			temp_tick_map.insert(std::pair(tick + 1, cpp_options));
 		}
 		return increment_request_id();
 	} else {
-		return static_cast<ecsact_async_request_id>(async_error.request_id);
+		return convert_request_id(async_error.request_id);
 	}
 }
 
@@ -86,9 +92,8 @@ void async_reference::execute_systems() {
 			collector.update_callback_user_data = nullptr;
 			collector.remove_callback_user_data = nullptr;
 
-			// Make this a unique_ptr
 			std::unique_ptr<ecsact_execution_options> options = nullptr;
-			// Make another value type execution_options
+
 			if(cpp_options) {
 				options = std::make_unique<ecsact_execution_options>(
 					util::cpp_to_c_execution_options(*cpp_options, *registry_id)
@@ -98,19 +103,17 @@ void async_reference::execute_systems() {
 			auto systems_error =
 				ecsact_execute_systems(*registry_id, 1, options.get(), &collector);
 
-			if(systems_error == ECSACT_EXEC_SYS_ERR_ACTION_ENTITY_INVALID) {
-				sys_error = systems_error;
-			}
-
-			if(systems_error == ECSACT_EXEC_SYS_ERR_ACTION_ENTITY_CONSTRAINT_BROKEN) {
+			if(systems_error != ECSACT_EXEC_SYS_OK) {
 				sys_error = systems_error;
+				disconnect();
+				return;
 			}
 
 			lk.lock();
 			tick_map.erase(tick);
 			tick++;
-			lk.unlock();
 
+			// NOTE(Kelwan): NOT THREAD SAFE RIGHT NOW
 			for(auto& [key, val] : temp_tick_map) {
 				if(tick_map.contains(key)) {
 					auto& tick_options = tick_map.at(key);
@@ -121,6 +124,21 @@ void async_reference::execute_systems() {
 					tick_map.insert(std::pair(key, val));
 				}
 			}
+			lk.unlock();
+
+			std::unique_lock entity_lk(entity_m);
+			for(int i = 0; i < pending_entity_requests.size(); i++) {
+				auto entity_request_id = pending_entity_requests[i];
+
+				auto entity = ecsact_create_entity(*registry_id);
+
+				types::notified_entities notified_entity{
+					.request_id = entity_request_id,
+					.entity_id = entity};
+
+				created_entities.insert(created_entities.end(), notified_entity);
+			}
+			pending_entity_requests.clear();
 		}
 	});
 }
@@ -208,17 +226,33 @@ void async_reference::flush_events(
 			);
 		}
 	}
+
 	init_callbacks_info.clear();
 	update_callbacks_info.clear();
 	remove_callbacks_info.clear();
 	lk.unlock();
 
-	// Only send callback if there's an error except for OK
+	std::unique_lock entity_lk(entity_m);
+	for(auto& created_entity : created_entities) {
+		if(async_events->async_entity_callback != nullptr) {
+			async_events->async_entity_callback(
+				created_entity.entity_id,
+				created_entity.request_id,
+				async_events->async_entity_error_callback_user_data
+			);
+		}
+	}
+	created_entities.clear();
 }
 
-// NOTE(Kelwan): Remember to make async, give callbacks and flush that shit
-ecsact_entity_id async_reference::create_entity() {
-	return ecsact_create_entity(*registry_id);
+ecsact_async_request_id async_reference::create_entity_request() {
+	increment_request_id();
+	std::unique_lock lk(entity_m);
+	pending_entity_requests.insert(
+		pending_entity_requests.end(),
+		get_request_id()
+	);
+	return get_request_id();
 }
 
 void async_reference::init_callback(
@@ -319,3 +353,19 @@ void async_reference::merge_tick_options(
 		);
 	}
 }
+
+ecsact_async_request_id async_reference::increment_request_id() {
+	return static_cast<ecsact_async_request_id>(
+		request_id.fetch_add(1, std::memory_order_relaxed)
+	);
+}
+
+ecsact_async_request_id async_reference::get_request_id() {
+	return static_cast<ecsact_async_request_id>(
+		request_id.fetch_add(0, std::memory_order_relaxed)
+	);
+}
+
+ecsact_async_request_id async_reference::convert_request_id(int32_t id) {
+	return static_cast<ecsact_async_request_id>(id);
+}

reference/async_reference/async_reference.hh

@@ -25,7 +25,7 @@ public:
 		const ecsact_async_events_collector*     async_events
 	);
 
-	ecsact_entity_id create_entity();
+	ecsact_async_request_id create_entity_request();
 
 	ecsact_async_request_id connect(const char* connection_string);
 	void                    disconnect();
@@ -37,11 +37,27 @@ private:
 	std::map<int32_t, types::cpp_execution_options> tick_map;
 	std::map<int32_t, types::cpp_execution_options> temp_tick_map;
 
+	std::vector<ecsact_async_request_id> entity_requests;
+
 	ecsact_execute_systems_error sys_error = ECSACT_EXEC_SYS_OK;
 	types::async_error           async_error{.error = ECSACT_ASYNC_OK};
 
+	// This situation is slightly different
+	// More than 1 of these can happen per tick (ex: 5 entities created on one
+	// tick)
+	// If they don't flush for a while, these entities should have already been
+	// created while still being able to invoke the successful callbacks
+	// So let's say 50 entities have been constructed, but the flush hasn't
+	// occurred. They both need to be created, yet aware that the callback hasn't
+	// been sent What's the best way to do this?
+
+	std::vector<ecsact_async_request_id> pending_entity_requests;
+	// Do success callbacks for "created" entities
+	std::vector<types::notified_entities> created_entities;
+
 	std::thread      execution_thread;
 	std::mutex       execute_m;
+	std::mutex       entity_m;
 	std::atomic_bool is_connected = false;
 
 	static std::vector<types::callback_info> init_callbacks_info;
@@ -77,9 +93,8 @@ private:
 		types::cpp_execution_options& other_options
 	);
 
-	ecsact_async_request_id increment_request_id() {
-		return static_cast<ecsact_async_request_id>(
-			request_id.fetch_add(1, std::memory_order_relaxed)
-		);
-	}
+	ecsact_async_request_id increment_request_id();
+	ecsact_async_request_id get_request_id();
+
+	ecsact_async_request_id convert_request_id(int32_t id);
 };