Jak sprawdzić liczbę procesorów za pomocą Pythona

Chcę poznać liczbę procesorów na komputerze lokalnym za pomocą Pythona. Wynik powinien być taki sam, user/realjak w time(1)przypadku wywołania za pomocą optymalnie skalowanego programu przeznaczonego tylko dla użytkowników.

Jeśli masz Pythona w wersji> = 2.6, możesz po prostu użyć

import multiprocessing

multiprocessing.cpu_count()

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

Jeśli interesuje Cię liczba procesorów dostępnych dla bieżącego procesu, musisz najpierw sprawdzić cpuset . W przeciwnym razie (lub jeśli cpuset nie jest używany), multiprocessing.cpu_count()jest to droga do przejścia w Pythonie 2.6 i nowszych. Następująca metoda odwołuje się do kilku alternatywnych metod w starszych wersjach Pythona:

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')

Inną opcją jest użycie psutil biblioteki, która zawsze okazuje się przydatna w następujących sytuacjach:

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

Powinno to działać na dowolnej platformie obsługiwanej przez psutil(Unix i Windows).

Należy pamiętać, że w niektórych przypadkach multiprocessing.cpu_countmoże wzrosnąć przez pewien NotImplementedErrorczas psutilbędzie w stanie uzyskać liczbę procesorów. Dzieje się tak po prostu dlatego, że psutilnajpierw próbuje zastosować te same techniki, których używa, multiprocessinga jeśli te zawiodą, stosuje również inne techniki.

W Python 3.4+: os.cpu_count () .

multiprocessing.cpu_count()jest zaimplementowany w kategoriach tej funkcji, ale podnosi się, NotImplementedErrorjeśli os.cpu_count()zwraca None(„nie można określić liczby procesorów”).

len(os.sched_getaffinity(0)) jest tym, czego zwykle chcesz

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

os.sched_getaffinity(0)(dodany w Pythonie 3) zwraca zestaw dostępnych procesorów, biorąc pod uwagę sched_setaffinitywywołanie systemowe Linux , które ogranicza procesory, na których proces i jego potomne mogą działać.

0oznacza uzyskanie wartości dla bieżącego procesu. Funkcja zwraca a set()dozwolonych procesorów, stąd potrzeba len().

multiprocessing.cpu_count() z drugiej strony po prostu zwraca całkowitą liczbę fizycznych procesorów.

Różnica jest szczególnie ważna, ponieważ niektóre systemy zarządzania klastrami, takie jak Platform LSF, ograniczają użycie procesora zadaniasched_getaffinity .

Dlatego jeśli używasz multiprocessing.cpu_count() , twój skrypt może próbować użyć znacznie większej liczby rdzeni, niż ma dostępnych, co może prowadzić do przeciążenia i przekroczenia limitu czasu.

Widzimy różnicę konkretnie, ograniczając powinowactwo z taskset użytecznością.

Na przykład, jeśli ograniczę Pythona do 1 rdzenia (0 rdzenia) w moim 16-rdzeniowym systemie:

taskset -c 0 ./main.py

ze skryptem testowym:

main.py

#!/usr/bin/env python3

import multiprocessing
import os

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

następnie dane wyjściowe to:

16
1

nproc jednak domyślnie szanuje powinowactwo i:

taskset -c 0 nproc

wyjścia:

1

i man nprocczyni to całkiem wyraźnym:

wydrukuj liczbę dostępnych jednostek przetwarzania

nprocma --allflagę dla rzadszego przypadku, w którym chcesz uzyskać fizyczną liczbę procesorów:

taskset -c 0 nproc --all

Jedynym minusem tej metody jest to, że wydaje się, że jest to tylko UNIX. Podejrzewam, że Windows musi mieć podobny interfejs API powinowactwa SetProcessAffinityMask, więc zastanawiam się, dlaczego nie został przeniesiony. Ale nic nie wiem o systemie Windows.

Testowane w Ubuntu 16.04, Python 3.5.2.

niezależny od platformy:

psutil.cpu_count (logiczne = Fałsz)

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

Dają ci liczbę procesorów hyperthreaded

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

Dają ci liczbę procesorów maszyny wirtualnej

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

Ma to znaczenie tylko, jeśli pracujesz na maszynach wirtualnych.

multiprocessing.cpu_count() zwróci liczbę logicznych procesorów, więc jeśli masz czterordzeniowy procesor z hyperthreading, zwróci 8 . Jeśli chcesz mieć liczbę fizycznych procesorów, użyj hwloc:

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

hwloc jest zaprojektowany tak, aby był przenośny w różnych systemach operacyjnych i architekturach.

Nie mogę wymyślić, jak dodać do kodu lub odpowiedzieć na wiadomość, ale oto wsparcie dla Jython, które możesz wprowadzić przed rezygnacją:

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

Może to działać dla tych z nas, którzy używają różnych systemów operacyjnych, ale chcą uzyskać to, co najlepsze ze wszystkich światów:

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

W tym celu możesz również użyć „joblib”.

import joblib
print joblib.cpu_count()

Ta metoda da ci liczbę procesorów w systemie. Joblib musi być jednak zainstalowany. Więcej informacji na temat joblib można znaleźć tutaj https://pythonhosted.org/joblib/parallel.html

Alternatywnie możesz użyć pakietu numexpr Pythona. Ma wiele prostych funkcji pomocnych w uzyskiwaniu informacji o procesorze systemowym.

import numexpr as ne
print ne.detect_number_of_cores()

Inna opcja, jeśli nie masz języka Python 2.6:

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