Extract DivideUp lambda

Author: kastiglione

lib/Driver/Compilation.cpp

@@ -1361,18 +1361,24 @@ namespace driver {
       // subprocesses than before. And significantly: it's doing so while
       // not exceeding the RAM of a typical 2-core laptop.
 
+      // An explanation of why the partition calculation isn't integer division.
+      // Using an example, a module of 26 files exceeds the limit of 25 and must
+      // be compiled in 2 batches. Integer division yields 26/25 = 1 batch, but
+      // a single batch of 26 exceeds the limit. The calculation must round up,
+      // which can be calculated using: `(x + y - 1) / y`
+      //
+      // Two key properties of this calculation are:
+      //   DivideUp(M*N, N) = M
+      //   DivideUp(M*N + 1, N) = M + 1
+      auto DivideUp = [](size_t Num, size_t Div) -> size_t {
+        return (Num + Div - 1) / Div;
+      };
+
       size_t DefaultSizeLimit = 25;
       size_t NumTasks = TQ->getNumberOfParallelTasks();
       size_t NumFiles = PendingExecution.size();
       size_t SizeLimit = Comp.getBatchSizeLimit().getValueOr(DefaultSizeLimit);
-
-      // An explanation of why the partition calculation isn't simple division.
-      // Using the default limit as an example, a module of 26 files must be
-      // compiled in 2 batches. Simple division yields 26/25 = 1 batch, but a
-      // single batch of 26 would exceed the limit of 25. To round up, the
-      // calculation is: `(x - 1) / y + 1`.
-      size_t NumPartitions = (NumFiles - 1) / SizeLimit + 1;
-      return std::max(NumTasks, NumPartitions);
+      return std::max(NumTasks, DivideUp(NumFiles, SizeLimit));
     }
 
     /// Select jobs that are batch-combinable from \c PendingExecution, combine