Wie erhält man die Anzahl der CPUs / Kerne in Linux von der Kommandozeile?

Habe ich dieses Skript, aber ich weiß nicht, wie man das Letzte element in dem Ausdruck:

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

Das Letzte element sollte der Anzahl der CPUs minus 1.

Kommentar zu dem Problem

Sie nicht brauchen, um Katze vor awk, eh nur awk '<script>' /proc/cpuinfo: awk '/^processor/{n+=1}END{print n}' /proc/cpuinfo. Und Sie erhalten ohne "minus eins". Kommentarautor: Tomasz Gandor

InformationsquelleAutor der Frage Richard | 2011-06-25

342
```
cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1
```
oder einfach
```
grep -c ^processor /proc/cpuinfo     
```
die Anzahl von Zeilen, beginnend mit "Prozessor" in /proc/cpuinfo

InformationsquelleAutor der Antwort unbeli
398

Verarbeitung des Inhalts /proc/cpuinfo ist unnötig Barock. Verwenden nproc die Bestandteil von coreutils, also es sollte auf den meisten Linux-Installationen.

Befehl nproc druckt die Anzahl der Verarbeitungseinheiten zur Verfügung, um den aktuellen Prozess kann weniger als die Anzahl der online-Prozessoren.

Finden Sie die Anzahl aller installierten Kerne/Prozessoren verwenden nproc --all

Auf meinem 8-core-Maschine:
```
$ nproc --all
8
```
InformationsquelleAutor der Antwort uckelman
172

Den meisten tragbaren Lösung, die ich gefunden habe, ist das getconf Befehl:
```
getconf _NPROCESSORS_ONLN
```
Diese funktioniert sowohl auf Linux und Mac OS X. ein Weiterer Vorteil dieser über einige der anderen Ansätze ist, dass getconf gewesen herum für eine lange Zeit. Einige ältere Linux-Maschinen zu tun haben, ich-Entwicklung auf nicht die nproc oder lscpu Befehle zur Verfügung, aber Sie haben getconf.

^{Anmerkung der Redaktion: Während die getconf Dienstprogramm POSIX-Mandat, die spezifischen _NPROCESSORS_ONLN und _NPROCESSORS_CONF Werte nicht.

Das sagte, wie gesagt, Sie arbeiten auf Linux-Plattformen als auch auf macOS; auf FreeBSD/PC-BSD, müssen Sie ausgelassen _.}

InformationsquelleAutor der Antwort mshildt
53

Vorwort:
- Den problem mit der /proc/cpuinfo-basierten Antworten ist, dass Sie die Informationen analysieren, die gemeint war für menschlichen Verbrauch und damit fehlt ein stabiles format, entworfen für Maschine analysieren: das Ausgabe-format kann Verschieden Plattformen hinweg-und Laufzeit-Bedingungen; mit lscpu -p auf Linux (und sysctl auf OSX) umgeht dieses problem.
- getconf _NPROCESSORS_ONLN /getconf NPROCESSORS_ONLN unterscheidet nicht zwischen logische und körperliche CPUs.
Hier ein bash - Schnipsel funktioniert auf Linux und macOS für die Bestimmung der Anzahl der - online - logische oder körperliche CPUs; siehe die Kommentare für weitere details.

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

Terminologie beachten: CPU bezieht sich auf die kleinste Verarbeitungseinheit in der OS. Nicht-hyper-threading-Kerne jeweils entsprechen 1 CPU, in der Erwägung, dass hyper-threading-Kerne enthalten mehr als 1 (in der Regel: 2) - logisch - CPU.

Linux verwendet die folgenden Taxonomie, beginnend mit der kleinsten Einheit: CPU < core < Buchse < Buch < Knoten, mit jedem Niveau, bestehend aus 1 oder mehr Instanzen auf der nächst tieferen Ebene.

Mein wissen ist etwas wackelig hier - lassen Sie mich wissen, wenn ich falsch Liege.
Weiß jemand, was ein "Buch" ist in diesem Zusammenhang?
```
# 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)
```
[1] macOS sysctl (3) - Dokumentation

