Merge branch 'true-async-api' into true-async-api-stable

Author: EdmondDantes

Zend/zend_async_API.c

@@ -406,7 +406,7 @@ ZEND_API zend_async_event_callback_t * zend_async_event_callback_new(zend_async_
 	return event_callback;
 }
 
-static void coroutine_event_callback_dispose(zend_async_event_callback_t *callback, zend_async_event_t * event);
+void coroutine_event_callback_dispose(zend_async_event_callback_t *callback, zend_async_event_t * event);
 
 ZEND_API zend_coroutine_event_callback_t * zend_async_coroutine_callback_new(
 	zend_coroutine_t * coroutine, zend_async_event_callback_fn callback, size_t size
@@ -537,7 +537,7 @@ ZEND_API void zend_async_waker_destroy(zend_coroutine_t *coroutine)
 	efree(waker);
 }
 
-static void coroutine_event_callback_dispose(zend_async_event_callback_t *callback, zend_async_event_t * event)
+void coroutine_event_callback_dispose(zend_async_event_callback_t *callback, zend_async_event_t * event)
 {
 	if (callback->ref_count > 1) {
 		// If the callback is still referenced, we cannot dispose it yet
@@ -552,14 +552,18 @@ static void coroutine_event_callback_dispose(zend_async_event_callback_t *callba
 
 	callback->ref_count = 0;
 
-	zend_async_waker_t * waker = ((zend_coroutine_event_callback_t *) callback)->coroutine->waker;
+	const zend_coroutine_t * coroutine = ((zend_coroutine_event_callback_t *) callback)->coroutine;
 
-	if (event != NULL && waker != NULL) {
-		// remove the event from the waker
-		zend_hash_index_del(&waker->events, (zend_ulong)event);
+	if (EXPECTED(coroutine != NULL)) {
+		zend_async_waker_t * waker = coroutine->waker;
 
-		if (waker->triggered_events != NULL) {
-			zend_hash_index_del(waker->triggered_events, (zend_ulong)event);
+		if (event != NULL && waker != NULL) {
+			// remove the event from the waker
+			zend_hash_index_del(&waker->events, (zend_ulong)event);
+
+			if (waker->triggered_events != NULL) {
+				zend_hash_index_del(waker->triggered_events, (zend_ulong)event);
+			}
 		}
 	}
 
@@ -582,6 +586,15 @@ ZEND_API void zend_async_waker_add_triggered_event(zend_coroutine_t *coroutine,
 	}
 }
 
+ZEND_API bool zend_async_waker_is_event_exists(zend_coroutine_t *coroutine, zend_async_event_t *event)
+{
+	if (UNEXPECTED(coroutine->waker == NULL)) {
+		return false;
+	}
+
+	return zend_hash_index_find(&coroutine->waker->events, (zend_ulong)event) != NULL;
+}
+
 ZEND_API void zend_async_resume_when(
 		zend_coroutine_t			*coroutine,
 		zend_async_event_t			*event,
@@ -590,6 +603,8 @@ ZEND_API void zend_async_resume_when(
 		zend_coroutine_event_callback_t *event_callback
 	)
 {
+	bool locally_allocated_callback = false;
+	
 	if (UNEXPECTED(ZEND_ASYNC_EVENT_IS_CLOSED(event))) {
 		zend_throw_error(NULL, "The event cannot be used after it has been terminated");
 		return;
@@ -610,6 +625,7 @@ ZEND_API void zend_async_resume_when(
 		event_callback->base.ref_count = 1;
 		event_callback->base.callback = callback;
 		event_callback->base.dispose = coroutine_event_callback_dispose;
+		locally_allocated_callback = true;
 	}
 
 	// Set up the default dispose function if not set
@@ -627,6 +643,10 @@ ZEND_API void zend_async_resume_when(
 	event->add_callback(event, &event_callback->base);
 
 	if (UNEXPECTED(EG(exception) != NULL)) {
+		if (locally_allocated_callback) {
+			event_callback->base.dispose(&event_callback->base, event);
+		}
+		
 		if (trans_event) {
 			event->dispose(event);
 		}
@@ -640,7 +660,18 @@ ZEND_API void zend_async_resume_when(
 		trigger->callback = &event_callback->base;
 
 		if (UNEXPECTED(zend_hash_index_add_ptr(&coroutine->waker->events, (zend_ulong)event, trigger) == NULL)) {
-			zend_throw_error(NULL, "Failed to add event to the waker");
+			efree(trigger);
+
+			if (locally_allocated_callback) {
+				event_callback->base.dispose(&event_callback->base, event);
+			}
+
+			if (trans_event) {
+				event->dispose(event);
+			}
+
+			zend_throw_error(NULL, "Failed to add event to the waker: maybe event already exists");
+
 			return;
 		}
 	}

Zend/zend_async_API.h

@@ -19,9 +19,9 @@
 #include "zend_fibers.h"
 #include "zend_globals.h"
 
-#define ZEND_ASYNC_API "TrueAsync API v0.2.0"
+#define ZEND_ASYNC_API "TrueAsync API v0.3.0"
 #define ZEND_ASYNC_API_VERSION_MAJOR 0
-#define ZEND_ASYNC_API_VERSION_MINOR 2
+#define ZEND_ASYNC_API_VERSION_MINOR 3
 #define ZEND_ASYNC_API_VERSION_PATCH 0
 
 #define ZEND_ASYNC_API_VERSION_NUMBER \
@@ -88,6 +88,11 @@ typedef enum {
 	ZEND_ASYNC_EXEC_MODE_SHELL_EXEC
 } zend_async_exec_mode;
 
+typedef enum {
+	ZEND_COROUTINE_NORMAL = 0,
+	ZEND_COROUTINE_HI_PRIORITY = 255
+} zend_coroutine_priority;
+
 typedef enum
 {
 	ZEND_ASYNC_CLASS_NO = 0,
@@ -334,7 +339,9 @@ typedef void (*zend_async_iterator_method_t)(zend_async_iterator_t *iterator);
 	/* The maximum number of concurrent tasks that can be executed at the same time */ \
 	unsigned int concurrency; \
 	/* Priority for coroutines created by this iterator */ \
-	int32_t priority;
+	int32_t priority; \
+	/* NULLABLE. Exception that stopped the iterator */ \
+	zend_object * exception;
 
 struct _zend_async_iterator_s {
 	ZEND_ASYNC_ITERATOR_FIELDS
@@ -381,10 +388,12 @@ struct _zend_async_event_callback_s {
 	}
 
 #define ZEND_ASYNC_EVENT_CALLBACK_RELEASE(callback) \
-	if (callback != NULL && callback->ref_count > 1) { \
-		callback->ref_count--; \
+	if ((callback) != NULL && (callback)->ref_count > 1) { \
+		(callback)->ref_count--; \
+	} else if((callback)->dispose != NULL) { \
+		(callback)->dispose((callback), NULL); \
 	} else { \
-		coroutine_event_callback_dispose(callback, NULL); \
+		coroutine_event_callback_dispose((callback), NULL); \
 	}
 
 struct _zend_coroutine_event_callback_s {
@@ -789,11 +798,13 @@ struct _zend_async_scope_s {
 #define ZEND_ASYNC_SCOPE_F_NO_FREE_MEMORY	      ZEND_ASYNC_EVENT_F_NO_FREE_MEMORY  /* scope will not free memory in dispose handler */
 #define ZEND_ASYNC_SCOPE_F_DISPOSE_SAFELY 		  (1u << 14)  /* scope will be disposed safely */
 #define ZEND_ASYNC_SCOPE_F_CANCELLED 			  (1u << 15)  /* scope was cancelled */
+#define ZEND_ASYNC_SCOPE_F_DISPOSING 			  (1u << 16)  /* scope disposing */
 
 #define ZEND_ASYNC_SCOPE_IS_CLOSED(scope)         (((scope)->event.flags & ZEND_ASYNC_SCOPE_F_CLOSED) != 0)
 #define ZEND_ASYNC_SCOPE_IS_NO_FREE_MEMORY(scope) (((scope)->event.flags & ZEND_ASYNC_SCOPE_F_NO_FREE_MEMORY) != 0)
 #define ZEND_ASYNC_SCOPE_IS_DISPOSE_SAFELY(scope) (((scope)->event.flags & ZEND_ASYNC_SCOPE_F_DISPOSE_SAFELY) != 0)
 #define ZEND_ASYNC_SCOPE_IS_CANCELLED(scope)      (((scope)->event.flags & ZEND_ASYNC_SCOPE_F_CANCELLED) != 0)
+#define ZEND_ASYNC_SCOPE_IS_DISPOSING(scope)      (((scope)->event.flags & ZEND_ASYNC_SCOPE_F_DISPOSING) != 0)
 
 #define ZEND_ASYNC_SCOPE_SET_CLOSED(scope)        ((scope)->event.flags |=  ZEND_ASYNC_SCOPE_F_CLOSED)
 #define ZEND_ASYNC_SCOPE_CLR_CLOSED(scope)        ((scope)->event.flags &= ~ZEND_ASYNC_SCOPE_F_CLOSED)
@@ -806,6 +817,9 @@ struct _zend_async_scope_s {
 
 #define ZEND_ASYNC_SCOPE_SET_CANCELLED(scope)      ((scope)->event.flags |=  ZEND_ASYNC_SCOPE_F_CANCELLED)
 
+#define ZEND_ASYNC_SCOPE_SET_DISPOSING(scope)	  ((scope)->event.flags |=  ZEND_ASYNC_SCOPE_F_DISPOSING)
+#define ZEND_ASYNC_SCOPE_CLR_DISPOSING(scope)	  ((scope)->event.flags &= ~ZEND_ASYNC_SCOPE_F_DISPOSING)
+
 static zend_always_inline void
 zend_async_scope_add_child(zend_async_scope_t *parent_scope, zend_async_scope_t *child_scope)
 {
@@ -1282,6 +1296,7 @@ ZEND_API zend_async_event_callback_t * zend_async_event_callback_new(zend_async_
 ZEND_API zend_coroutine_event_callback_t * zend_async_coroutine_callback_new(
 	zend_coroutine_t * coroutine, zend_async_event_callback_fn callback, size_t size
 );
+ZEND_API void coroutine_event_callback_dispose(zend_async_event_callback_t *callback, zend_async_event_t * event);
 
 /* Waker API */
 ZEND_API zend_async_waker_t *zend_async_waker_new(zend_coroutine_t *coroutine);
@@ -1293,6 +1308,7 @@ ZEND_API bool zend_async_waker_apply_error(
 );
 ZEND_API void zend_async_waker_destroy(zend_coroutine_t *coroutine);
 ZEND_API void zend_async_waker_add_triggered_event(zend_coroutine_t *coroutine, zend_async_event_t *event);
+ZEND_API bool zend_async_waker_is_event_exists(zend_coroutine_t *coroutine, zend_async_event_t *event);
 
 #define ZEND_ASYNC_WAKER_APPLY_ERROR(waker, error, transfer) zend_async_waker_apply_error((waker), (error), (transfer), true, false)
 #define ZEND_ASYNC_WAKER_APPEND_ERROR(waker, error, transfer) zend_async_waker_apply_error((waker), (error), (transfer), false, false)