Jak uzyskać liczbę procesorów / rdzeni w systemie Linux z wiersza polecenia?

Mam ten skrypt, ale nie wiem, jak uzyskać ostatni element na wydruku:

cat /proc/cpuinfo | awk '/^processor/{print $3}'

Ostatnim elementem powinna być liczba procesorów minus 1.

grep -c ^processor /proc/cpuinfo     

policzy liczbę linii zaczynających się od „procesor” w /proc/cpuinfo

W przypadku systemów z hiperwątkowością można użyć

grep ^cpu\\scores /proc/cpuinfo | uniq |  awk '{print $4}' 

który powinien zwrócić (na przykład) 8(podczas gdy powyższe polecenie powróci 16)

Przetwarzanie zawartości /proc/cpuinfojest niepotrzebnie barokowe. Użyj nproc, który jest częścią coreutils, więc powinien być dostępny w większości instalacji Linuksa.

Polecenie nprocdrukuje liczbę jednostek przetwarzania dostępnych dla bieżącego procesu, która może być mniejsza niż liczba procesorów online.

Aby znaleźć liczbę wszystkich zainstalowanych rdzeni / procesorów, użyj nproc --all

Na mojej 8-rdzeniowej maszynie:

$ nproc --all
8

Najbardziej przenośnym rozwiązaniem, jakie znalazłem, jest getconfpolecenie:

getconf _NPROCESSORS_ONLN

Działa to zarówno w systemie Linux, jak i Mac OS X. Inną zaletą tego w porównaniu z innymi podejściami jest to, że getconf istnieje już od dłuższego czasu. Niektóre starsze maszyny z Linuksem, na których muszę tworzyć, nie mają dostępnych poleceń nproclub lscpu, ale mają getconf.

^{Od redakcji: Podczas narzędzie jest upoważniona POSIX , specyficzne i wartości nie są. To powiedziawszy, jak powiedziano, działają na platformach Linux, a także na macOS; na FreeBSD / PC-BSD musisz pominąć wiodącą pozycję .getconf _NPROCESSORS_ONLN_NPROCESSORS_CONF _}

Przedmowa:

• Problem z /proc/cpuinfoopartych o odpowiedziach jest to, że parse informacje, które było przeznaczone dla ludzkiej konsumpcji, a tym samym brakuje formatu stabilne przeznaczone do maszynowego parsowania : Format wyjściowy może się różnić na różnych platformach i warunków wykonawczych; używanie lscpu -pw systemie Linux (i sysctlmacOS) omija ten problem .

• getconf _NPROCESSORS_ONLN/ getconf NPROCESSORS_ONLNNie rozróżnia logicznych i fizycznych procesorów.

Oto shfragment kodu (zgodny z POSIX), który działa w systemach Linux i macOS do określania liczby procesorów logicznych lub fizycznych w trybie online ; zobacz komentarze, aby uzyskać szczegółowe informacje.

Korzysta lscpuz systemu Linux i sysctlmacOS.

Uwaga dotycząca terminologii : CPU oznacza najmniejszą jednostkę przetwarzającą widzianą przez system operacyjny. Każdy rdzeń niebędący hiperwątkiem odpowiada 1 procesorowi, podczas gdy rdzenie hiperwątkowujące zawierają więcej niż 1 (zwykle: 2) - logicznie - procesor.
Linux wykorzystuje następującą taksonomię ^[1] , zaczynając od najmniejszej jednostki:
CPU < rdzeń < gniazdo < książka < węzeł
z każdym poziomem zawierającym 1 lub więcej instancji następnego niższego poziomu.

#!/bin/sh

# macOS:           Use `sysctl -n hw.*cpu_max`, which returns the values of 
#                  interest directly.
#                  CAVEAT: Using the "_max" key suffixes means that the *maximum*
#                          available number of CPUs is reported, whereas the
#                          current power-management mode could make *fewer* CPUs 
#                          available; dropping the "_max" suffix would report the
#                          number of *currently* available ones; see [1] below.
#
# Linux:           Parse output from `lscpu -p`, where each output line represents
#                  a distinct (logical) CPU.
#                  Note: Newer versions of `lscpu` support more flexible output
#                        formats, but we stick with the parseable legacy format 
#                        generated by `-p` to support older distros, too.
#                        `-p` reports *online* CPUs only - i.e., on hot-pluggable 
#                        systems, currently disabled (offline) CPUs are NOT
#                        reported.

# Number of LOGICAL CPUs (includes those reported by hyper-threading cores)
  # Linux: Simply count the number of (non-comment) output lines from `lscpu -p`, 
  # which tells us the number of *logical* CPUs.
