Implement a demo

Author: LamentXU123

UPGRADING

@@ -983,8 +983,9 @@ PHP 8.6 UPGRADE NOTES
   . Improved performance of array_walk().
   . Improved performance of intval('+0b...', 2) and intval('0b...', 2).
   . Improved performance of str_split().
-  . Improved performance and reduced memory usage of sort() and rsort()
-    when using SORT_REGULAR on packed arrays containing only integers.
+  . sort() and rsort() now sort packed arrays containing at least 64 elements
+    in place, avoiding conversion to mixed storage. Numeric indices remain
+    accessible to callbacks invoked during comparison.
 
 - URI:
   . Improved performance of Uri\WhatWg\Url::parse() when collecting

UPGRADING.INTERNALS

@@ -193,6 +193,12 @@ PHP 8.6 INTERNALS UPGRADE NOTES
     receives pointers to zval elements rather than Bucket entries and must
     not execute user code or modify the array. Callers requiring stable sorting
     must initialize any tie-breaking metadata and compare it themselves.
+  . Added zend_array_sort_packed() to sort and renumber packed user arrays
+    without converting them to mixed storage. The array must have a reference
+    count of 1. Holes are compacted, and the array is kept alive while the
+    comparator runs, including calls to user code. The comparator receives
+    zval pointers and must use the original positions initialized in
+    Z_EXTRA_P() to break ties stably.
   . Added zend_ast_call_get_args() to fetch the argument node from any call
     node.
   . Added Z_PARAM_ENUM().

Zend/zend_hash.c

@@ -2997,17 +2997,56 @@ static void zend_hash_packed_zval_swap(void *a, void *b)
 	*(zval *) b = tmp;
 }
 
-ZEND_API void ZEND_FASTCALL zend_hash_sort_packed(HashTable *ht, compare_func_t compar)
+static void zend_hash_sort_packed_internal(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_sort(ht->arPacked, ht->nNumUsed, sizeof(zval), compar, zend_hash_packed_zval_swap);
 	ht->nInternalPointer = 0;
 	ht->nNextFreeElement = ht->nNumUsed;
 }
 
+ZEND_API void ZEND_FASTCALL zend_hash_sort_packed(HashTable *ht, compare_func_t compar)
+{
+	HT_ASSERT_RC1(ht);
+	zend_hash_sort_packed_internal(ht, compar);
+}
+
+ZEND_API void ZEND_FASTCALL zend_array_sort_packed(HashTable *ht, compare_func_t compar)
+{
+	HT_ASSERT_RC1(ht);
+	ZEND_ASSERT(HT_IS_PACKED(ht));
+
+	if (ht->nNumOfElements == 0) {
+		return;
+	}
+
+	/* Compact holes and record the original order for stable comparisons. */
+	uint32_t count = 0;
+	for (uint32_t i = 0; i < ht->nNumUsed; i++) {
+		zval *value = &ht->arPacked[i];
+		if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
+			continue;
+		}
+		if (count != i) {
+			ht->arPacked[count] = *value;
+		}
+		Z_EXTRA(ht->arPacked[count]) = count;
+		count++;
+	}
+	ht->nNumUsed = count;
+
+	/* Keep the buffer alive and force PHP writes during comparison to separate. */
+	GC_ADDREF(ht);
+	zend_hash_sort_packed_internal(ht, compar);
+	if (UNEXPECTED(GC_DELREF(ht) == 0)) {
+		zend_array_destroy(ht);
+	} else {
+		gc_check_possible_root((zend_refcounted *) ht);
+	}
+}
+
 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

