Wie erhalte ich die Anzahl der CPUs / Kerne unter Linux über die Befehlszeile?

Ich habe dieses Skript, weiß aber nicht, wie ich das letzte Element im Ausdruck erhalten soll:

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

Das letzte Element sollte die Anzahl der CPUs minus 1 sein.

grep -c ^processor /proc/cpuinfo     

zählt die Anzahl der Zeilen beginnend mit "Prozessor" in /proc/cpuinfo

Für Systeme mit Hyper-Threading können Sie verwenden

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

welches zurückgeben sollte (zum Beispiel) 8(während der obige Befehl zurückgeben würde 16)

Die Verarbeitung des Inhalts von /proc/cpuinfoist unnötig barock. Verwenden Sie nproc, das Teil von coreutils ist, daher sollte es bei den meisten Linux-Installationen verfügbar sein.

Der Befehl gibt nprocdie Anzahl der für den aktuellen Prozess verfügbaren Verarbeitungseinheiten aus, die möglicherweise geringer ist als die Anzahl der Online-Prozessoren.

Um die Anzahl aller installierten Kerne / Prozessoren zu ermitteln, verwenden Sie nproc --all

Auf meiner 8-Kern-Maschine:

$ nproc --all
8

Die portabelste Lösung, die ich gefunden habe, ist der getconfBefehl:

getconf _NPROCESSORS_ONLN

Dies funktioniert sowohl unter Linux als auch unter Mac OS X. Ein weiterer Vorteil gegenüber einigen anderen Ansätzen besteht darin, dass es getconf schon lange gibt. Einige der älteren Linux-Maschinen, auf denen ich entwickeln muss, verfügen nicht über die Befehle nprocoder lscpu, aber sie haben sie getconf.

^{Anmerkung des Herausgebers: Während das getconf Dienstprogramm POSIX-mandatiert ist , sind die spezifischen _NPROCESSORS_ONLNund _NPROCESSORS_CONF Werte nicht. Wie bereits erwähnt, funktionieren sie sowohl auf Linux-Plattformen als auch unter macOS. Bei FreeBSD / PC-BSD müssen Sie die führende weglassen _.}

Vorwort:

• Das Problem bei den /proc/cpuinfoAntworten auf der Basis besteht darin, dass sie Informationen analysieren, die für den menschlichen Verzehr bestimmt waren, und daher kein stabiles Format für das Parsen von Maschinen aufweisen : Das Ausgabeformat kann je nach Plattform und Laufzeitbedingungen unterschiedlich sein. Die Verwendung lscpu -punter Linux (und sysctlunter MacOS) umgeht dieses Problem .

• getconf _NPROCESSORS_ONLNIch getconf NPROCESSORS_ONLNunterscheide nicht zwischen logischen und physischen CPUs.

Hier ist ein sh(POSIX-kompatibles) Snippet, das unter Linux und MacOS funktioniert, um die Anzahl der - online - logischen oder physischen CPUs zu bestimmen . Einzelheiten finden Sie in den Kommentaren.

Verwendet lscpufür Linux und sysctlfür MacOS.

Terminologie-Hinweis : CPU bezieht sich auf die kleinste Verarbeitungseinheit, wie sie vom Betriebssystem gesehen wird. Nicht-Hyper-Threading-Kerne entsprechen jeweils 1 CPU, während Hyper-Threading-Kerne mehr als 1 (normalerweise: 2) - logische - CPU enthalten.
Linux verwendet die folgende Taxonomie ^[1] , beginnend mit der kleinsten Einheit:
CPU < Kern < Socket < Buch < Knoten,
wobei jede Ebene 1 oder mehr Instanzen der nächstniedrigeren Ebene umfasst.

#!/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] macOS- sysctl (3)Dokumentation

Beachten Sie, dass von BSD abgeleitete Systeme außer macOS - z. B. FreeBSD - nur den hw.ncpuSchlüssel für unterstützen sysctl, der unter macOS veraltet ist. Ich bin mir nicht sicher, welcher der neuen Schlüssel hw.npuentspricht : hw.(logical|physical)cpu_[max].

^{Tipp an @teambob für die Korrektur des Befehls für die Anzahl der physischen CPUs lscpu.}