logicalCpuCount=$([ $(uname) = 'Darwin' ] && 
                       sysctl -n hw.logicalcpu_max || 
                       lscpu -p | egrep -v '^#' | wc -l)

# Number of PHYSICAL CPUs (cores).
  # Linux: The 2nd column contains the core ID, with each core ID having 1 or
  #        - in the case of hyperthreading - more logical CPUs.
  #        Counting the *unique* cores across lines tells us the
  #        number of *physical* CPUs (cores).
physicalCpuCount=$([ $(uname) = 'Darwin' ] && 
                       sysctl -n hw.physicalcpu_max ||
                       lscpu -p | egrep -v '^#' | sort -u -t, -k 2,4 | wc -l)

# Print the values.
cat <<EOF
# of logical CPUs:  $logicalCpuCount
# of physical CPUS: $physicalCpuCount
EOF

[1] dokumentacja macOSsysctl (3)

Zauważ, że systemy pochodzące z BSD inne niż macOS - np. FreeBSD - obsługują tylko hw.ncpuklucz dla sysctl, które są przestarzałe w macOS; Jestem jasne, która z nowych kluczy hw.npuodpowiada: hw.(logical|physical)cpu_[max].

^{Wskazówka dla @teambob za pomoc w poprawieniu lscpukomendy obliczania fizycznych procesorów .}

Uwaga : lscpu -pdane wyjściowe NIE zawierają kolumny „książka” ( manstrona wspomina o „książkach” jako encji między gniazdem a węzłem w hierarchii taksonomicznej). Jeśli „książki” są w grze w danym systemie Linux ( czy ktoś wie kiedy i jak? ), Komenda fizyko-CPU-count może pod -report (ta opiera się na założeniu, że lscpuraporty identyfikatory, które są specyficzne dla całej wyższy -poziomowe jednostki , np .: 2 różne rdzenie z 2 różnych gniazd mogą mieć ten sam identyfikator).

Jeśli zapiszesz powyższy kod jako, powiedzmy, skrypt powłokicpus , sprawisz , że będzie wykonywalny chmod +x cpusi umieścisz go w folderze w swoim folderze $PATH, zobaczysz dane wyjściowe, takie jak:

$ cpus
logical  4
physical 4

^{[1] Xaekai rzuca światło na to, czym jest książka : „ książka to moduł zawierający płytkę drukowaną z gniazdami procesora, gniazdami RAM, połączeniami IO wzdłuż krawędzi i hakiem do integracji systemu chłodzenia. Są one używane w komputerach mainframe IBM Więcej informacji: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf ”}

lscpu gromadzi informacje o architekturze procesora / proc / cpuinfon w formacie czytelnym dla człowieka:

# lscpu


Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                8
On-line CPU(s) list:   0-7
Thread(s) per core:    1
Core(s) per socket:    4
CPU socket(s):         2
NUMA node(s):          1
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 15
Stepping:              7
CPU MHz:               1866.669
BogoMIPS:              3732.83
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              4096K
NUMA node0 CPU(s):     0-7

Zobacz także /unix/468766/understanding-output-of-lscpu .

To zadziałało dla mnie. tail -nXpozwala uchwycić tylko ostatnie X linii.

cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1

Jeśli masz hyperthreading, powinno to działać w celu pobrania liczby rdzeni fizycznych .

grep "^core id" /proc/cpuinfo | sort -u | wc -l

Dla całkowitej liczby rdzeni fizycznych:

grep '^core id' /proc/cpuinfo |sort -u|wc -l

Na maszynach z wieloma gniazdami (lub zawsze) należy pomnożyć powyższy wynik przez liczbę gniazd:

echo $(($(grep "^physical id" /proc/cpuinfo | awk '{print $4}' | sort -un | tail -1)+1))

@ mklement0 ma całkiem fajną odpowiedź poniżej za pomocą lscpu. W komentarzach napisałem bardziej zwięzłą wersję

Możesz także użyć Pythona! Aby uzyskać liczbę rdzeni fizycznych:

$ python -c "import psutil; print(psutil.cpu_count(logical=False))"
4

Aby uzyskać liczbę rdzeni hiperwątkowych:

$ python -c "import psutil; print(psutil.cpu_count(logical=True))"
8

Rozwiązanie Crossplatform dla systemów Linux, MacOS, Windows:

CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu || echo "$NUMBER_OF_PROCESSORS")

Oto sposób, w jaki używam do zliczania liczby rdzeni fizycznych, które są online w systemie Linux:

