ext/standard: Optimize sort(), rsort() and usort() for packed arrays

[LamentXU123]

TL;DR: This PR completely implements a sort internally, but using only zvals. sort(), rsort(), and usort() now avoid converting packed arrays to mixed storage while sorting.

After the last trivial one-element optimization I get to be familiar with how sort works in Zend. So, now, except the array is empty or only has one element, we convert arrays to mixed storage before sorting, and convert them back after we sort them.

The reason we are doing this is because the internal sorting functions is using Buckets, so we can preserve the keys when sorting the values. Packed arrays (most cases we are sorting them instead of unpacked and mixed arrays), are sequence zvals, and don't have customized keys.

This let me thinking. Can we just implement a sort internally which completely works with zvals and not Buckets? So we don't need to convert them to Bucket and convert them back again when sorting packed arrays that don't have external keys at all?

I have a idea to implement a sort works with packed arrays entirely depending on zvals. There it is. The benchmark results:

sort:

elements	int	float	string
2	−14.29%	−8.54%	−6.84%
10	−36.67%	−5.83%	−11.60%
64	−34.84%	−3.27%	-0.17%
65,535	−46.30%	−10.66%	−8.58%

rsort:

elements	int	float	string
2	-11.57%	-10.79%	-10.27%
10	-40.47%	-16.50%	-12.47%
64	-50.39%	-21.09%	-10.55%
65535	-59.65%	-30.82%	-15.47%

usort:

elements	int	float	string
2	-8.42%	-11.43%	-12.61%
10	-7.07%	-3.81%	-5.67%
64	-2.56%	-3.96%	-8.85%
65535	-5.74%	-4.72%	-8.82%

benchmark.php

 
mt_srand(717);

$rows = [];

for ($i = 0; $i < $batch; $i++) {

$row = [];

for ($j = 0; $j < $size; $j++) {

$value = mt_rand(-1000000, 1000000);

$row[] = match ($type) {

'ints' => $value,

'floats' => $value / 8.0,

'strings' => ($j % 2 ? 'A' : 'a') . $value,

};

}

$rows[] = $row;

}

unset($row); // Do not leave an additional reference to the last input array.

$start = hrtime(true);

foreach ($rows as &$row) {

sort($row, SORT_REGULAR);

}

unset($row);

$ms = (hrtime(true) - $start) / 1e6;
$hash = hash_init('sha256');

foreach ($rows as $row) {

if (!array_is_list($row) || count($row) !== $size) {

throw new RuntimeException('Incorrect result keys or size');

}

for ($j = 1; $j < $size; $j++) {

if (($row[$j - 1] <=> $row[$j]) > 0) {

throw new RuntimeException('Incorrect result order');

}

}

hash_update($hash, serialize($row));

}

echo json_encode([

'type' => $type, 'size' => $size, 'batch' => $batch,

'flags' => SORT_REGULAR, 'seed' => 717, 'ms' => $ms,

'checksum' => hash_final($hash),

]), "\n";

[staabm]

Nice to see faster sorting. In PHPStan profiles we see slow sorting in https://github.com/phpstan/phpstan-src/blob/2.3.x/src/Type/TypeCombinator.php in most profiles (which is not sorting on pure integers though)

[LamentXU123]

TBH, I don't think this is a completed PR. The idea is good, but we can't just implement this only for integers. Ideally, we can implement a sort completely supporting any zvals to be used by packed arrays.

I will be working on that idea in the coming days. So this is now drafted, sorry to ping you so early. I will request reviews when I think the implementaion is done.

Feel free to comment about the idea itself :)

Okay this is now completed.

[staabm]

would it make sense to add benchmark numbers for the case when sorting a array of objects?
(From a PHPStan maintainer point of view, thats the case we use most)

[LamentXU123]

I know how to add object in this optimization case but it seems like it's quite annoying cuz it will cause bugs and inevitably break things. Now, sorting object's performance should be unchanged (except in usort. If you are sorting objects in usort it should be faster.).