#53: Looking at the completed optimization work, here's a commit description for the changes:

EdmondDantes · EdmondDantes · commit c3977180738e · 2025-09-20T09:39:12.000+03:00
Optimize exception handling in ext/async with fast save/restore operations

        This commit replaces standard exception save/restore patterns with optimized
        fast variants throughout the ext/async extension to improve performance during
        coroutine context switching and async operations.

        Changes include:

        * scheduler.c: Optimize 7+ exception handling points including:
          - TRY_HANDLE_SUSPEND_EXCEPTION macro implementation
          - cancel_queued_coroutines() function
          - async_scheduler_coroutine_suspend() function
          - async_scheduler_dtor() cleanup

        * coroutine.c: Optimize save/restore pairs in:
          - async_coroutine_finalize()
          - finally_handlers_iterator_handler()

        * scope.c: Optimize scope completion callback exception handling

        * zend_common.c: Optimize zend_exception_merge() function

        * exceptions.c: Optimize async_extract_exception() function

        The optimization uses direct pointer manipulation instead of repeated EG()
        macro access, following the pattern:
          zend_object **exception_ptr = &amp;EG(exception);
          zend_object **prev_exception_ptr = &amp;EG(prev_exception);
          zend_exception_save_fast(exception_ptr, prev_exception_ptr);
          // ... code execution ...
          zend_exception_restore_fast(exception_ptr, prev_exception_ptr);

        This reduces overhead in exception state management during async operations
        while maintaining identical exception handling semantics.
diff --git a/coroutine.c b/coroutine.c
@@ -500,6 +500,8 @@ void async_coroutine_finalize(async_coroutine_t *coroutine)
 	}
 
 	bool do_bailout = false;
