More fine-grained control (using [conf]) for build parallelization

conan/tools/cmake/cmake.py

@@ -3,13 +3,15 @@
 
 from conan.tools.cmake.base import CMakeToolchainBase
 from conan.tools.cmake.utils import get_generator, is_multi_configuration
-from conan.tools.microsoft.msbuild import msbuild_verbosity_cmd_line_arg
+from conan.tools.gnu.make import make_jobs_cmd_line_arg
+from conan.tools.meson.meson import ninja_jobs_cmd_line_arg
+from conan.tools.microsoft.msbuild import msbuild_verbosity_cmd_line_arg, \
+    msbuild_max_cpu_count_cmd_line_arg
 from conans.client import tools
 from conans.client.build import join_arguments
 from conans.client.tools.files import chdir
 from conans.client.tools.oss import cpu_count, args_to_string
 from conans.errors import ConanException
-from conans.model.version import Version
 from conans.util.conan_v2_mode import conan_v2_error
 from conans.util.files import mkdir
 
@@ -23,15 +25,27 @@ def _validate_recipe(conanfile):
 
 def _cmake_cmd_line_args(conanfile, generator, parallel):
     args = []
-    compiler_version = conanfile.settings.get_safe("compiler.version")
-    if generator and parallel:
-        if ("Makefiles" in generator or "Ninja" in generator) and "NMake" not in generator:
-            args.append("-j%i" % cpu_count(conanfile.output))
-        elif "Visual Studio" in generator and compiler_version and Version(compiler_version) >= "10":
-            # Parallel for building projects in the solution
-            args.append("/m:%i" % cpu_count(output=conanfile.output))
-
-    if generator and "Visual Studio" in generator:
+    if not generator:
+        return args
+
+    # Arguments related to parallel
+    if "MakeFiles" in generator and "NMake" not in generator and parallel:
+        njobs = make_jobs_cmd_line_arg(conanfile)
+        if njobs:
+            args.append(njobs)
+
+    if "Ninja" in generator and "NMake" not in generator:
+        njobs = ninja_jobs_cmd_line_arg(conanfile)
+        if njobs:
+            args.append(njobs)
+
+    if "Visual Studio" in generator and parallel:
+        max_cpu_count = msbuild_max_cpu_count_cmd_line_arg(conanfile)
+        if max_cpu_count:
+            args.append(max_cpu_count)
+
+    # Arguments for verbosity
+    if "Visual Studio" in generator:
         verbosity = msbuild_verbosity_cmd_line_arg(conanfile)
         if verbosity:
             args.append(verbosity)

conan/tools/gnu/make.py

@@ -3,11 +3,19 @@
 from collections import OrderedDict
 
 from jinja2 import Template
+
 from conans.client.build.compiler_flags import build_type_define, libcxx_define
 from conans.client.tools.oss import detected_architecture, detected_os, get_build_os_arch
 from conans.util.files import save
 
 
+def make_jobs_cmd_line_arg(conanfile):
+    njobs = conanfile.conf["tools.gnu.make"].jobs or \
+            conanfile.conf["tools.build"].processes
+    if njobs:
+        return "-j{}".format(njobs)
+
+
 class MakeToolchain(object):
     filename = "conan_toolchain.mak"
 

conan/tools/meson/meson.py

@@ -2,7 +2,14 @@
 
 from conan.tools.meson import MesonToolchain
 from conan.tools.microsoft.visual import vcvars_command, vcvars_arch
-from conans.client.tools.oss import cross_building, cpu_count
+from conans.client.tools.oss import cross_building
+
+
+def ninja_jobs_cmd_line_arg(conanfile):
+    njobs = conanfile.conf["tools.ninja"].jobs or \
+            conanfile.conf["tools.build"].processes
+    if njobs:
+        return "-j{}".format(njobs)
 
 
 class Meson(object):
@@ -33,14 +40,17 @@ def configure(self, source_folder=None):
         if cross_building(self._conanfile):
             cmd += ' --cross-file "{}"'.format(MesonToolchain.cross_filename)
         else:
-            cmd += ' --native-file "{}"'. format(MesonToolchain.native_filename)
+            cmd += ' --native-file "{}"'.format(MesonToolchain.native_filename)
         cmd += ' "{}" "{}"'.format(self._build_dir, source)
         if self._conanfile.package_folder:
             cmd += ' -Dprefix="{}"'.format(self._conanfile.package_folder)
         self._run(cmd)
 
     def build(self, target=None):
-        cmd = 'meson compile -C "{}" -j {}'.format(self._build_dir, cpu_count())
+        cmd = 'meson compile -C "{}"'.format(self._build_dir)
+        njobs = ninja_jobs_cmd_line_arg(self._conanfile)
+        if njobs:
+            cmd += " {}".format(njobs)
         if target:
             cmd += " {}".format(target)
         self._run(cmd)

conan/tools/microsoft/msbuild.py

@@ -9,6 +9,13 @@ def msbuild_verbosity_cmd_line_arg(conanfile):
         return '/verbosity:{}'.format(verbosity)
 
 
+def msbuild_max_cpu_count_cmd_line_arg(conanfile):
+    max_cpu_count = conanfile.conf["tools.microsoft.msbuild"].max_cpu_count or \
+                    conanfile.conf["tools.build"].processes
+    if max_cpu_count:
+        return "/m:{}".format(max_cpu_count)
+
+
 class MSBuild(object):
     def __init__(self, conanfile):
         self._conanfile = conanfile
@@ -34,6 +41,10 @@ def command(self, sln):
         if verbosity:
             cmd += " {}".format(verbosity)
 
+        max_cpu_count = msbuild_max_cpu_count_cmd_line_arg(self._conanfile)
+        if max_cpu_count:
+            cmd += " {}".format(max_cpu_count)
+
         return cmd
 
     def build(self, sln):