Cómo averiguar la cantidad de CPU que usan Python

Quiero saber la cantidad de CPU en la máquina local que usa Python. El resultado debe ser user/realcomo resultado time(1)cuando se llama con un programa de espacio de usuario de escala óptima.

Si tiene Python con una versión> = 2.6, simplemente puede usar

import multiprocessing

multiprocessing.cpu_count()

http://docs.python.org/library/multiprocessing.html#multiprocessing.cpu_count

Si está interesado en la cantidad de procesadores disponibles para su proceso actual, primero debe verificar cpuset . De lo contrario (o si cpuset no está en uso), este multiprocessing.cpu_count()es el camino a seguir en Python 2.6 y versiones posteriores. El siguiente método recurre a un par de métodos alternativos en versiones anteriores de Python:

import os
import re
import subprocess


def available_cpu_count():
    """ Number of available virtual or physical CPUs on this system, i.e.
    user/real as output by time(1) when called with an optimally scaling
    userspace-only program"""

    # cpuset
    # cpuset may restrict the number of *available* processors
    try:
        m = re.search(r'(?m)^Cpus_allowed:\s*(.*)$',
                      open('/proc/self/status').read())
        if m:
            res = bin(int(m.group(1).replace(',', ''), 16)).count('1')
            if res > 0:
                return res
    except IOError:
        pass

    # Python 2.6+
    try:
        import multiprocessing
        return multiprocessing.cpu_count()
    except (ImportError, NotImplementedError):
        pass

    # https://github.com/giampaolo/psutil
    try:
        import psutil
        return psutil.cpu_count()   # psutil.NUM_CPUS on old versions
    except (ImportError, AttributeError):
        pass

    # POSIX
    try:
        res = int(os.sysconf('SC_NPROCESSORS_ONLN'))

        if res > 0:
            return res
    except (AttributeError, ValueError):
        pass

    # Windows
    try:
        res = int(os.environ['NUMBER_OF_PROCESSORS'])

        if res > 0:
            return res
    except (KeyError, ValueError):
        pass

    # jython
    try:
        from java.lang import Runtime
        runtime = Runtime.getRuntime()
        res = runtime.availableProcessors()
        if res > 0:
            return res
    except ImportError:
        pass

    # BSD
    try:
        sysctl = subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
                                  stdout=subprocess.PIPE)
        scStdout = sysctl.communicate()[0]
        res = int(scStdout)

        if res > 0:
            return res
    except (OSError, ValueError):
        pass

    # Linux
    try:
        res = open('/proc/cpuinfo').read().count('processor\t:')

        if res > 0:
            return res
    except IOError:
        pass

    # Solaris
    try:
        pseudoDevices = os.listdir('/devices/pseudo/')
        res = 0
        for pd in pseudoDevices:
            if re.match(r'^cpuid@[0-9]+$', pd):
                res += 1

        if res > 0:
            return res
    except OSError:
        pass

    # Other UNIXes (heuristic)
    try:
        try:
            dmesg = open('/var/run/dmesg.boot').read()
        except IOError:
            dmesgProcess = subprocess.Popen(['dmesg'], stdout=subprocess.PIPE)
            dmesg = dmesgProcess.communicate()[0]

        res = 0
        while '\ncpu' + str(res) + ':' in dmesg:
            res += 1

        if res > 0:
            return res
    except OSError:
        pass

    raise Exception('Can not determine number of CPUs on this system')

Otra opción es usar la psutilbiblioteca, que siempre resulta útil en estas situaciones:

>>> import psutil
>>> psutil.cpu_count()
2

Esto debería funcionar en cualquier plataforma compatible con psutil(Unix y Windows).

Tenga en cuenta que en algunas ocasiones multiprocessing.cpu_countpuede aumentar un NotImplementedErrortiempo psutilpodrá obtener el número de CPU. Esto es simplemente porque psutilprimero intenta usar las mismas técnicas que usa multiprocessingy, si fallan, también usa otras técnicas.

En Python 3.4+: os.cpu_count () .

multiprocessing.cpu_count()se implementa en términos de esta función, pero aumenta NotImplementedErrorsi os.cpu_count()devuelve None("no se puede determinar el número de CPU").

len(os.sched_getaffinity(0)) es lo que normalmente quieres

https://docs.python.org/3/library/os.html#os.sched_getaffinity