Vorsichtsmaßnahme : Die lscpu -pAusgabe enthält KEINE "Buch" -Spalte (auf der manSeite werden "Bücher" als Entität zwischen Socket und Knoten in der taxonomischen Hierarchie erwähnt). Wenn auf einem bestimmten Linux-System "Bücher" im Spiel sind ( weiß jemand wann und wie? ), Wird der Befehl für die Anzahl der physischen CPUs möglicherweise unter -report gemeldet (dies basiert auf der Annahme, dass lscpuIDs gemeldet werden , die über höhere nicht eindeutig sind Entitäten auf -ebene , z. B.: 2 verschiedene Kerne aus 2 verschiedenen Sockets können dieselbe ID haben.

Wenn Sie den obigen Code beispielsweise als Shell-Skript speicherncpus , ihn ausführbar machen chmod +x cpusund in einem Ordner in Ihrem Ordner ablegen $PATH, wird folgende Ausgabe angezeigt:

$ cpus
logical  4
physical 4

^{[1] Xaekai beleuchtet, was ein Buch ist: "Ein Buch ist ein Modul, das eine Leiterplatte mit CPU-Sockeln, RAM-Sockeln, E / A-Verbindungen entlang der Kante und einem Haken für die Kühlsystemintegration enthält. Sie werden in IBM-Mainframes verwendet Weitere Informationen: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf "}

lscpu sammelt Informationen zur CPU-Architektur aus / proc / cpuinfon in einem für Menschen lesbaren Format:

# 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

Siehe auch /unix/468766/understanding-output-of-lscpu .

Das hat bei mir funktioniert. tail -nXMit dieser Option können Sie nur die letzten X-Zeilen erfassen.

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

Wenn Sie Hyperthreading haben, sollte dies funktionieren, um die Anzahl der physischen Kerne zu ermitteln.

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

Für die Gesamtzahl der physischen Kerne:

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

Multiplizieren Sie auf Computern mit mehreren Sockets (oder immer) das obige Ergebnis mit der Anzahl der Sockets:

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

@ mklement0 hat unten eine nette Antwort mit lscpu. Ich habe eine prägnantere Version in den Kommentaren geschrieben

Sie können auch Python verwenden! So ermitteln Sie die Anzahl der physischen Kerne:

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

So ermitteln Sie die Anzahl der Hyperthread-Kerne:

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

Plattformübergreifende Lösung für Linux, MacOS, Windows:

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

So zähle ich die Anzahl der physischen Kerne, die unter Linux online sind:

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

oder kurz:

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

Beispiel (1 Steckdose):

> 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

Beispiel (2 Steckdosen):

> 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

Beispiel (4 Steckdosen):

> 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

Die Verwendung von getconf ist in der Tat die portabelste Methode. Die Variable hat jedoch in BSD und Linux unterschiedliche Namen für getconf. Daher müssen Sie beide testen, wie in diesem Inhalt vorgeschlagen: https://gist.github.com/jj1bdx/5746298 (enthält auch) ein Solaris-Fix mit ksh)

Ich persönlich benutze:

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

Und wenn Sie dies in Python möchten, können Sie einfach die von syscall getconf verwendeten verwenden, indem Sie das Betriebssystemmodul importieren:

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

Was nproc, es ist Teil des GNU Coreutils, also nicht in BSD standardmäßig. Nach einigen anderen Methoden wird auch sysconf () verwendet.

Wenn Sie dies tun möchten, damit es unter Linux und OS X funktioniert, können Sie Folgendes tun:

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

Es ist sehr einfach. Verwenden Sie einfach diesen Befehl:

lscpu

Sie können eine der folgenden Methoden verwenden, um die Anzahl der physischen CPU-Kerne zu bestimmen .

• Zählen Sie die Anzahl der eindeutigen Kern-IDs (ungefähr gleichwertig mit grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l).

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

• Multiplizieren Sie die Anzahl der 'Kerne pro Sockel' mit der Anzahl der Sockel.

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

• Zählen Sie die Anzahl der eindeutigen logischen CPUs, die vom Linux-Kernel verwendet werden. Die -pOption generiert eine Ausgabe zum einfachen Parsen und ist mit früheren Versionen von kompatibel lscpu.

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

Um noch einmal zu wiederholen, was andere gesagt haben, gibt es eine Reihe verwandter Eigenschaften.

So bestimmen Sie die Anzahl der verfügbaren Prozessoren:

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

Ermittlung der Anzahl der verfügbaren Verarbeitungseinheiten (nicht unbedingt gleich der Anzahl der Kerne). Dies ist hyperthreading-bewusst.

nproc

Ich möchte nicht zu weit in den Kaninchenbau gehen, aber Sie können auch die Anzahl der konfigurierten Prozessoren (im Gegensatz zu einfach verfügbaren / Online-Prozessoren) über bestimmen getconf _NPROCESSORS_CONF. Um die Gesamtzahl der CPUs (offline und online) zu bestimmen, möchten Sie die Ausgabe von analysieren lscpu -ap.

Ich dachte cat /proc/cpuinfoauch, ich würde die richtige Antwort erhalten, aber ich habe kürzlich gesehen, dass mein ARM Quad Core Cortex A53 System nur einen einzigen Kern aufweist. Es scheint, dass / proc / cpuinfo nur die aktiven Kerne anzeigt, während:

cat /sys/devices/system/cpu/present

ist ein besseres Maß dafür, was da ist. Du kannst auch

cat /sys/devices/system/cpu/online

um zu sehen, welche Kerne online sind, und

cat /sys/devices/system/cpu/offline

um zu sehen, welche Kerne offline sind. Die online, offlineund presentsysfs Einträge zurück , den Index des CPUs, so dass ein Rückgabewert von 0nur Mitteln Kern 0, während eines Rückgabewertes von 1-3Mitteln Kernen 1,2 und 3.

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

Im Folgenden sollten Sie die Anzahl der "echten" Kerne auf einem Hyperthread- und einem Nicht-Hyperthread-System angeben. Zumindest hat es in all meinen Tests funktioniert.

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

Nicht meine Webseite, aber dieser Befehl von http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 funktioniert gut für mich auf Centos. Es zeigt den tatsächlichen CPU-Wert an, auch wenn das Hyperthreading aktiviert ist.

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

Zählen Sie die "Kern-ID" pro "physische ID" -Methode mit awk mit Fallback auf "Prozessor", wenn "Kern-ID" nicht verfügbar ist (wie Himbeere).

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

Das hat gut funktioniert. Als ich die erste Antwort versuchte, bekam ich 3 CPUs als Ausgang. Ich weiß, dass ich 4 CPUs im System habe, also habe ich nur einen grepfür den Prozessor erstellt und die Ausgabe sah folgendermaßen aus:

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

 dmidecode  | grep -i cpu | grep Version

gibt mir

Version: Intel (R) Xeon (R) CPU E5-2667 v4 bei 3,20 GHz

Version: Intel (R) Xeon (R) CPU E5-2667 v4 bei 3,20 GHz

Welches ist die richtige Socket-Anzahl? E5-2667Wenn Sie nachschlagen 8 cores, sagt mir das, was jeder Socket hat , also multiplizieren Sie und landen Sie bei 16 coresacross 2 sockets.

Wo lscpugibst du mir 20 CPUs- was völlig falsch ist - nicht sicher warum. (Gleiches gilt für cat /proc/cpu- endet mit 20.

Schneller ohne Gabel

Diese Arbeit mit fast allen Schale.

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

Um kompatibel zu bleiben mit Schale, Strich, Busyboxund andere habe ich ncore=$((ncore+1))stattdessen verwendet ((ncore++)).

Bash Ausführung

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

Wenn es in Ordnung ist, dass Sie Python verwenden können, hat das numexprModul eine Funktion dafür:

In [5]: import numexpr as ne

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

auch das:

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

Um diese Informationen an der Eingabeaufforderung abzufragen, verwenden Sie:

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

Oder es ist einfach möglich, diese Informationen von der multiprocessing.cpu_count()Funktion abzurufen

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

Oder noch einfacher verwenden os.cpu_count()

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

Wenn Sie nur physische Kerne zählen möchten, hat dieser Befehl dies für mich getan.

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

Ziemlich einfach, scheint aber die tatsächlichen physischen Kerne zu zählen, wobei die logische Anzahl ignoriert wird

Python 3 bietet auch einige einfache Möglichkeiten, um es zu erhalten:

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

4

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

4

Verwenden Sie die folgende Abfrage, um die wichtigsten Details abzurufen

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

Zusammenfassung: Um physische CPUs zu erhalten, gehen Sie wie folgt vor :

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

Um physische und logische CPUs zu erhalten, gehen Sie wie folgt vor:

grep -c ^processor /proc/cpuinfo

/proc << Dies ist die goldene Quelle für alle Informationen, die Sie über Prozesse und benötigen

/proc/cpuinfo << ist die goldene Quelle für CPU-Informationen.