#53: * fix memory leak by resumed_coroutines logic

Author: EdmondDantes

coroutine.c

@@ -694,15 +694,17 @@ void async_coroutine_resume(zend_coroutine_t *coroutine, zend_object *error, con
 		return;
 	}
 
-	if (UNEXPECTED(circular_buffer_push(&ASYNC_G(coroutine_queue), &coroutine, true)) == FAILURE) {
+	if (UNEXPECTED(circular_buffer_push_ptr_with_resize(&ASYNC_G(coroutine_queue), coroutine)) == FAILURE) {
 		async_throw_error("Failed to enqueue coroutine");
 		return;
 	}
 
 	coroutine->waker->status = ZEND_ASYNC_WAKER_QUEUED;
 
 	// Add to resumed_coroutines queue for event cleanup
-	circular_buffer_push(&ASYNC_G(resumed_coroutines), &coroutine, true);
+	if (ZEND_ASYNC_IS_SCHEDULER_CONTEXT) {
+		circular_buffer_push_ptr_with_resize(&ASYNC_G(resumed_coroutines), coroutine);
+	}
 }
 
 void async_coroutine_cancel(zend_coroutine_t *zend_coroutine,

internal/circular_buffer.h

@@ -87,6 +87,10 @@ static zend_always_inline bool circular_buffer_is_not_empty(const circular_buffe
     return buffer->head != buffer->tail;
 }
 
+static zend_always_inline void circular_buffer_clean(circular_buffer_t *buffer) {
+	buffer->head = buffer->tail;
+}
+
 /* Fast specialized version for pointer push (8 bytes) */
 static zend_always_inline zend_result circular_buffer_push_ptr(circular_buffer_t *buffer, void *ptr) {
     // Check if buffer is full using bitwise AND (capacity is power of 2)
@@ -121,4 +125,4 @@ static zend_always_inline zend_result circular_buffer_push_ptr_with_resize(circu
     return circular_buffer_push(buffer, &ptr, true);
 }
 
-#endif // ASYNC_CIRCULAR_BUFFER_V2_H
+#endif // ASYNC_CIRCULAR_BUFFER_V2_H

scheduler.c

@@ -1044,7 +1044,9 @@ void async_scheduler_coroutine_enqueue(zend_coroutine_t *coroutine)
 			coroutine->waker->status = ZEND_ASYNC_WAKER_QUEUED;
 
 			// Add to resumed_coroutines queue for event cleanup
-			circular_buffer_push_ptr_with_resize(&ASYNC_G(resumed_coroutines), coroutine);
+			if (ZEND_ASYNC_IS_SCHEDULER_CONTEXT) {
+				circular_buffer_push_ptr_with_resize(&ASYNC_G(resumed_coroutines), coroutine);
+			}
 		}
 
 		//
@@ -1074,11 +1076,11 @@ static zend_always_inline void scheduler_next_tick(void)
 
 	if (UNEXPECTED(current_time - ASYNC_G(last_reactor_tick) > REACTOR_CHECK_INTERVAL)) {
 		ASYNC_G(last_reactor_tick) = current_time;
-		const circular_buffer_t * queue = &ASYNC_G(coroutine_queue);
+		const circular_buffer_t *queue = &ASYNC_G(coroutine_queue);
 
 		has_handles = ZEND_ASYNC_REACTOR_EXECUTE(circular_buffer_is_not_empty(queue));
 
-		if (circular_buffer_is_not_empty(&ASYNC_G(resumed_coroutines))) {
+		if (circular_buffer_is_not_empty(&ASYNC_G(coroutine_queue))) {
 			process_resumed_coroutines();
 		}
 
@@ -1290,7 +1292,7 @@ ZEND_STACK_ALIGNED void fiber_entry(zend_fiber_transfer *transfer)
 		switch_status status = COROUTINE_NOT_EXISTS;
 
 		const circular_buffer_t *coroutine_queue = &ASYNC_G(coroutine_queue);
-		const circular_buffer_t *resumed_coroutines = &ASYNC_G(resumed_coroutines);
+		circular_buffer_t *resumed_coroutines = &ASYNC_G(resumed_coroutines);
 
 		do {
 
@@ -1303,6 +1305,8 @@ ZEND_STACK_ALIGNED void fiber_entry(zend_fiber_transfer *transfer)
 			execute_microtasks();
 			TRY_HANDLE_EXCEPTION();
 
+			ZEND_ASSERT(circular_buffer_is_not_empty(resumed_coroutines) == 0 && "resumed_coroutines should be 0");
+
 			has_next_coroutine = circular_buffer_count(coroutine_queue) > 0;
 			has_handles = ZEND_ASYNC_REACTOR_EXECUTE(has_next_coroutine);