array_push(): Append to packed arrays in bulk

NEWS

@@ -98,6 +98,7 @@ PHP                                                                        NEWS
     elements. (mehmetcansahin)
   . Enforce max_filter_count: limit the number of filters that can be chained
     in a php://filter URL. (Sjoerd Langkemper)
+  . Improved performance of array_push() on packed arrays. (mehmetcansahin)
 
 - URI:
   . Fix casing of enum cases in UriHostType and UrlHostType to match the RFC

UPGRADING

@@ -96,6 +96,7 @@ PHP 8.7 UPGRADE NOTES
 - Standard:
   . Improved performance of strcspn() and strpbrk() when searching longer strings
     with a single-byte character mask.
+  . Improved performance of array_push() on packed arrays.
   . Improved performance of array_splice() when inserting without removing
     elements.
   . Improved performance of str_rot13().

ext/standard/array.c

@@ -3476,19 +3476,56 @@ PHP_FUNCTION(array_push)
 		Z_PARAM_VARIADIC('+', args, argc)
 	ZEND_PARSE_PARAMETERS_END();
 
+	HashTable *ht = Z_ARRVAL_P(stack);
+
+	/* Pushing nothing must not change the array, not even initialize it. A
+	 * single value is added to an uninitialized array more cheaply by
+	 * zend_hash_next_index_insert(), which initializes it inline. */
+	if (argc > 0 && (HT_IS_PACKED(ht) || (argc > 1 && (HT_FLAGS(ht) & HASH_FLAG_UNINITIALIZED)))) {
+		/* Like zend_hash_next_index_insert(), treat ZEND_LONG_MIN (no integer
+		 * key used yet) as 0. */
+		zend_long next_index = ht->nNextFreeElement == ZEND_LONG_MIN ? 0 : ht->nNextFreeElement;
+		bool appends_after_last = next_index == (zend_long) ht->nNumUsed;
+		uint32_t room = ht->nTableSize - ht->nNumUsed;
+
+		/* The values can be stored after the last used slot. Growing an array
+		 * with holes may turn it into a hash, so it must already have room. */
+		if (appends_after_last
+		 && argc <= HT_MAX_SIZE - ht->nNumUsed /* nNumUsed + argc must not wrap */
+		 && (argc <= room || HT_IS_WITHOUT_HOLES(ht))) {
+			if (UNEXPECTED(argc > room)) {
+				zend_hash_extend(ht, ht->nNumUsed + argc, true);
+			} else if (UNEXPECTED(HT_FLAGS(ht) & HASH_FLAG_UNINITIALIZED)) {
+				zend_hash_real_init_packed(ht);
+			}
+
+			/* ZEND_HASH_FILL_END() resets the internal pointer, array_push() keeps it. */
+			uint32_t pos = ht->nInternalPointer;
+			ZEND_HASH_FILL_PACKED(ht) {
+				for (uint32_t i = 0; i < argc; i++) {
+					Z_TRY_ADDREF(args[i]);
+					ZEND_HASH_FILL_ADD(&args[i]);
+				}
+			} ZEND_HASH_FILL_END();
+			ht->nInternalPointer = pos;
+
+			RETURN_LONG(zend_hash_num_elements(ht));
+		}
+	}
+
 	/* For each subsequent argument, make it a reference, increase refcount, and add it to the end of the array */
 	for (uint32_t i = 0; i < argc; i++) {
 		Z_TRY_ADDREF(args[i]);
 
-		if (zend_hash_next_index_insert(Z_ARRVAL_P(stack), &args[i]) == NULL) {
+		if (zend_hash_next_index_insert(ht, &args[i]) == NULL) {
 			Z_TRY_DELREF(args[i]);
 			zend_throw_error(NULL, "Cannot add element to the array as the next element is already occupied");
 			RETURN_THROWS();
 		}
 	}
 
 	/* Clean up and return the number of values in the stack */
-	RETVAL_LONG(zend_hash_num_elements(Z_ARRVAL_P(stack)));
+	RETVAL_LONG(zend_hash_num_elements(ht));
 }
 /* }}} */
 

ext/standard/tests/array/array_push_packed_bulk_metadata.phpt

@@ -0,0 +1,52 @@
+--TEST--
+array_push() keeps the internal pointer and the next index
+--FILE--
+<?php
+// The internal pointer does not move
+$a = [1, 2, 3];
+next($a);
+array_push($a, 4, 5);
+var_dump(key($a));
+
+// The next index left by a removed last element is used
+$a = [0, 1, 2];
+unset($a[2]);
+array_push($a, 3);
+var_dump(array_keys($a));
+
+// Pushing nothing keeps the next index of an empty array
+$a = [];
+array_push($a);
+$a[-5] = 1;
+$a[] = 2;
+var_dump(array_keys($a));
+
+// A negative next index of an empty copy is used
+$a = [-3 => 0];
+unset($a[-3]);
+$copy = $a;
+array_push($a, 1, 2);
+var_dump(array_keys($a));
+?>
+--EXPECT--
+int(1)
+array(3) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(3)
+}
+array(2) {
+  [0]=>
+  int(-5)
+  [1]=>
+  int(-4)
+}
+array(2) {
+  [0]=>
+  int(-2)
+  [1]=>
+  int(-1)
+}