Beachten Sie, dass die BSD-abgeleiteten Systemen andere als macOS - z.B., FreeBSD - Unterstützung nur die hw.ncpu Schlüssel für sysctl, die veraltet sind auf macOS; ich bin unklar, auf welchen der neue Schlüssel hw.npu entspricht: hw.(logical|physical)cpu_[max].

^{Tipp der Hut, um @teambob für die Hilfe zu korrigieren, die körperliche-CPU-count lscpu Befehl.}

VORBEHALT: lscpu -p Ausgabe NICHT enthalten ist eine "Buch" - Spalte (die man Seite erwähnt "Bücher" als eine Einheit zwischen Steckdose und Knoten in der taxonomischen Hierarchie). Wenn "Bücher" sind im Spiel auf eine bestimmte Linux-system (weiß jemand, Wann und wie?), die physische CPU-count-Befehl kann unter-Bericht (dies basiert auf der Annahme, dass lscpu Berichte IDs sind nicht eindeutig über übergeordnete Entitäten; z.B.: 2 unterschiedliche Kerne aus 2 verschiedenen Steckdosen könnte, haben die gleiche ID).

InformationsquelleAutor der Antwort mklement0
12

Dieser arbeitete für mich. tail -nX können Sie schnappen Sie sich nur die letzten X Zeilen.
```
cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1
```
Wenn du hyperthreading sollte diese Arbeit für die Aufbereitung der Anzahl der körperliche Kerne.
```
grep "^core id" /proc/cpuinfo | sort -u | wc -l
```
InformationsquelleAutor der Antwort lunixbochs
9

Für die Gesamtanzahl der physischen Kerne:
```
grep '^core id' /proc/cpuinfo |sort -u|wc -l
```
Auf mehrere sockel-Maschinen (oder immer), multiplizieren Sie das obige Ergebnis durch die Anzahl der buchsen:
```
echo $(($(grep "^physical id" /proc/cpuinfo | awk '{print $4}' | sort -un | tail -1)+1))
```
@mklement0 hat durchaus eine nette Antwort unten mit lscpu. Ich habe geschrieben, kurz und bündig-version in den Kommentaren

InformationsquelleAutor der Antwort teambob
7

Mit getconf ist in der Tat die meisten tragbaren Weg, aber die variable hat verschiedene Namen in BSD und Linux, getconf, so dass Sie haben, um zu prüfen, wie diese Kern-Idee:
https://gist.github.com/jj1bdx/5746298
(enthält auch ein Solaris-Update mit ksh)

Ich persönlich benutze:
```
$ getconf _NPROCESSORS_ONLN 2>/dev/null || getconf NPROCESSORS_ONLN 2>/dev/null || echo 1
```
Und wenn Sie wollen, dass diese in python, können Sie einfach die syscall-getconf verwendet, die durch den Import der os-Modul:
```
$ python -c 'import os; print os.sysconf(os.sysconf_names["SC_NPROCESSORS_ONLN"]);'
```
Als für nproc, es ist Teil der GNU Coreutils, also nicht in BSD standardmäßig. Es nutzt sysconf() als auch nach einigen anderen Methoden.

InformationsquelleAutor der Antwort mmu_man
5

Wenn Sie dies tun wollen, damit es funktioniert auf linux und OS X, die Sie tun können:
```
CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
```
InformationsquelleAutor der Antwort tim_yates
4

Können Sie auch Python! Um die Anzahl der physischen Kerne:
```
$ python -c "import psutil; psutil.cpu_count(logical=False)"
4
```
, Um die Anzahl der HyperThread-cores:
```
$ python -c "import psutil; psutil.cpu_count(logical=True)"
8
```
InformationsquelleAutor der Antwort ostrokach

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

InformationsquelleAutor der Antwort Sergey

lscpu sammelt CPU-Architektur Informationen /proc/cpuinfon in der human-read-fähig-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

