Optimize sort() and rsort() for packed integer arrays

Author: LamentXU123

Zend/zend_hash.c

@@ -2990,6 +2990,29 @@ ZEND_API void zend_hash_bucket_packed_swap(Bucket *p, Bucket *q)
 	q->h = h;
 }
 
+static void zend_hash_packed_zval_swap(void *a, void *b)
+{
+	zval tmp = *(zval *) a;
+	*(zval *) a = *(zval *) b;
+	*(zval *) b = tmp;
+}
+
+ZEND_API void ZEND_FASTCALL zend_hash_sort_packed(HashTable *ht, compare_func_t compar)
+{
+	IS_CONSISTENT(ht);
+	HT_ASSERT_RC1(ht);
+	ZEND_ASSERT(HT_IS_PACKED(ht) && HT_IS_WITHOUT_HOLES(ht));
+	ZEND_ASSERT(!HT_HAS_ITERATORS(ht));
+
+	/* Preserve original order for stable comparisons. Swaps must include u2. */
+	for (uint32_t i = 0; i < ht->nNumUsed; i++) {
+		Z_EXTRA(ht->arPacked[i]) = i;
+	}
+	zend_sort(ht->arPacked, ht->nNumUsed, sizeof(zval), compar, zend_hash_packed_zval_swap);
+	ht->nInternalPointer = 0;
+	ht->nNextFreeElement = ht->nNumUsed;
+}
+
 static void zend_hash_sort_internal(HashTable *ht, sort_func_t sort, bucket_compare_func_t compar, bool renumber)
 {
 	Bucket *p;

Zend/zend_hash.h

@@ -304,6 +304,10 @@ ZEND_API int   zend_hash_compare(HashTable *ht1, const HashTable *ht2, compare_f
 ZEND_API void  ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort_func, bucket_compare_func_t compare_func, bool renumber);
 ZEND_API void  ZEND_FASTCALL zend_array_sort_ex(HashTable *ht, sort_func_t sort_func, bucket_compare_func_t compare_func, bool renumber);
 
+/* Sort and renumber a packed array without holes. The comparator must not
+ * execute user code or modify the array. */
+ZEND_API void ZEND_FASTCALL zend_hash_sort_packed(HashTable *ht, compare_func_t compare_func);
+
 static zend_always_inline void ZEND_FASTCALL zend_hash_sort(HashTable *ht, bucket_compare_func_t compare_func, bool renumber) {
 	zend_hash_sort_ex(ht, zend_sort, compare_func, renumber);
 }

ext/standard/array.c

@@ -695,6 +695,43 @@ PHP_FUNCTION(natcasesort)
 
 typedef bucket_compare_func_t(*get_compare_function)(zend_long);
 
+static int php_array_packed_long_compare(const void *a, const void *b)
+{
+	const zval *lhs = a, *rhs = b;
+	if (Z_LVAL_P(lhs) != Z_LVAL_P(rhs)) {
+		return Z_LVAL_P(lhs) > Z_LVAL_P(rhs) ? 1 : -1;
+	}
+	return (Z_EXTRA_P(lhs) > Z_EXTRA_P(rhs)) - (Z_EXTRA_P(lhs) < Z_EXTRA_P(rhs));
+}
+
+static int php_array_packed_long_reverse_compare(const void *a, const void *b)
+{
+	const zval *lhs = a, *rhs = b;
+	if (Z_LVAL_P(lhs) != Z_LVAL_P(rhs)) {
+		return Z_LVAL_P(lhs) < Z_LVAL_P(rhs) ? 1 : -1;
+	}
+	return (Z_EXTRA_P(lhs) > Z_EXTRA_P(rhs)) - (Z_EXTRA_P(lhs) < Z_EXTRA_P(rhs));
+}
+
+static bool php_array_try_packed_long_sort(HashTable *array, compare_func_t cmp)
+{
+	if (!HT_IS_PACKED(array)
+	 || !HT_IS_WITHOUT_HOLES(array) || HT_HAS_ITERATORS(array)) {
+		return false;
+	}
+
+	/* Reject references and other types before changing any element. Integer
+	 * comparisons cannot invoke user code, so the array stays exclusively owned. */
+	for (uint32_t i = 0; i < array->nNumUsed; i++) {
+		if (Z_TYPE(array->arPacked[i]) != IS_LONG) {
+			return false;
+		}
+	}
+
+	zend_hash_sort_packed(array, cmp);
+	return true;
+}
+
 static zend_always_inline void php_sort(INTERNAL_FUNCTION_PARAMETERS, get_compare_function get_cmp, bool renumber) {
 	HashTable *array;
 	zend_long sort_type = PHP_SORT_REGULAR;
@@ -708,6 +745,14 @@ static zend_always_inline void php_sort(INTERNAL_FUNCTION_PARAMETERS, get_compar
 
 	cmp = get_cmp(sort_type);
 
+	/* Keep small sorts out of the speculative type scan and helper call. */
+	if (renumber && sort_type == PHP_SORT_REGULAR && array->nNumOfElements >= 64
+	 && php_array_try_packed_long_sort(array,
+		get_cmp == php_get_data_compare_func
+			? php_array_packed_long_compare : php_array_packed_long_reverse_compare)) {
+		RETURN_TRUE;
+	}
+
 	zend_array_sort(array, cmp, renumber);
 
 	RETURN_TRUE;