Come ottenere il numero di CPU / core in Linux dalla riga di comando?

Ho questo script, ma non so come ottenere l'ultimo elemento nella stampa:

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

L'ultimo elemento dovrebbe essere il numero di CPU, meno 1.

grep -c ^processor /proc/cpuinfo     

conterà il numero di righe che iniziano con "processore" in /proc/cpuinfo

Per i sistemi con hyper-threading, è possibile utilizzare

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

che dovrebbe restituire (ad esempio) 8(mentre il comando sopra restituirebbe 16)

Elaborare il contenuto di /proc/cpuinfoè inutilmente barocco. Usa nproc che fa parte di coreutils, quindi dovrebbe essere disponibile sulla maggior parte delle installazioni di Linux.

Il comando nprocstampa il numero di unità di elaborazione disponibili per il processo corrente, che può essere inferiore al numero di processori online.

Per trovare il numero di tutti i core / processori installati utilizzare nproc --all

Sulla mia macchina a 8 core:

$ nproc --all
8

La soluzione più portatile che ho trovato è il getconfcomando:

getconf _NPROCESSORS_ONLN

Funziona su Linux e Mac OS X. Un altro vantaggio di questo rispetto ad alcuni degli altri approcci è che getconf è in circolazione da molto tempo. Alcune delle macchine Linux più vecchie su cui devo fare lo sviluppo non hanno i comandi nproco lscpudisponibili, ma ce l'hanno getconf.