lscpu --online --parse=Core,Socket | grep --invert-match '^#' | sort --unique | wc --lines

lub w skrócie:

lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l

Przykład (1 gniazdo):

> lscpu
...
CPU(s):                28
Thread(s) per core:    2
Core(s) per socket:    14
Socket(s):             1
....
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
14

Przykład (2 gniazda):

> lscpu
...
CPU(s):                56
Thread(s) per core:    2
Core(s) per socket:    14
Socket(s):             2
...
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
28

Przykład (4 gniazda):

> lscpu
...
CPU(s):                64
Thread(s) per core:    2
Core(s) per socket:    8
Socket(s):             4
...
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
32

Korzystanie z getconf jest rzeczywiście najbardziej przenośnym sposobem, jednak zmienna ma różne nazwy w BSD i Linux, aby uzyskać getconf, więc musisz przetestować oba, jak sugeruje to gist: https://gist.github.com/jj1bdx/5746298 (obejmuje również poprawka Solaris za pomocą ksh)

Osobiście używam:

$ getconf _NPROCESSORS_ONLN 2>/dev/null || getconf NPROCESSORS_ONLN 2>/dev/null || echo 1

A jeśli chcesz tego w pythonie, możesz po prostu użyć syscall, którego używa getconf, importując moduł os:

$ python -c 'import os; print os.sysconf(os.sysconf_names["SC_NPROCESSORS_ONLN"]);'

Co do tego nproc, jest częścią GNU Coreutils, więc domyślnie nie jest dostępna w BSD. Używa sysconf () również po kilku innych metodach.

Jeśli chcesz to zrobić, aby działało na systemie Linux i OS X, możesz:

CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)

To bardzo proste. Wystarczy użyć tego polecenia:

lscpu

Możesz użyć jednej z następujących metod, aby określić liczbę fizycznych rdzeni procesora.

• Policz liczbę unikalnych podstawowych identyfikatorów (mniej więcej tyle, ile wynosi grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l).

  awk '/^core id\t/ {cores[$NF]++} END {print length(cores)}' /proc/cpuinfo

• Pomnóż liczbę „rdzeni na gniazdo” przez liczbę gniazd.

  lscpu | awk '/^Core\(s\) per socket:/ {cores=$NF}; /^Socket\(s\):/ {sockets=$NF}; END{print cores*sockets}'

• Policz liczbę unikalnych logicznych procesorów używanych przez jądro Linuksa. -pOpcja generuje wyjście dla łatwego analizowania i jest kompatybilny z wcześniejszymi wersjami lscpu.

  lscpu -p | awk -F, '$0 !~ /^#/ {cores[$1]++} END {print length(cores)}'

Aby powtórzyć to, co powiedzieli inni, istnieje wiele powiązanych właściwości.

Aby określić liczbę dostępnych procesorów:

getconf _NPROCESSORS_ONLN
grep -cP '^processor\t' /proc/cpuinfo

Aby określić liczbę dostępnych jednostek przetwarzających (niekoniecznie taką samą jak liczba rdzeni). Jest to świadomy hipertekstu.

nproc

Nie chcę schodzić zbyt daleko w dół do króliczej nory, ale można również określić liczbę skonfigurowanych procesorów (w przeciwieństwie do zwykłych procesorów dostępnych online) getconf _NPROCESSORS_CONF. Aby określić całkowitą liczbę procesorów (offline i online), należy przeanalizować dane wyjściowe lscpu -ap.

Pomyślałem również, cat /proc/cpuinfoże da mi poprawną odpowiedź, jednak ostatnio zauważyłem, że mój czterordzeniowy system ARM Cortex A53 wykazywał tylko jeden rdzeń. Wygląda na to, że / proc / cpuinfo pokazuje tylko aktywne rdzenie, podczas gdy:

cat /sys/devices/system/cpu/present

jest lepszą miarą tego, co tam jest. Możesz też

cat /sys/devices/system/cpu/online

aby zobaczyć, które rdzenie są online, i

cat /sys/devices/system/cpu/offline

aby zobaczyć, które rdzenie są offline. Te online, offlineoraz presentSysFS wpisy powrót indeksu jednostek CPU, a więc wartość powrotu 0tylko środki rdzenia 0, podczas gdy wartość powrotną 1-3oznacza, że rdzenie 1,2 i 3.

Zobacz https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-system-cpu

Poniższe informacje powinny dać ci liczbę „prawdziwych” rdzeni zarówno w systemie hiperwątkowym, jak i niehththreaded. Przynajmniej działał we wszystkich moich testach.