os.sched_getaffinity(0)(agregado en Python 3) devuelve el conjunto de CPU disponibles teniendo en cuenta la sched_setaffinityllamada al sistema Linux , que limita en qué CPU puede ejecutarse un proceso y sus hijos.

0significa obtener el valor para el proceso actual. La función devuelve una set()de las CPU permitidas, por lo tanto, la necesidad delen() .

multiprocessing.cpu_count() Por otro lado, solo devuelve el número total de CPU físicas.

La diferencia es especialmente importante porque ciertos sistemas de administración de clúster como Platform LSF limitan el uso de CPU de trabajo sched_getaffinity.

Por lo tanto, si lo usa multiprocessing.cpu_count(), su script podría intentar usar muchos más núcleos de los que tiene disponibles, lo que puede provocar sobrecarga y tiempos de espera.

Podemos ver la diferencia concretamente restringiendo la afinidad con la tasksetutilidad.

Por ejemplo, si restrinjo Python a solo 1 núcleo (núcleo 0) en mi sistema de 16 núcleos:

taskset -c 0 ./main.py

con el script de prueba:

main.py

#!/usr/bin/env python3

import multiprocessing
import os

print(multiprocessing.cpu_count())
print(len(os.sched_getaffinity(0)))

entonces la salida es:

16
1

nproc sin embargo, respeta la afinidad por defecto y:

taskset -c 0 nproc

salidas:

1

y lo man nprochace bastante explícito:

imprime el número de unidades de procesamiento disponibles

nproctiene el --allindicador para el caso menos común en el que desea obtener el recuento físico de CPU:

taskset -c 0 nproc --all

El único inconveniente de este método es que parece ser solo UNIX. Supuse que Windows debe tener una API de afinidad similar, posiblemente SetProcessAffinityMask, así que me pregunto por qué no se ha portado. Pero no sé nada sobre Windows.

Probado en Ubuntu 16.04, Python 3.5.2.

Si desea saber la cantidad de núcleos físicos (no núcleos virtuales hiperprocesados), aquí hay una solución independiente de la plataforma:

psutil.cpu_count(logical=False)

https://github.com/giampaolo/psutil/blob/master/INSTALL.rst

Tenga en cuenta que el valor predeterminado para logicales True, por lo tanto, si desea incluir núcleos hipertirados, puede usar:

psutil.cpu_count()

Esto dará el mismo número que os.cpu_count()y multiprocessing.cpu_count(), ninguno de los cuales tiene el logicalargumento de palabra clave.

Estos le dan el conteo de CPU hiperprocesado

1. multiprocessing.cpu_count()
2. os.cpu_count()

Estos le dan el recuento de CPU de la máquina virtual

1. psutil.cpu_count()
2. numexpr.detect_number_of_cores()

Solo importa si trabaja en máquinas virtuales.

multiprocessing.cpu_count()devolverá el número de CPU lógicas, por lo que si tiene una CPU de cuatro núcleos con hyperthreading, volverá 8. Si desea la cantidad de CPU físicas, use los enlaces de python para hwloc:

#!/usr/bin/env python
import hwloc
topology = hwloc.Topology()
topology.load()
print topology.get_nbobjs_by_type(hwloc.OBJ_CORE)

hwloc está diseñado para ser portátil en sistemas operativos y arquitecturas.

No puedo entender cómo agregar al código o responder al mensaje, pero aquí hay soporte para jython que puede agregar antes de darse por vencido:

# jython
try:
    from java.lang import Runtime
    runtime = Runtime.getRuntime()
    res = runtime.availableProcessors()
    if res > 0:
        return res
except ImportError:
    pass

Esto puede funcionar para aquellos de nosotros que usamos diferentes sistemas operativos, pero queremos obtener lo mejor de todos los mundos:

import os
workers = os.cpu_count()
if 'sched_getaffinity' in dir(os):
    workers = len(os.sched_getaffinity(0))

También puede usar "joblib" para este propósito.

import joblib
print joblib.cpu_count()

Este método le dará la cantidad de cpus en el sistema. Sin embargo, debe instalarse JobLib. Puede encontrar más información sobre joblib aquí. https://pythonhosted.org/joblib/parallel.html

Alternativamente, puede usar el paquete numexpr de python. Tiene muchas funciones simples útiles para obtener información sobre la CPU del sistema.

import numexpr as ne
print ne.detect_number_of_cores()

Otra opción si no tienes Python 2.6:

import commands
n = commands.getoutput("grep -c processor /proc/cpuinfo")