Fix the configuration calculation (#132)

- We previously we doing some calculation based on `$numberOfProcesses` and `$numberOfProcessesDefined`. In reality those calculation were not related directly to those values, but about the fact that child processes we spawned. Indeed when they are not, i.e. we do the processing in the main process, then the segment size and the number of segment becomes irrelevant. I think the logging should be updated to reflect this and better document when child processes are spawned, but this is out of scope of this PR. To address the direct issue though, we now pass directly `bool $shouldSpawnChildProcesses`
- The calculation of the segment size and number of segments was incorrect, most likely due to some confusion as to when it is run in the main process or not.
- The total number of batches was incorrect:
  - when no child processes are spawned, it is not the segment size that matters but the total number of items
  - when child processes are spawned, it may be that the last process does not need to run its maximum number of batches if there is not enough items

Author: theofidry

src/Configuration.php

@@ -35,14 +35,12 @@ final class Configuration
     private int $totalNumberOfBatches;
 
     /**
-     * @param positive-int   $numberOfProcesses
      * @param 0|positive-int $numberOfItems
      * @param positive-int   $segmentSize
      * @param positive-int   $batchSize
      */
     public function __construct(
-        bool $numberOfProcessesDefined,
-        int $numberOfProcesses,
+        bool $shouldSpawnChildProcesses,
         int $numberOfItems,
         int $segmentSize,
         int $batchSize
@@ -59,11 +57,24 @@ public function __construct(
             ),
         );
 
-        $this->segmentSize = 1 === $numberOfProcesses && !$numberOfProcessesDefined
-            ? $numberOfItems
-            : $segmentSize;
-        $this->numberOfSegments = (int) (1 === $numberOfProcesses ? 1 : ceil($numberOfItems / $segmentSize));
-        $this->totalNumberOfBatches = (int) (ceil($segmentSize / $batchSize) * $this->numberOfSegments);
+        if ($shouldSpawnChildProcesses) {
+            $this->segmentSize = $segmentSize;
+            $this->numberOfSegments = (int) ceil($numberOfItems / $segmentSize);
+            $this->totalNumberOfBatches = self::calculateTotalNumberOfBatches(
+                $numberOfItems,
+                $segmentSize,
+                $batchSize,
+                $this->numberOfSegments,
+            );
+        } else {
+            // The segments are what define the sizes of the sub-processes. When
+            // executing only the main process, then there is no use for
+            // segments.
+            // See https://github.com/webmozarts/console-parallelization#segments
+            $this->segmentSize = 1;
+            $this->numberOfSegments = 1;
+            $this->totalNumberOfBatches = (int) ceil($numberOfItems / $batchSize);
+        }
     }
 
     /**
@@ -89,4 +100,36 @@ public function getTotalNumberOfBatches(): int
     {
         return $this->totalNumberOfBatches;
     }
+
+    /**
+     * @param 0|positive-int $numberOfItems
+     * @param positive-int   $segmentSize
+     * @param positive-int   $batchSize
+     * @param positive-int   $numberOfSegments
+     *
+     * @return positive-int
+     */
+    private static function calculateTotalNumberOfBatches(
+        int $numberOfItems,
+        int $segmentSize,
+        int $batchSize,
+        int $numberOfSegments
+    ): int {
+        if ($numberOfSegments >= 2) {
+            // It "should" be `$numberOfSegments - 1`. However, it actually does
+            // not matter as the expression L128 is just going to give a
+            // negative number adjusting the final result correctly.
+            // So we keep this simpler expression, although a bit less intuitive,
+            // to avoid to have to configure Infection to not mutate this piece.
+            $numberOfCompleteSegments = $numberOfSegments;
+            $totalNumberOfBatches = ((int) ceil($segmentSize / $batchSize)) * $numberOfSegments;
+        } else {
+            $numberOfCompleteSegments = 0;
+            $totalNumberOfBatches = 0;
+        }
+
+        $totalNumberOfBatches += (int) ceil(($numberOfItems - $numberOfCompleteSegments * $segmentSize) / $batchSize);
+
+        return $totalNumberOfBatches;
+    }
 }

src/ParallelExecutor.php

@@ -219,9 +219,15 @@ private function executeMainProcess(
 
         $numberOfItems = $itemIterator->getNumberOfItems();
 
-        $config = new Configuration(
-            $isNumberOfProcessesDefined,
+        $shouldSpawnChildProcesses = self::shouldSpawnChildProcesses(
+            $numberOfItems,
+            $segmentSize,
             $numberOfProcesses,
+            $parallelizationInput->isNumberOfProcessesDefined(),
+        );
+
+        $config = new Configuration(
+            $shouldSpawnChildProcesses,
             $numberOfItems,
             $segmentSize,
             $batchSize,
@@ -243,12 +249,7 @@ private function executeMainProcess(
 
         $logger->startProgress($numberOfItems);
 
-        if (self::shouldSpawnChildProcesses(
-            $numberOfItems,
-            $segmentSize,
-            $numberOfProcesses,
-            $parallelizationInput->isNumberOfProcessesDefined(),
-        )) {
+        if ($shouldSpawnChildProcesses) {
             $this
                 ->createProcessLauncher(
                     $segmentSize,