PHP array_shift(): Optimize tail move on hole-free packed arrays

When a packed array has no holes and no active iterators, the slot
vacated by the shifted element is the only hole, so the tail can be
moved down with a single memmove instead of testing every slot for
IS_UNDEF and comparing source and destination indexes. A tail of a
single element is moved directly instead, avoiding the memmove call
overhead on tiny arrays.

Author: mehmetcansahin

NEWS

@@ -54,6 +54,8 @@ PHP                                                                        NEWS
   . Fixed read buffer compaction in php_stream_filter_flush(). (crystarm)
   . Io\Poll\Context::wait() now rejects a $maxEvents value greater than
     INT_MAX instead of truncating it. (marc-mabe)
+  . Improved performance of array_shift() on packed arrays without holes.
+    (mehmetcansahin)
 
 - SimpleXML:
   . Fixed writing to a dimension of the object returned by attributes() not

UPGRADING

@@ -977,6 +977,7 @@ PHP 8.6 UPGRADE NOTES
   . Improved performance of array_fill_keys().
   . Improved performance of array_intersect().
   . Improved performance of array_map() with multiple arrays passed.
+  . Improved performance of array_shift() on packed arrays without holes.
   . Improved performance of array_sum() and array_product() for
     integer-only arrays.
   . Improved performance of array_unshift().

ext/standard/array.c

@@ -3576,6 +3576,8 @@ PHP_FUNCTION(array_shift)
 	/* re-index like it did before */
 	if (HT_IS_PACKED(Z_ARRVAL_P(stack))) {
 		uint32_t k = 0;
+		/* Must be read before the deletion below opens a hole. */
+		bool without_holes = HT_IS_WITHOUT_HOLES(Z_ARRVAL_P(stack));
 
 		/* Get the first value and copy it into the return value */
 		idx = 0;
@@ -3596,15 +3598,32 @@ PHP_FUNCTION(array_shift)
 		zend_hash_packed_del_val(Z_ARRVAL_P(stack), val);
 
 		if (EXPECTED(!HT_HAS_ITERATORS(Z_ARRVAL_P(stack)))) {
-			for (idx = 0; idx < Z_ARRVAL_P(stack)->nNumUsed; idx++) {
-				val = Z_ARRVAL_P(stack)->arPacked + idx;
-				if (Z_TYPE_P(val) == IS_UNDEF) continue;
-				if (idx != k) {
-					zval *q = Z_ARRVAL_P(stack)->arPacked + k;
-					ZVAL_COPY_VALUE(q, val);
-					ZVAL_UNDEF(val);
+			if (without_holes) {
+				/* The slot just vacated is the only hole, so the rest moves down by one
+				 * without having to test every slot. */
+				HashTable *ht = Z_ARRVAL_P(stack);
+
+				if (ht->nNumUsed > 0) {
+					k = ht->nNumUsed - 1;
+					if (k == 1) {
+						/* Avoid the memmove() call overhead for the common tiny-array case. */
+						ZVAL_COPY_VALUE(ht->arPacked, ht->arPacked + 1);
+					} else {
+						memmove(ht->arPacked, ht->arPacked + 1, sizeof(zval) * k);
+					}
+					ZVAL_UNDEF(ht->arPacked + k);
+				}
+			} else {
+				for (idx = 0; idx < Z_ARRVAL_P(stack)->nNumUsed; idx++) {
+					val = Z_ARRVAL_P(stack)->arPacked + idx;
+					if (Z_TYPE_P(val) == IS_UNDEF) continue;
+					if (idx != k) {
+						zval *q = Z_ARRVAL_P(stack)->arPacked + k;
+						ZVAL_COPY_VALUE(q, val);
+						ZVAL_UNDEF(val);
+					}
+					k++;
 				}
-				k++;
 			}
 		} else {
 			uint32_t iter_pos = zend_hash_iterators_lower_pos(Z_ARRVAL_P(stack), 0);

ext/standard/tests/array/array_shift_packed_holes.phpt

@@ -0,0 +1,31 @@
+--TEST--
+array_shift() on packed arrays with holes created by unset()
+--FILE--
+<?php
+// Holes at the head and in the middle: the compaction loop must skip them.
+$a = [1, 2, 3, 4, 5];
+unset($a[0], $a[2]);
+var_dump(array_shift($a), $a);
+
+// Shift a holed array down to empty: the next appended key must be 0.
+$a = [10, 20];
+unset($a[0]);
+var_dump(array_shift($a), $a);
+$a[] = 30;
+var_dump($a);
+?>
+--EXPECT--
+int(2)
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+int(20)
+array(0) {
+}
+array(1) {
+  [0]=>
+  int(30)
+}