Wie kann ich die Anzahl der CPUs/Kerne in Linux von der Kommandozeile erhalten?

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

Der Befehl nproc gibt die Anzahl der Verarbeitungseinheiten aus, die für den aktuellen Prozess verfügbar sind. Dies kann weniger als die Anzahl der Online-Prozessoren sein.

Verwenden Sie nproc --all, um die Anzahl aller installierten Kerne/Prozessoren zu ermitteln.

Auf meiner 8-Kern-Maschine:

$ nproc --all
8

Die tragbarste Lösung, die ich gefunden habe, ist der Befehl getconf:

getconf _NPROCESSORS_ONLN

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

^{Anmerkung des Herausgebers: Während das getconf-Programm POSIX-Mandat ist , sind die spezifischen _NPROCESSORS_ONLN- und _NPROCESSORS_CONF-Werte nicht. Das heißt, wie gesagt, sie funktionieren sowohl auf Linux-Plattformen als auch auf MacOS. Bei FreeBSD/PC-BSD müssen Sie den führenden _ weglassen.}

Vorwort: 

• Das -Problem mit den /proc/cpuinfo-basierten Antworten besteht darin, dass sie Informationen analysieren, die für den Verbrauch von (mensch gedacht waren, und daher ein stabiles Format für das Maschinen-Parsing fehlt: Plattformen und Laufzeitbedingungen; using lscpu -p unter Linux (und sysctl unter macOS) umgeht dieses Problem.

• getconf _NPROCESSORS_ONLNgetconf NPROCESSORS_ONLN unterscheidet nicht zwischen logisch und physisch CPUs.

Hier ist ein sh (POSIX-kompatibles) Snippet, das unter _/Linux und macOS funktioniert, um die Anzahl von - online - logisch oder physisch CPUs; Details finden Sie in den Kommentaren.

Verwendet lscpu für Linux und sysctl für macOS.

Terminologieanmerkung: CPU bezieht sich auf die kleinste Verarbeitungseinheit, die vom Betriebssystem gesehen wird. Nicht-Hyper-Threading-Kerne entsprechen jeweils einer CPU, wohingegen Hyper-Threading-Kerne mehr als eine (normalerweise: 2) logische CPU enthalten.
Linux verwendet die folgende Taxonomie, beginnend mit der kleinsten Einheit: CPU <Kern <Socket <Buch <node, wobei jede Ebene eine oder mehrere Instanzen der nächst niedrigeren Ebene umfasst.
Mein Wissen ist hier etwas wackelig - lassen Sie mich wissen, ob ich falsch liege.Weiß jemand, was ein "Buch" in diesem Zusammenhang ist?

#!/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 andere von BSD abgeleitete Systeme als macOS - z. B. FreeBSD - nur den hw.ncpu-Schlüssel für sysctl unterstützen, die unter macOS nicht mehr empfohlen werden. Ich bin unklar, welcher der neuen Schlüssel hw.npu entspricht: hw.(logical|physical)cpu_[max].

^{Tipp an @teambob für die Korrektur des physischen CPU-Count-Befehls lscpu.}

Caveat: lscpu -p Die Ausgabe enthält KEINE "book" -Spalte (die man-Seite erwähnt "books" als Entität zwischen Socket und Knoten in der taxonomischen Hierarchie). Wenn auf einem bestimmten Linux-System "Bücher" im Spiel sind (weiß wann und wie?), Kann der physikalische CPU-Count-Befehl under- report (dies basiert auf) die Annahme, dass lscpu IDs meldet, die nicht eindeutig sind übergeordnete Entitäten; zB: 2 verschiedene Kerne aus 2 verschiedenen Sockets könnten dieselbe ID haben).

Wenn Sie den obigen Code als Shell-Skript cpus speichern, ihn mit chmod +x cpus ausführbar machen und ihn im Ordner $PATH ablegen, wird folgende Ausgabe angezeigt:

$ cpus
logical  4
physical 4

lscpu sammelt Informationen zur CPU-Architektur in/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 https://unix.stackexchange.com/questions/468766/understanding-output-of-lscpu .

Das hat bei mir funktioniert. Mit tail -nX können Sie nur die letzten X-Zeilen erfassen.

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

Wenn Sie über Hyper-Threading verfügen, sollte dies die Anzahl der physischen -Kerne 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 Maschinen mit mehreren Sockeln (oder immer) das obige Ergebnis mit der Anzahl der Sockel:

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