awk -F: '/^physical/ && !ID[$2] { P++; ID[$2]=1 }; /^cpu cores/ { CORES=$2 };  END { print CORES*P }' /proc/cpuinfo

Nie moja strona internetowa, ale to polecenie z http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 działa dla mnie ładnie na centos. Pokaże rzeczywisty procesor, nawet gdy włączony jest hiperwątkowanie.

cat /proc/cpuinfo | egrep "core id|physical id" | tr -d "\n" | sed s/physical/\\nphysical/g | grep -v ^$ | sort | uniq | wc -l

Policz „identyfikator rdzenia” według metody „identyfikatora fizycznego” za pomocą awk z rezerwą na „procesorze”, licz, jeśli „identyfikator rdzenia” nie jest dostępny (np. Malina)

echo $(awk '{ if ($0~/^physical id/) { p=$NF }; if ($0~/^core id/) { cores[p$NF]=p$NF }; if ($0~/processor/) { cpu++ } } END { for (key in cores) { n++ } } END { if (n) {print n} else {print cpu} }' /proc/cpuinfo)

cat /proc/cpuinfo | grep processor

To działało dobrze. Kiedy wypróbowałem pierwszą odpowiedź, otrzymałem 3 procesory jako dane wyjściowe. Wiem, że mam 4 procesory w systemie, więc właśnie zrobiłem grepprocesor, a dane wyjściowe wyglądały następująco:

[root@theservername ~]# cat /proc/cpuinfo | grep processor
processor       : 0
processor       : 1
processor       : 2
processor       : 3

 dmidecode  | grep -i cpu | grep Version

daje mi

Wersja: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Wersja: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Która jest poprawna liczba gniazd - patrząc w górę E5-2667mówi mi, że każde gniazdo ma 8 cores, więc pomnóż i skończ z 16 coresprzecinkiem 2 sockets.

Gdzie lscpudaj mi 20 CPUs- co jest całkowicie niepoprawne - nie jestem pewien, dlaczego. (to samo dotyczy cat /proc/cpu- kończy się na 20.

Szybszy, bez widelca

Działa to z prawie wszystkimi muszla.

ncore=0
while read line ;do
    [ "$line" ] && [ -z "${line%processor*}" ] && ncore=$((ncore+1))
  done </proc/cpuinfo
echo $ncore
4

Aby zachować zgodność z muszla, dziarskość, busyboxi inne, których użyłem ncore=$((ncore+1))zamiast ((ncore++)).

grzmotnąć wersja

ncore=0
while read -a line ;do
    [ "$line" = "processor" ] && ((ncore++))
  done </proc/cpuinfo
echo $ncore
4

Jeśli możesz używać Pythona, numexprmoduł ma do tego funkcję:

In [5]: import numexpr as ne

In [6]: ne.detect_number_of_cores()
Out[6]: 8

także to:

In [7]: ne.ncores
Out[7]: 8

Aby wyszukać te informacje w wierszu polecenia, użyj:

# runs whatever valid Python code given as a string with `-c` option
$ python -c "import numexpr as ne; print(ne.ncores)"
8

Lub po prostu można uzyskać te informacje z multiprocessing.cpu_count()funkcji

$ python -c "import multiprocessing; print(multiprocessing.cpu_count())"

Lub jeszcze bardziej po prostu użyj os.cpu_count()

$ python -c "import os; print(os.cpu_count())"

Jeśli chcesz policzyć rdzenie fizyczne, to polecenie zrobiło to dla mnie.

lscpu -e | tail -n +2 | tr -s " " | cut -d " " -f 4 | sort | uniq | wc -w

Całkiem proste, ale zdaje się liczyć rzeczywiste rdzenie fizyczne, ignorując logiczną liczbę

Python 3 oferuje również kilka prostych sposobów na uzyskanie:

$ python3 -c "import os; print(os.cpu_count());"

4

$ python3 -c "import multiprocessing; print(multiprocessing.cpu_count())"

4

Użyj poniższego zapytania, aby uzyskać podstawowe informacje

[oracle@orahost](TESTDB)$ grep -c ^processor /proc/cpuinfo
8

Podsumowanie: aby uzyskać fizyczne procesory, wykonaj następujące czynności:

grep 'core id' /proc/cpuinfo | sort -u

aby uzyskać fizyczne i logiczne procesory, wykonaj następujące czynności:

grep -c ^processor /proc/cpuinfo

/proc << to jest złote źródło wszelkich potrzebnych informacji na temat procesów i

/proc/cpuinfo << jest złotym źródłem wszelkich informacji o procesorze.