^{Nota del redattore: mentre l' getconf utilità è obbligatoria per POSIX , i valori specifici _NPROCESSORS_ONLNe non lo sono. Detto questo, come detto, funzionano su piattaforme Linux e su macOS; su FreeBSD / PC-BSD, devi omettere il comando ._NPROCESSORS_CONF _}

Prefazione:

• Il problema con le /proc/cpuinforisposte basate sul fatto è che analizzano le informazioni destinate al consumo umano e quindi mancano di un formato stabile progettato per l'analisi delle macchine : il formato di output può differire tra piattaforme e condizioni di runtime; l'utilizzo lscpu -psu Linux (e sysctlsu macOS) aggira quel problema .

• getconf _NPROCESSORS_ONLN/ getconf NPROCESSORS_ONLNnon distingue tra CPU logiche e fisiche .

Ecco uno shsnippet (conforme a POSIX) che funziona su Linux e macOS per determinare il numero di CPU - online - logiche o fisiche ; vedere i commenti per i dettagli.

Utilizza lscpuper Linux e sysctlper macOS.

Nota terminologica : CPU si riferisce all'unità di elaborazione più piccola vista dal sistema operativo. I core non hyper-threading corrispondono ciascuno a 1 CPU, mentre i core hyper-threading contengono più di 1 (in genere: 2) - logici - CPU.
Linux utilizza la seguente tassonomia ^[1] , a partire dall'unità più piccola: nodo
CPU < core < socket < book < con ogni livello comprendente 1 o più istanze del livello inferiore successivo.

#!/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] documentazione macOSsysctl (3)

Nota che i sistemi derivati ​​da BSD diversi da macOS - ad esempio FreeBSD - supportano solo la hw.ncpuchiave per sysctl, che sono deprecati su macOS; Sono poco chiaro di quale delle nuove chiavi hw.npucorrisponde a: hw.(logical|physical)cpu_[max].

^{Punta del cappello a @teambob per aiutare a correggere il lscpucomando conteggio fisico-CPU .}

Avvertenza : l' lscpu -poutput NON include una colonna "libro" (la manpagina menziona "libri" come entità tra socket e nodo nella gerarchia tassonomica). Se "libri" sono in gioco su un determinato sistema Linux ( qualcuno sa quando e come? ), Il comando conteggio fisico CPU-CPU potrebbe essere sotto -riportato (questo si basa sul presupposto che lscpuriporta ID che non sono univoci in un livello superiore entità di livello ; ad esempio: 2 core diversi da 2 socket diversi potrebbero avere lo stesso ID).

Se salvi il codice sopra come, ad esempio, script di shellcpus , rendilo eseguibile con chmod +x cpuse lo inserisci nella cartella nella tua $PATH, vedrai un output come il seguente:

$ cpus
logical  4
physical 4

^{[1] Xaekai fa luce su cosa sia un libro : "un libro è un modulo che ospita un circuito stampato con prese CPU, prese RAM, connessioni IO lungo il bordo e un gancio per l'integrazione del sistema di raffreddamento. Sono utilizzati nei mainframe IBM Ulteriori informazioni: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf "}

lscpu raccoglie il modulo di informazioni sull'architettura della CPU / proc / cpuinfon in formato leggibile dall'uomo:

# 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

Vedi anche /unix/468766/understanding-output-of-lscpu .

Questo ha funzionato per me. tail -nXti permette di afferrare solo le ultime X linee.

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

Se hai hyperthreading, questo dovrebbe funzionare per afferrare il numero di core fisici .

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

Per il numero totale di core fisici:

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

Su macchine con più socket (o sempre), moltiplicare il risultato sopra per il numero di socket:

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

@ mklement0 ha una bella risposta sotto usando lscpu. Ho scritto una versione più concisa nei commenti

Puoi anche usare Python! Per ottenere il numero di core fisici:

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

Per ottenere il numero di core hyperthreaded:

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

Soluzione multipiattaforma per Linux, MacOS, Windows:

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

Ecco il modo in cui uso per contare il numero di core fisici che sono online su Linux:

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

o in breve:

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

Esempio (1 presa):

> 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

Esempio (2 prese):

> 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

Esempio (4 prese):

> 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

L'uso di getconf è effettivamente il modo più portatile, tuttavia la variabile ha nomi diversi in BSD e Linux per getconf, quindi è necessario testare entrambi, come suggerisce questa sintesi: https://gist.github.com/jj1bdx/5746298 (include anche una correzione di Solaris usando ksh)

Personalmente uso:

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

E se lo vuoi in Python puoi semplicemente usare syscall che getconf usa importando il modulo os:

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

Per quanto riguarda nproc, fa parte di GNU Coreutils, quindi non disponibile in BSD per impostazione predefinita. Utilizza sysconf () anche dopo alcuni altri metodi.

Se vuoi farlo in modo che funzioni su Linux e OS X, puoi fare:

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

È molto semplice. Usa questo comando:

lscpu

È possibile utilizzare uno dei seguenti metodi per determinare il numero di core fisici della CPU.

• Contare il numero di ID core univoci (approssimativamente equivalenti a grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l).

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

• Moltiplicare il numero di "core per socket" per il numero di socket.

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

• Contare il numero di CPU logiche univoche utilizzate dal kernel Linux. L' -popzione genera output per un facile analisi ed è compatibile con le versioni precedenti di lscpu.

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

Solo per ribadire ciò che altri hanno detto, ci sono un certo numero di proprietà correlate.

Per determinare il numero di processori disponibili:

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

Per determinare il numero di unità di elaborazione disponibili (non necessariamente uguale al numero di core). Questo è consapevole dell'hyperthreading.

nproc

Non voglio andare troppo lontano nella tana del coniglio, ma puoi anche determinare il numero di processori configurati (al contrario dei processori semplicemente disponibili / online) tramite getconf _NPROCESSORS_CONF. Per determinare il numero totale di CPU (offline e online) di cui si desidera analizzare l'output lscpu -ap.

Ho anche pensato di cat /proc/cpuinfodarmi la risposta corretta, tuttavia di recente ho visto che il mio sistema Cortex A53 quad core ARM mostrava solo un singolo core. Sembra che / proc / cpuinfo mostri solo i core attivi, mentre:

cat /sys/devices/system/cpu/present

è una misura migliore di ciò che c'è. Puoi anche

cat /sys/devices/system/cpu/online

per vedere quali core sono online e

cat /sys/devices/system/cpu/offline

per vedere quali core sono offline. I online, offlinee presentsysfs voci restituiscono l'indice delle CPU, quindi un valore restituito di 0mezzi solo nucleo 0, mentre un valore di ritorno di 1-3mezzi nuclei 1,2 e 3.

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

Quanto segue dovrebbe fornire il numero di core "reali" su un sistema sia hyperthreaded che non hyperthreaded. Almeno ha funzionato in tutti i miei test.

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

Non è la mia pagina web, ma questo comando di http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 funziona bene per me su Centos. Mostrerà l'effettivo cpus anche quando l'hyperthreading è abilitato.

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

Conta "ID core" per il metodo "ID fisico" usando awk con il conteggio del "processore" se "ID core" non è disponibile (come raspberry)

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

Questo ha funzionato bene. Quando ho provato la prima risposta ho ottenuto 3 CPU come output. So di avere 4 CPU sul sistema, quindi ho appena fatto un grepprocessore per e l'output è simile al seguente:

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

 dmidecode  | grep -i cpu | grep Version

mi da

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

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

Che è il conteggio corretto dei socket - guardando in alto E5-2667mi dice che ogni socket ha 8 cores, quindi moltiplica e finisci con 16 coresacross 2 sockets.

Dove lscpumi dia 20 CPUs- il che è totalmente errato - non so perché. (lo stesso vale per cat /proc/cpu- finisce con 20.

Più veloce, senza forcella

Questo lavoro con quasi tutti conchiglia.

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

Per rimanere compatibile con conchiglia, trattino, busyboxe altri, ho usato al ncore=$((ncore+1))posto di ((ncore++)).

bash versione

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

Se va bene che puoi usare Python, allora il numexprmodulo ha una funzione per questo:

In [5]: import numexpr as ne

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

anche questo:

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

Per richiedere queste informazioni dal prompt dei comandi, utilizzare:

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

O semplicemente è possibile ottenere queste informazioni dalla multiprocessing.cpu_count()funzione

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

O ancora più semplicemente usare os.cpu_count()

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

Se vuoi solo contare i nuclei fisici, questo comando l'ha fatto per me.

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

Abbastanza semplice, ma sembra contare i nuclei fisici reali, ignorando il conteggio logico

Python 3 offre anche alcuni semplici modi per ottenerlo:

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

4

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

4

Utilizzare la query seguente per ottenere i dettagli principali

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

Riepilogo: per ottenere CPU fisiche, procedere come segue:

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

per ottenere CPU fisiche e logiche , procedere come segue:

grep -c ^processor /proc/cpuinfo

/proc << questa è la fonte d'oro di ogni informazione che ti serve sui processi e

/proc/cpuinfo << è la fonte d'oro di qualsiasi informazione sulla CPU.