@ mklement0 hat unten eine ziemlich nette Antwort mit lscpu. Ich habe eine knappere Version in den Kommentaren geschrieben

Sie können auch Python verwenden! Um die Anzahl der physischen Kerne zu erhalten:

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

So ermitteln Sie die Anzahl der Hyperthreaded Cores:

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

Die Verwendung von getconf ist in der Tat die portabelste Methode, allerdings hat die Variable in BSD und Linux unterschiedliche Namen für getconf. Daher müssen Sie beide testen, wie dies von Gist vorgeschlagen wird: https://Gist.github.com/) jj1bdx/5746298 .__ (enthält auch einen 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 wollen, können Sie einfach den syscall-Befehl getconf verwenden, indem Sie das os-Modul importieren:

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

Was nproc betrifft, so ist es Teil von GNU Coreutils, daher nicht standardmäßig in BSD verfügbar. Es verwendet sysconf () auch nach einigen anderen Methoden.

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

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)

Im Folgenden sollten Sie die Anzahl der "echten" Kerne sowohl in einem Hyperthread- als auch in einem Nicht-Hyperthreadsystem angeben. Zumindest hat es in allen meinen Tests funktioniert. 

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

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

• Zählen Sie die Anzahl der eindeutigen Core-IDs (entspricht in etwa 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 Option -p Generiert eine Ausgabe zum einfachen Parsen und ist mit früheren Versionen von lscpu kompatibel.

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

Um nur zu wiederholen, was andere gesagt haben, gibt es eine Reihe von verwandten Eigenschaften.

So bestimmen Sie die Anzahl der verfügbaren Prozessoren:

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

Zur Bestimmung der Anzahl der verfügbaren Verarbeitungseinheiten (nicht unbedingt die gleiche wie die Anzahl der Kerne). Dies ist hyperthreading-bewusst.

nproc

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

Auf diese Weise verwende 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

Ich dachte auch, cat /proc/cpuinfo würde mir die richtige Antwort geben, aber ich habe kürzlich gesehen, dass mein ARM Vierkern-Cortex-A53-System nur einen einzigen Kern zeigte. 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 sysfs-Einträge online, offline und present geben den Index des CPUS zurück, sodass ein Rückgabewert von 0 nur den Kern 0 bedeutet, während ein Rückgabewert von 1-3 die Kerne 1,2 und 3 bedeutet.

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

Wenn Sie nur physische Kerne zählen möchten, hat dieser Befehl das 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

Zählung der "Kern-ID" pro "physikalische Id" -Methode unter Verwendung von awk mit Rückfall auf "Prozessor" -Zählung, 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)

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

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 mit dem Befehl Aufforderung abzufragen, verwenden Sie Folgendes:

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

Oder Sie können diese Informationen einfach über die Funktion multiprocessing.cpu_count() abrufen

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

Oder noch einfacher verwenden Sie os.cpu_count()

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

Es ist sehr einfach. Verwenden Sie einfach diesen Befehl:

lscpu

Schneller ohne Gabel

Dies funktioniert mit almsost all Shell .

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

Um mit Shell , dash , busybox und anderen kompatibel zu bleiben, habe ich ncore=$((ncore+1)) anstelle von ((ncore++)) verwendet.

bash version

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

cat /proc/cpuinfo | grep processor

Das hat gut funktioniert. Als ich die erste Antwort ausprobierte, erhielt ich 3 CPUs als Ausgang. Ich weiß, dass ich 4 CPUs auf dem System habe, also habe ich gerade eine grep für den Prozessor erstellt und die Ausgabe sah folgendermaßen aus: 

[[email protected] ~]# cat /proc/cpuinfo | grep processor
processor       : 0
processor       : 1
processor       : 2
processor       : 3

Zusammenfassung: um physische CPUs zu bekommen mache dies:

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 Prozesse benötigen

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

 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 der korrekte Socket-Countdown - nachschlagen der E5-2667 sagt mir, dass jeder Socket 8 cores hat, multiplizieren Sie und enden Sie mit 16 cores über 2 sockets.

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

Verwenden Sie die folgende Abfrage, um die Kerndetails abzurufen

[[email protected]](TESTDB)$ grep -c ^processor /proc/cpuinfo
8

Nicht meine Webseite, sondern dieser Befehl von http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 funktioniert für mich auf Centos. Die tatsächliche CPU wird auch angezeigt, wenn 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

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