@@ -309,6 +309,11 @@ ZEND_API void  ZEND_FASTCALL zend_array_sort_ex(HashTable *ht, sort_func_t sort_
  * stable sorting must initialize any tie-breaking metadata and compare it. */
 ZEND_API void ZEND_FASTCALL zend_hash_sort_packed(HashTable *ht, compare_func_t compare_func);
 
+/* Sort and renumber a packed user array, compacting holes and keeping it alive
+ * across calls to user code. The comparator receives zvals and must use the
+ * original positions initialized in Z_EXTRA_P() to break ties stably. */
+ZEND_API void ZEND_FASTCALL zend_array_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

@@ -282,17 +282,17 @@ static zend_always_inline int php_array_key_compare_string_locale_unstable_i(Buc
 }
 /* }}} */
 
-static zend_always_inline int php_array_data_compare_unstable_i(Bucket *f, Bucket *s) /* {{{ */
+static zend_always_inline int php_array_data_compare_zval_unstable_i(zval *f, zval *s) /* {{{ */
 {
-	int result = zend_compare(&f->val, &s->val);
+	int result = zend_compare(f, s);
 	/* Special enums handling for array_unique. We don't want to add this logic to zend_compare as
 	 * that would be observable via comparison operators. */
-	zval *rhs = &s->val;
+	zval *rhs = s;
 	ZVAL_DEREF(rhs);
 	if (UNEXPECTED(Z_TYPE_P(rhs) == IS_OBJECT)
 	 && result == ZEND_UNCOMPARABLE
 	 && (Z_OBJCE_P(rhs)->ce_flags & ZEND_ACC_ENUM)) {
-		zval *lhs = &f->val;
+		zval *lhs = f;
 		ZVAL_DEREF(lhs);
 		if (Z_TYPE_P(lhs) == IS_OBJECT && (Z_OBJCE_P(lhs)->ce_flags & ZEND_ACC_ENUM)) {
 			// Order doesn't matter, we just need to group the same enum values
@@ -308,29 +308,29 @@ static zend_always_inline int php_array_data_compare_unstable_i(Bucket *f, Bucke
 }
 /* }}} */
 
-static zend_always_inline int php_array_data_compare_numeric_unstable_i(Bucket *f, Bucket *s) /* {{{ */
+static zend_always_inline int php_array_data_compare_numeric_zval_unstable_i(zval *f, zval *s) /* {{{ */
 {
-	return numeric_compare_function(&f->val, &s->val);
+	return numeric_compare_function(f, s);
 }
 /* }}} */
 
-static zend_always_inline int php_array_data_compare_string_case_unstable_i(Bucket *f, Bucket *s) /* {{{ */
+static zend_always_inline int php_array_data_compare_string_case_zval_unstable_i(zval *f, zval *s) /* {{{ */
 {
-	return string_case_compare_function(&f->val, &s->val);
+	return string_case_compare_function(f, s);
 }
 /* }}} */
 
-static zend_always_inline int php_array_data_compare_string_unstable_i(Bucket *f, Bucket *s) /* {{{ */
+static zend_always_inline int php_array_data_compare_string_zval_unstable_i(zval *f, zval *s) /* {{{ */
 {
-	return string_compare_function(&f->val, &s->val);
+	return string_compare_function(f, s);
 }
 /* }}} */
 
-static int php_array_natural_general_compare(Bucket *f, Bucket *s, bool fold_case) /* {{{ */
+static int php_array_natural_general_compare(zval *f, zval *s, bool fold_case) /* {{{ */
 {
 	zend_string *tmp_str1, *tmp_str2;
-	zend_string *str1 = zval_get_tmp_string(&f->val, &tmp_str1);
-	zend_string *str2 = zval_get_tmp_string(&s->val, &tmp_str2);
+	zend_string *str1 = zval_get_tmp_string(f, &tmp_str1);
+	zend_string *str2 = zval_get_tmp_string(s, &tmp_str2);
 
 	int result = strnatcmp_ex(ZSTR_VAL(str1), ZSTR_LEN(str1), ZSTR_VAL(str2), ZSTR_LEN(str2), fold_case);
 
@@ -340,36 +340,62 @@ static int php_array_natural_general_compare(Bucket *f, Bucket *s, bool fold_cas
 }
 /* }}} */
 
-static zend_always_inline int php_array_natural_compare_unstable_i(Bucket *a, Bucket *b) /* {{{ */
+static zend_always_inline int php_array_natural_compare_zval_unstable_i(zval *a, zval *b) /* {{{ */
 {
 	return php_array_natural_general_compare(a, b, false);
 }
 /* }}} */
 
-static zend_always_inline int php_array_natural_case_compare_unstable_i(Bucket *a, Bucket *b) /* {{{ */
+static zend_always_inline int php_array_natural_case_compare_zval_unstable_i(zval *a, zval *b) /* {{{ */
 {
 	return php_array_natural_general_compare(a, b, true);
 }
 /* }}} */
 
-static int php_array_data_compare_string_locale_unstable_i(Bucket *f, Bucket *s) /* {{{ */
+static int php_array_data_compare_string_locale_zval_unstable_i(zval *f, zval *s) /* {{{ */
 {
-	return string_locale_compare_function(&f->val, &s->val);
+	return string_locale_compare_function(f, s);
 }
 /* }}} */
 
+static zend_never_inline ZEND_COLD int stable_zval_sort_fallback(const zval *a, const zval *b)
+{
+	return ZEND_THREEWAY_COMPARE(Z_EXTRA_P(a), Z_EXTRA_P(b));
+}
+
+/* Share value comparisons between Bucket sorting and packed zval sorting. */
+#define DEFINE_DATA_SORT_VARIANTS(name) \
+	static zend_always_inline int php_array_##name##_unstable_i(Bucket *a, Bucket *b) { \
+		return php_array_##name##_zval_unstable_i(&a->val, &b->val); \
+	} \
+	DEFINE_SORT_VARIANTS(name) \
+	static zend_never_inline int php_array_packed_##name(const void *a, const void *b) { \
+		int result = php_array_##name##_zval_unstable_i((zval *) a, (zval *) b); \
+		if (EXPECTED(result)) { \
+			return result; \
+		} \
+		return stable_zval_sort_fallback(a, b); \
+	} \
+	static zend_never_inline int php_array_packed_reverse_##name(const void *a, const void *b) { \
+		int result = php_array_##name##_zval_unstable_i((zval *) a, (zval *) b) * -1; \
+		if (EXPECTED(result)) { \
+			return result; \
+		} \
+		return stable_zval_sort_fallback(a, b); \
+	}
+
 DEFINE_SORT_VARIANTS(key_compare);
 DEFINE_SORT_VARIANTS(key_compare_numeric);
 DEFINE_SORT_VARIANTS(key_compare_string_case);
 DEFINE_SORT_VARIANTS(key_compare_string);
 DEFINE_SORT_VARIANTS(key_compare_string_locale);
-DEFINE_SORT_VARIANTS(data_compare);
-DEFINE_SORT_VARIANTS(data_compare_numeric);
-DEFINE_SORT_VARIANTS(data_compare_string_case);
-DEFINE_SORT_VARIANTS(data_compare_string);
-DEFINE_SORT_VARIANTS(data_compare_string_locale);
-DEFINE_SORT_VARIANTS(natural_compare);
-DEFINE_SORT_VARIANTS(natural_case_compare);
+DEFINE_DATA_SORT_VARIANTS(data_compare);
+DEFINE_DATA_SORT_VARIANTS(data_compare_numeric);
+DEFINE_DATA_SORT_VARIANTS(data_compare_string_case);
+DEFINE_DATA_SORT_VARIANTS(data_compare_string);
+DEFINE_DATA_SORT_VARIANTS(data_compare_string_locale);
+DEFINE_DATA_SORT_VARIANTS(natural_compare);
+DEFINE_DATA_SORT_VARIANTS(natural_case_compare);
 
 static bucket_compare_func_t php_get_key_compare_func(zend_long sort_type)
 {
@@ -491,6 +517,39 @@ static bucket_compare_func_t php_get_data_reverse_compare_func(zend_long sort_ty
 	return NULL;
 }
 
+static zend_always_inline compare_func_t php_get_packed_data_compare_func_ex(zend_long sort_type, bool reverse)
+{
+	switch (sort_type & ~PHP_SORT_FLAG_CASE) {
+		case PHP_SORT_NUMERIC:
+			return reverse ? php_array_packed_reverse_data_compare_numeric : php_array_packed_data_compare_numeric;
+		case PHP_SORT_STRING:
+			if (sort_type & PHP_SORT_FLAG_CASE) {
+				return reverse ? php_array_packed_reverse_data_compare_string_case : php_array_packed_data_compare_string_case;
+			}
+			return reverse ? php_array_packed_reverse_data_compare_string : php_array_packed_data_compare_string;
+		case PHP_SORT_NATURAL:
+			if (sort_type & PHP_SORT_FLAG_CASE) {
+				return reverse ? php_array_packed_reverse_natural_case_compare : php_array_packed_natural_case_compare;
+			}
+			return reverse ? php_array_packed_reverse_natural_compare : php_array_packed_natural_compare;
+		case PHP_SORT_LOCALE_STRING:
+			return reverse ? php_array_packed_reverse_data_compare_string_locale : php_array_packed_data_compare_string_locale;
+		case PHP_SORT_REGULAR:
+		default:
+			return reverse ? php_array_packed_reverse_data_compare : php_array_packed_data_compare;
+	}
+}
+
+static compare_func_t php_get_packed_data_compare_func(zend_long sort_type)
+{
+	return php_get_packed_data_compare_func_ex(sort_type, false);
+}
+
+static compare_func_t php_get_packed_data_reverse_compare_func(zend_long sort_type)
+{
+	return php_get_packed_data_compare_func_ex(sort_type, true);
+}
+
 static bucket_compare_func_t php_get_data_compare_func_unstable(zend_long sort_type, bool reverse) /* {{{ */
 {
 	switch (sort_type & ~PHP_SORT_FLAG_CASE) {
@@ -694,6 +753,7 @@ PHP_FUNCTION(natcasesort)
 /* }}} */
 
 typedef bucket_compare_func_t(*get_compare_function)(zend_long);
+typedef compare_func_t (*get_packed_compare_function)(zend_long);
 
 static int php_array_packed_long_compare(const void *a, const void *b)
 {
@@ -726,7 +786,7 @@ static bool php_array_try_packed_long_sort(HashTable *array, compare_func_t cmp)
 }
 
 static zend_always_inline void php_sort(INTERNAL_FUNCTION_PARAMETERS,
-		get_compare_function get_cmp, bool renumber, compare_func_t packed_cmp) {
+		get_compare_function get_cmp, bool renumber, get_packed_compare_function get_packed_cmp) {
 	HashTable *array;
 	zend_long sort_type = PHP_SORT_REGULAR;
 	bucket_compare_func_t cmp;
@@ -737,15 +797,22 @@ static zend_always_inline void php_sort(INTERNAL_FUNCTION_PARAMETERS,
 		Z_PARAM_LONG(sort_type)
 	ZEND_PARSE_PARAMETERS_END();
 
-	cmp = get_cmp(sort_type);
-
-	/* Keep arrays that do not need sorting on the existing path. */
-	if (renumber && packed_cmp && array->nNumOfElements > 1
-	 && (cmp == php_array_data_compare || cmp == php_array_reverse_data_compare)
-	 && php_array_try_packed_long_sort(array, packed_cmp)) {
+	/* Keep small arrays on the existing path. */
+	if (renumber && get_packed_cmp && array->nNumOfElements >= 64 && HT_IS_PACKED(array)) {
+		compare_func_t packed_cmp = get_packed_cmp(sort_type);
+		compare_func_t long_cmp = NULL;
+		if (packed_cmp == php_array_packed_data_compare) {
+			long_cmp = php_array_packed_long_compare;
+		} else if (packed_cmp == php_array_packed_reverse_data_compare) {
+			long_cmp = php_array_packed_long_reverse_compare;
+		}
+		if (!long_cmp || !php_array_try_packed_long_sort(array, long_cmp)) {
+			zend_array_sort_packed(array, packed_cmp);
+		}
 		RETURN_TRUE;
 	}
 
+	cmp = get_cmp(sort_type);
 	zend_array_sort(array, cmp, renumber);
 
 	RETURN_TRUE;
@@ -769,15 +836,15 @@ PHP_FUNCTION(arsort)
 PHP_FUNCTION(sort)
 {
 	php_sort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_get_data_compare_func, true,
-		php_array_packed_long_compare);
+		php_get_packed_data_compare_func);
 }
 /* }}} */
 
 /* {{{ Sort an array in reverse order */
 PHP_FUNCTION(rsort)
 {
 	php_sort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_get_data_reverse_compare_func, true,
-		php_array_packed_long_reverse_compare);
+		php_get_packed_data_reverse_compare_func);
 }
 /* }}} */
 

ext/standard/tests/array/sort/packed_integer_sort.phpt

@@ -1,5 +1,5 @@
 --TEST--
-Packed integer sort and rsort at the insertion sort boundary
+Packed integer sort and rsort at the insertion sort and fast path boundaries
 --FILE--
 <?php
 function check($actual, $expected) {
@@ -8,7 +8,7 @@ function check($actual, $expected) {
     }
 }
 
-foreach ([2, 16, 17] as $size) {
+foreach ([2, 16, 17, 63, 64, 65] as $size) {
     $ascending = range(1, $size);
     $descending = array_reverse($ascending);
     $permuted = array_merge(array_slice($ascending, 1), [1]);
@@ -56,4 +56,7 @@ echo "other comparators: OK\n";
 size 2: OK
 size 16: OK
 size 17: OK
+size 63: OK
+size 64: OK
+size 65: OK
 other comparators: OK

ext/standard/tests/array/sort/packed_integer_sort_fallback.phpt

@@ -10,11 +10,12 @@ function check($actual, $expected) {
 
 foreach (['sort', 'rsort'] as $sort) {
     $left = $right = 1;
-    $values = [&$left, 2, &$right];
+    $zeros = array_fill(0, 61, 0);
+    $values = [...$zeros, &$left, 2, &$right];
     $sort($values);
     $left = 11;
     $right = 12;
-    check($values, $sort === 'sort' ? [11, 12, 2] : [2, 11, 12]);
+    check($values, $sort === 'sort' ? [...$zeros, 11, 12, 2] : [2, 11, 12, ...$zeros]);
 
     $values = [1.0, 1, 0.5];
     $sort($values);
@@ -24,10 +25,10 @@ foreach (['sort', 'rsort'] as $sort) {
     $sort($values);
     check($values, $sort === 'sort' ? ['1', '01', '2', '02'] : ['2', '02', '1', '01']);
 
-    $values = range(16, 1);
+    $values = range(64, 1);
     $values[] = 0.5;
     $sort($values);
-    check($values, $sort === 'sort' ? [0.5, ...range(1, 16)] : [...range(16, 1), 0.5]);
+    check($values, $sort === 'sort' ? [0.5, ...range(1, 64)] : [...range(64, 1), 0.5]);
 
     $values = [3, 9, 1, 2];
     unset($values[1]);