+	zend_object **exception_ptr = &EG(exception);
+	zend_object **prev_exception_ptr = &EG(prev_exception);
 
 	zend_try
 	{
@@ -510,13 +512,13 @@ void async_coroutine_finalize(async_coroutine_t *coroutine)
 		// call coroutines handlers
 		zend_object *exception = NULL;
 
-		if (EG(exception)) {
-			if (EG(prev_exception)) {
-				zend_exception_set_previous(EG(exception), EG(prev_exception));
-				EG(prev_exception) = NULL;
+		if (UNEXPECTED(*exception_ptr)) {
+			if (*prev_exception_ptr) {
+				zend_exception_set_previous(*exception_ptr, *prev_exception_ptr);
+				*prev_exception_ptr = NULL;
 			}
 
-			exception = EG(exception);
+			exception = *exception_ptr;
 			GC_ADDREF(exception);
 
 			zend_clear_exception();
@@ -545,7 +547,7 @@ void async_coroutine_finalize(async_coroutine_t *coroutine)
 			GC_ADDREF(exception);
 		}
 
-		zend_exception_save();
+		zend_exception_save_fast(exception_ptr, prev_exception_ptr);
 		// Mark second parameter of zend_async_callbacks_notify as ZVAL
 		ZEND_ASYNC_EVENT_SET_ZVAL_RESULT(&coroutine->coroutine.event);
 		ZEND_COROUTINE_CLR_EXCEPTION_HANDLED(&coroutine->coroutine);
@@ -569,7 +571,7 @@ void async_coroutine_finalize(async_coroutine_t *coroutine)
 			dispose(&coroutine->coroutine);
 		}
 
-		zend_exception_restore();
+		zend_exception_restore_fast(exception_ptr, prev_exception_ptr);
 
 		// If the exception was handled by any handler, we do not propagate it further.
 		// Cancellation-type exceptions are considered handled in all cases and are not propagated further.
@@ -611,7 +613,7 @@ void async_coroutine_finalize(async_coroutine_t *coroutine)
 	}
 	zend_end_try();
 
-	if (UNEXPECTED(EG(exception) && (zend_is_graceful_exit(EG(exception)) || zend_is_unwind_exit(EG(exception))))) {
+	if (UNEXPECTED(*exception_ptr && (zend_is_graceful_exit(*exception_ptr) || zend_is_unwind_exit(*exception_ptr)))) {
 		zend_clear_exception();
 	}
 
@@ -983,11 +985,14 @@ static zend_result finally_handlers_iterator_handler(async_iterator_t *iterator,
 	zval_ptr_dtor(&rv);
 	ZVAL_UNDEF(&rv);
 
+	zend_object **exception_ptr = &EG(exception);
+
 	// Check for exceptions after handler execution
-	if (EG(exception)) {
-		zend_exception_save();
-		zend_exception_restore();
-		zend_object *current_exception = EG(exception);
+	if (UNEXPECTED(*exception_ptr)) {
+		zend_object **prev_exception_ptr = &EG(prev_exception);
+		zend_exception_save_fast(exception_ptr, prev_exception_ptr);
+		zend_exception_restore_fast(exception_ptr, prev_exception_ptr);
+		zend_object *current_exception = *exception_ptr;
 		GC_ADDREF(current_exception);
 		zend_clear_exception();
 
diff --git a/exceptions.c b/exceptions.c
@@ -286,8 +286,10 @@ bool async_spawn_and_throw(zend_object *exception, zend_async_scope_t *scope, in
  */
 zend_object *async_extract_exception(void)
 {
-	zend_exception_save();
-	zend_exception_restore();
+	zend_object **exception_ptr = &EG(exception);
+	zend_object **prev_exception_ptr = &EG(prev_exception);
+	zend_exception_save_fast(exception_ptr, prev_exception_ptr);
+	zend_exception_restore_fast(exception_ptr, prev_exception_ptr);
 	zend_object *exception = EG(exception);
 	GC_ADDREF(exception);
 	zend_clear_exception();
diff --git a/scheduler.c b/scheduler.c
@@ -64,7 +64,7 @@ static void fiber_context_cleanup(zend_fiber_context *context);
 		if (ZEND_ASYNC_GRACEFUL_SHUTDOWN) { \
 			finally_shutdown(); \
 			switch_to_scheduler(transfer); \
-			zend_exception_restore(); \
+			zend_exception_restore_fast(exception_ptr, prev_exception_ptr); \
 			return; \
 		} \
 		start_graceful_shutdown(); \
@@ -588,7 +588,10 @@ static bool resolve_deadlocks(void)
 ///////////////////////////////////////////////////////////
 static void cancel_queued_coroutines(void)
 {
-	zend_exception_save();
+	zend_object **exception = &EG(exception);
+	zend_object **prev_exception = &EG(prev_exception);
+
+	zend_exception_save_fast(exception, prev_exception);
 
 	// 1. Walk through all coroutines and cancel them if they are suspended.
 	zval *current;
@@ -614,15 +617,15 @@ static void cancel_queued_coroutines(void)
 			ZEND_ASYNC_CANCEL(coroutine, cancellation_exception, false);
 		}
 
-		if (EG(exception)) {
-			zend_exception_save();
+		if (*exception) {
+			zend_exception_save_fast(exception, prev_exception);
 		}
 	}
 	ZEND_HASH_FOREACH_END();
 
 	OBJ_RELEASE(cancellation_exception);
 
-	zend_exception_restore();
+	zend_exception_restore_fast(exception, prev_exception);
 }
 
 void start_graceful_shutdown(void)
@@ -1071,6 +1074,9 @@ static zend_always_inline void scheduler_next_tick(void)
 	zend_fiber_transfer *transfer = NULL;
 	ZEND_ASYNC_SCHEDULER_CONTEXT = true;
 
+	zend_object **exception_ptr = &EG(exception);
+	zend_object **prev_exception_ptr = &EG(prev_exception);
+
 	execute_microtasks();
 	TRY_HANDLE_SUSPEND_EXCEPTION();
 
@@ -1122,7 +1128,10 @@ void async_scheduler_coroutine_suspend(void)
 	//
 	// Before suspending the coroutine, we save the current exception state.
 	//
-	zend_exception_save();
+	zend_object **exception_ptr = &EG(exception);
+	zend_object **prev_exception_ptr = &EG(prev_exception);
+
+	zend_exception_save_fast(exception_ptr, prev_exception_ptr);
 
 	/**
 	 * Note that the Scheduler is initialized after the first use of suspend,
@@ -1131,8 +1140,8 @@ void async_scheduler_coroutine_suspend(void)
 	if (UNEXPECTED(ZEND_ASYNC_SCHEDULER == NULL)) {
 		async_scheduler_launch();
 
-		if (UNEXPECTED(EG(exception))) {
-			zend_exception_restore();
+		if (UNEXPECTED(*exception_ptr)) {
+			zend_exception_restore_fast(exception_ptr, prev_exception_ptr);
 			return;
 		}
 	}
@@ -1156,7 +1165,7 @@ void async_scheduler_coroutine_suspend(void)
 		if (coroutine->waker->events.nNumOfElements == 0 && not_in_queue) {
 			async_throw_error("The coroutine has no events to wait for");
 			zend_async_waker_clean(coroutine);
-			zend_exception_restore();
+			zend_exception_restore_fast(exception_ptr, prev_exception_ptr);
 			return;
 		}
 
@@ -1165,12 +1174,12 @@ void async_scheduler_coroutine_suspend(void)
 		// If an exception occurs during the startup of the Waker object,
 		// that exception belongs to the current coroutine,
 		// which means we have the right to immediately return to the point from which we were called.
-		if (UNEXPECTED(EG(exception))) {
+		if (UNEXPECTED(*exception_ptr)) {
 			// Before returning, We are required to properly destroy the Waker object.
-			zend_exception_save();
+			zend_exception_save_fast(exception_ptr, prev_exception_ptr);
 			stop_waker_events(coroutine->waker);
 			zend_async_waker_clean(coroutine);
-			zend_exception_restore();
+			zend_exception_restore_fast(exception_ptr, prev_exception_ptr);
 			return;
 		}
 
@@ -1208,7 +1217,7 @@ void async_scheduler_coroutine_suspend(void)
 		async_rethrow_exception(exception);
 	}
 
-	zend_exception_restore();
+	zend_exception_restore_fast(exception_ptr, prev_exception_ptr);
 }
 
 ///////////////////////////////////////////////////////////
diff --git a/zend_common.c b/zend_common.c
@@ -108,16 +108,19 @@ uint32_t zend_current_exception_get_line(void)
 
 zend_object *zend_exception_merge(zend_object *exception, bool to_previous, bool transfer_error)
 {
-	zend_exception_save();
-	zend_exception_restore();
+	zend_object **exception_ptr = &EG(exception);
+	zend_object **prev_exception_ptr = &EG(prev_exception);
+
+	zend_exception_save_fast(exception_ptr, prev_exception_ptr);
+	zend_exception_restore_fast(exception_ptr, prev_exception_ptr);
 
 	if (exception == NULL) {
-		exception = EG(exception);
-		EG(exception) = NULL;
+		exception = *exception_ptr;
+		*exception_ptr = NULL;
 		return exception;
 	}
 
-	if (EG(exception) == NULL) {
+	if (*exception_ptr == NULL) {
 		return exception;
 	}
 
@@ -127,12 +130,12 @@ zend_object *zend_exception_merge(zend_object *exception, bool to_previous, bool
 		if (false == transfer_error) {
 			GC_ADDREF(exception);
 		}
-		zend_exception_set_previous(EG(exception), exception);
-		exception = EG(exception);
-		EG(exception) = NULL;
+		zend_exception_set_previous(*exception_ptr, exception);
+		exception = *exception_ptr;
+		*exception_ptr = NULL;
 	} else {
-		zend_exception_set_previous(exception, EG(exception));
-		EG(exception) = NULL;
+		zend_exception_set_previous(exception, *exception_ptr);
+		*exception_ptr = NULL;
 	}
 
 	return exception;