InformationsquelleAutor der Antwort Sh4msi

3

Sollte Folgendes geben Sie die Anzahl der "echten" Kerne auf einem HyperThread-und nicht-HyperThread-system. Zumindest funktionierte es in meinen tests.
```
awk -F: '/^physical/&& !ID[$2] { P++; ID[$2]=1 }; /^cpu cores/{ CORES=$2 };  END { print CORES*P }' /proc/cpuinfo
```
InformationsquelleAutor der Antwort foomiser
2

Können Sie verwenden Sie eine der folgenden Methoden, um zu bestimmen, die Anzahl der körperliche CPU-Kerne.
- Count die Anzahl der eindeutigen core-ids (das entspricht rund 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 socket, die von der Anzahl der sockets.
  
  lscpu | awk '/^Core$s$ per socket:/{cores=$NF}; /^Socket$s$:/{sockets=$NF}; END{print cores*sockets}'
- Zählen Sie die Anzahl der logischen CPU ' s wie der Linux-kernel. Die -p option erzeugt-Ausgang für eine einfache Analyse und ist kompatibel mit früheren Versionen von lscpu.
  
  lscpu -p | awk -F, '$0 !~ /^#/{cores[$1]++} END {print length(cores)}'
Nur zu wiederholen, was andere gesagt haben, gibt es eine Reihe von verwandten Eigenschaften.

Zu bestimmen, die Anzahl der verfügbaren Prozessoren:
```
getconf _NPROCESSORS_ONLN
grep -cP '^processor\t' /proc/cpuinfo
```
Zur Bestimmung der Anzahl der Verarbeitungseinheiten zur Verfügung (nicht notwendigerweise die gleiche wie die Anzahl der Kerne). Dies ist die hyperthreading-bewusst.
```
nproc
```
Ich will nicht zu weit zu gehen, down the rabbit-hole, Sie können aber auch bestimmen die Anzahl der konfigurierten Prozessoren (im Gegensatz zu einfach verfügbar/online-Prozessoren) über getconf _NPROCESSORS_CONF. Um zu bestimmen, insgesamt die Anzahl der CPU ' s (offline und online), die Sie wollen, um zu analysieren die Ausgabe von lscpu -ap.

InformationsquelleAutor der Antwort Six

Count "core id" pro "physical id" - Methode unter Verwendung von awk mit fall-back auf "Prozessor" zählen wenn "core id" sind nicht verfügbar (wie Himbeeren)

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)

InformationsquelleAutor der Antwort Totaly FuRy

Hier ist der Weg, ich benutze zum zählen der Anzahl von physischen Prozessorkernen, die online sind, auf Linux:

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

kurz:

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

InformationsquelleAutor der Antwort Fravadona

1
```
cat /proc/cpuinfo | grep processor
```
Dies funktionierte gut. Als ich versuchte, die erste Antwort bekam ich 3 CPU ' s als output. Ich weiß, dass ich 4 CPUs auf dem system, so, ich habe gerade ein grep für den Prozessor und die Ausgabe sah so aus:
```
[root@theservername ~]# cat /proc/cpuinfo | grep processor
processor       : 0
processor       : 1
processor       : 2
processor       : 3
```
InformationsquelleAutor der Antwort Gary Liggons

Schneller, ohne Gabel

Diese Arbeit mit almsost alle shell.

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, dash, busybox und andere, die ich benutzt habe ncore=$((ncore+1)) statt ((ncore++)).

bash - version

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

InformationsquelleAutor der Antwort F. Hauri

0

Nicht meine web-Seite, 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 wird sich zeigen aktuelle cpus, auch 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

InformationsquelleAutor der Antwort Chaim Geretz
0
```
 dmidecode  | grep -i cpu | grep Version
```
gibt mir

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

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

Die korrekte Buchse zählen - die Suche des E5-2667 sagt mir jeder socket hat 8 cores, so multiplizieren und am Ende mit 16 cores über 2 sockets.

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

InformationsquelleAutor der Antwort Hank42

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.