Add multiprocessing.cpu_count access to platform module.

recipe_modules/platform/api.py

 # Copyright 2013 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 import sys
 import platform
+import multiprocessing
 
 from recipe_engine import recipe_api
 
 
 def norm_plat(plat):
   if plat.startswith('linux'):
     return 'linux'
   elif plat.startswith(('win', 'cygwin')):
     return 'win'
   elif plat.startswith(('darwin', 'mac')):
@@ skipping 20 matching lines @@
     super(PlatformApi, self).__init__(**kwargs)
     self._name = norm_plat(sys.platform)
 
     self._arch = 'intel'
     self._bits = norm_bits(platform.machine())
 
     if self._test_data.enabled:
       # Default to linux/64, unless test case says otherwise.
       self._name = norm_plat(self._test_data.get('name', 'linux'))
       self._bits = norm_bits(self._test_data.get('bits', 64))
+      self._cpu_count = self._test_data.get('cpu_count', 2)
     else:  # pragma: no cover
       # platform.machine is based on running kernel. It's possible to use 64-bit
       # kernel with 32-bit userland, e.g. to give linker slightly more memory.
       # Distinguish between different userland bitness by querying
       # the python binary.
       if (self._name == 'linux' and
           self._bits == 64 and
           platform.architecture()[0] == '32bit'):
         self._bits = 32
       # On Mac, the inverse of the above is true: the kernel is 32-bit but the
       # CPU and userspace both are capable of running 64-bit programs.
       elif (self._name == 'mac' and
             self._bits == 32 and
             platform.architecture()[0] == '64bit'):
         self._bits = 64
 
+      self._cpu_count = multiprocessing.cpu_count()
+
   @property
   def is_win(self):
     return self.name == 'win'
 
   @property
   def is_mac(self):
     return self.name == 'mac'
 
   @property
   def is_linux(self):
     return self.name == 'linux'
 
   @property
   def name(self):
     return self._name
 
   @property
   def bits(self):
     # The returned bitness corresponds to the userland. If anyone ever wants
     # to query for bitness of the kernel, another accessor should be added.
     return self._bits
 
   @property
   def arch(self):
     return self._arch
 
+  @property
+  def cpu_count(self):
+    """The number of CPU cores, according to multiprocessing.cpu_count()."""
+    return self._cpu_count
+
   @staticmethod
   def normalize_platform_name(platform):
     """One of python's sys.platform values -> 'win', 'linux' or 'mac'."""
     return norm_plat(platform)  # pragma: no cover