Benchmark for JUnitTestCaseSorter::uniqueByTestFile

devTools/phpstan-src.neon

@@ -32,10 +32,6 @@ parameters:
             path: '../src/Container.php'
             message: '#^Parameter \#1 \$processHandler of class Infection\\Process\\Runner\\ParallelProcessRunner constructor expects Closure\(Infection\\Process\\Runner\\ProcessBearer\)\: void\, Closure\(Infection\\Process\\MutantProcess\): void given\.$#'
             count: 1
-        -
-            path: '../src/TestFramework/Coverage/JUnit/JUnitTestCaseSorter.php'
-            message: '#array_key_exists expects int\|string, string\|null given#'
-            count: 1
         -
             path: '../src/FileSystem/DummyFileSystem.php'
             message: '#Infection\\FileSystem\\DummyFileSystem#'

src/Process/Runner/MutationTestingRunner.php

@@ -90,6 +90,7 @@ public function run(iterable $mutations, string $testFrameworkExtraOptions): voi
                 return $this->mutantFactory->create($mutation);
             })
             ->filter(function (Mutant $mutant) {
+                // It's a proxy call to Mutation, can be done one stage up
                 if ($mutant->isCoveredByTest()) {
                     return true;
                 }

src/TestFramework/Coverage/JUnit/JUnitTestCaseSorter.php

@@ -36,53 +36,134 @@
 namespace Infection\TestFramework\Coverage\JUnit;
 
 use function array_key_exists;
+use function count;
 use function current;
 use Infection\AbstractTestFramework\Coverage\TestLocation;
+use function Safe\ksort;
 use function Safe\usort;
 
 /**
  * @internal
  */
 final class JUnitTestCaseSorter
 {
+    /**
+     * Expected average number of buckets. Exposed for testing purposes.
+     *
+     * @var int[]
+     */
+    public const BUCKETS_COUNT = 25;
+
+    /**
+     * For 25 buckets QS becomes theoretically less efficient on average at and after 15 elements.
+     * Exposed for testing purposes.
+     */
+    public const USE_BUCKET_SORT_AFTER = 15;
+
     /**
      * @param TestLocation[] $tests
      *
-     * @return string[]
+     * @return iterable<string>
      */
     public function getUniqueSortedFileNames(array $tests): iterable
     {
         $uniqueTestLocations = $this->uniqueByTestFile($tests);
 
-        if (count($uniqueTestLocations) === 1) {
+        $numberOfTestLocation = count($uniqueTestLocations);
+
+        if ($numberOfTestLocation === 1) {
             // Around 5% speed up compared to when without this optimization.
             /** @var TestLocation $testLocation */
             $testLocation = current($uniqueTestLocations);
 
+            /** @var string $filePath */
             $filePath = $testLocation->getFilePath();
 
-            if ($filePath !== null) {
-                yield $filePath;
-            }
-
-            return;
+            return [$filePath];
         }
 
         /*
+         * We need to sort tests to run the fastest first.
+         *
          * Two tests per file are also very frequent. Yet it doesn't make sense
          * to sort them by hand: usort does that just as good.
          */
 
-        // sort tests to run the fastest first
-        usort(
-            $uniqueTestLocations,
-            static function (TestLocation $a, TestLocation $b) {
-                return $a->getExecutionTime() <=> $b->getExecutionTime();
-            }
+        if ($numberOfTestLocation < self::USE_BUCKET_SORT_AFTER) {
+            usort(
+                $uniqueTestLocations,
+                static function (TestLocation $a, TestLocation $b) {
+                    return $a->getExecutionTime() <=> $b->getExecutionTime();
+                }
+            );
+
+            return self::sortedLocationsGenerator($uniqueTestLocations);
+        }
+
+        /*
+         * For large number of tests use a more efficient algorithm.
+         */
+        return self::sortedLocationsGenerator(
+            self::bucketSort($uniqueTestLocations)
         );
+    }
+
+    /**
+     * Sorts tests to run the fastest first. Exposed for benchmarking purposes.
+     *
+     * @param TestLocation[] $uniqueTestLocations
+     *
+     * @return iterable<TestLocation>
+     */
+    public static function bucketSort(array $uniqueTestLocations): iterable
+    {
+        // Pre-sort first buckets, optimistically assuming that
+        // most projects won't have tests longer than a second
+        $buckets = [
+            0 => [],
+            1 => [],
+            2 => [],
+            3 => [],
+            4 => [],
+            5 => [],
+            6 => [],
+            7 => [],
+        ];
+
+        foreach ($uniqueTestLocations as $location) {
+            // Quick drop off lower bits, reducing precision to 8th of a second
+            $msTime = $location->getExecutionTime() * 1024 >> 7; // * 1024 / 128
+
+            // For anything above 4 seconds reduce precision to 4 seconds
+            if ($msTime > 32) {
+                $msTime = $msTime >> 5 << 5; // 7 + 5 = 12 bits
+            }
+
+            $buckets[$msTime][] = $location;
+        }
+
+        ksort($buckets);
+
+        foreach ($buckets as $bucket) {
+            foreach ($bucket as $value) {
+                // not `yield from` here because it'll break order in PHP 7.3
+                yield $value;
+            }
+        }
+    }
+
+    /**
+     * @param iterable<TestLocation> $sortedTestLocations
+     *
+     * @return iterable<string>
+     */
+    private static function sortedLocationsGenerator(iterable $sortedTestLocations): iterable
+    {
+        foreach ($sortedTestLocations as $testLocation) {
+            /** @var string $filePath */
+            $filePath = $testLocation->getFilePath();
 
-        foreach ($uniqueTestLocations as $testLocation) {
-            yield $testLocation->getFilePath();
+            yield $filePath;
         }
     }
 
@@ -98,9 +179,11 @@ private function uniqueByTestFile(array $testLocations): array
         $uniqueTests = [];
 
         foreach ($testLocations as $testLocation) {
+            /** @var string $filePath */
             $filePath = $testLocation->getFilePath();
 
-            if (!array_key_exists($filePath, $usedFileNames)) {
+            // isset() is 20% faster than array_key_exists()
+            if (!isset($usedFileNames[$filePath])) {
                 $uniqueTests[] = $testLocation;
                 $usedFileNames[$filePath] = true;
             }