#57: Optimize pointer hashing in async waker events

       - Add ptr_to_index() function to improve hash distribution for pointer keys
       - Replace all (zend_ulong) event casts with ptr_to_index(event) calls
       - Use zend_hash_index_find_ptr() where appropriate to simplify code
       - Preserve critical memory management in waker trigger updates

       The ptr_to_index() function uses right rotation by 3 bits to better
       distribute pointer addresses as hash keys, reducing collisions caused
       by zero lower bits from memory alignment.

Author: EdmondDantes

coroutine.c

@@ -241,20 +241,18 @@ static HashTable *async_coroutine_object_gc(zend_object *object, zval **table, i
 		}
 
 		/* Add events HashTable contents */
-		zval *event_val;
+		zend_async_event_t *event;
 		zval zval_object;
-		ZEND_HASH_FOREACH_VAL(&coroutine->waker.events, event_val)
+		ZEND_HASH_FOREACH_PTR(&coroutine->waker.events, event)
 		{
-
-			zend_async_event_t *event = (zend_async_event_t *) Z_PTR_P(event_val);
-
 			if (ZEND_ASYNC_EVENT_IS_REFERENCE(event) || ZEND_ASYNC_EVENT_IS_ZEND_OBJ(event)) {
 				ZVAL_OBJ(&zval_object, ZEND_ASYNC_EVENT_TO_OBJECT(event));
 				zend_get_gc_buffer_add_zval(buf, &zval_object);
 			}
 		}
 		ZEND_HASH_FOREACH_END();
 
+		zval *event_val;
 		/* Add triggered events if present */
 		if (coroutine->waker.triggered_events) {
 			ZEND_HASH_FOREACH_VAL(coroutine->waker.triggered_events, event_val)

libuv_reactor.c

@@ -910,7 +910,7 @@ static void libuv_add_signal_event(int signum, zend_async_event_t *event)
 	}
 
 	// Add event to the list (use pointer address as key)
-	zend_hash_index_add_ptr(events_list, (zend_ulong) event, event);
+	zend_hash_index_add_ptr(events_list, async_ptr_to_index(event), event);
 }
 
 /* }}} */
@@ -927,7 +927,7 @@ static void libuv_remove_signal_event(int signum, zend_async_event_t *event)
 		return;
 	}
 
-	zend_hash_index_del(events_list, (zend_ulong) event);
+	zend_hash_index_del(events_list, async_ptr_to_index(event));
 
 	// If no more events for this signal, remove the handler (but check for process events if SIGCHLD)
 	if (zend_hash_num_elements(events_list) == 0) {
@@ -989,7 +989,7 @@ static void libuv_handle_process_events(void)
 
 		// Verify event is still in the HashTable (might have been removed)
 		if (ASYNC_G(process_events) == NULL ||
-			zend_hash_index_find_ptr(ASYNC_G(process_events), (zend_ulong) event) == NULL) {
+			zend_hash_index_find_ptr(ASYNC_G(process_events), async_ptr_to_index(event)) == NULL) {
 			continue;
 		}
 
@@ -1057,7 +1057,7 @@ static void libuv_add_process_event(zend_async_event_t *event)
 	}
 
 	// Add event to the process events list (use pointer address as key)
-	zend_hash_index_add_ptr(ASYNC_G(process_events), (zend_ulong) event, event);
+	zend_hash_index_add_ptr(ASYNC_G(process_events), async_ptr_to_index(event), event);
 }
 
 /* }}} */
@@ -1069,7 +1069,7 @@ static void libuv_remove_process_event(zend_async_event_t *event)
 		return;
 	}
 
-	zend_hash_index_del(ASYNC_G(process_events), (zend_ulong) event);
+	zend_hash_index_del(ASYNC_G(process_events), async_ptr_to_index(event));
 
 	// Only remove SIGCHLD handler if no more process events AND no regular signal events for SIGCHLD
 	if (zend_hash_num_elements(ASYNC_G(process_events)) == 0) {

scheduler.c

@@ -687,11 +687,10 @@ static void async_scheduler_dtor(void)
 	zval_c_buffer_cleanup(&ASYNC_G(resumed_coroutines));
 	zval_c_buffer_cleanup(&ASYNC_G(microtasks));
 
-	zval *current;
+	async_coroutine_t *coroutine;
 	// foreach by fibers_state and release all fibers
-	ZEND_HASH_FOREACH_VAL(&ASYNC_G(coroutines), current)
+	ZEND_HASH_FOREACH_PTR(&ASYNC_G(coroutines), coroutine)
 	{
-		async_coroutine_t *coroutine = Z_PTR_P(current);
 		OBJ_RELEASE(&coroutine->std);
 	}
 	ZEND_HASH_FOREACH_END();
@@ -714,10 +713,9 @@ static zend_always_inline void start_waker_events(zend_async_waker_t *waker)
 {
 	ZEND_ASSERT(waker != NULL && "Waker is NULL in async_scheduler_start_waker_events");
 
-	zval *current;
-	ZEND_HASH_FOREACH_VAL(&waker->events, current)
+	zend_async_waker_trigger_t *trigger;
+	ZEND_HASH_FOREACH_PTR(&waker->events, trigger)
 	{
-		const zend_async_waker_trigger_t *trigger = Z_PTR_P(current);
 		trigger->event->start(trigger->event);
 	}
 	ZEND_HASH_FOREACH_END();
@@ -727,10 +725,9 @@ static zend_always_inline void stop_waker_events(zend_async_waker_t *waker)
 {
 	ZEND_ASSERT(waker != NULL && "Waker is NULL in async_scheduler_stop_waker_events");
 
-	zval *current;
-	ZEND_HASH_FOREACH_VAL(&waker->events, current)
+	zend_async_waker_trigger_t *trigger;
+	ZEND_HASH_FOREACH_PTR(&waker->events, trigger)
 	{
-		const zend_async_waker_trigger_t *trigger = Z_PTR_P(current);
 		trigger->event->stop(trigger->event);
 	}
 	ZEND_HASH_FOREACH_END();

zend_common.h

@@ -267,4 +267,19 @@ void zend_copy_fci(zend_fcall_info *dest_fci,
 				   zend_fcall_info *src_fci,
 				   zend_fcall_info_cache *src_fcc);
 
+/**
+ * Optimized pointer to hash index conversion.
+ *
+ * Uses right rotation by 3 bits to improve hash distribution for pointer addresses,
+ * reducing collisions caused by zero lower bits from memory alignment.
+ *
+ * @param ptr  Pointer to convert to hash index
+ * @return     Optimized hash index value
+ */
+static zend_always_inline zend_ulong async_ptr_to_index(void *ptr)
+{
+	zend_ulong key = (zend_ulong) ptr;
+	return (key >> 3) | (key << ((sizeof(key) * 8) - 3));
+}
+
 #endif // ASYNC_ZEND_COMMON_H