¿Cómo obtener el número de CPU / núcleos en Linux desde la línea de comandos?

Tengo este script, pero no sé cómo obtener el último elemento en la impresión:

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

El último elemento debe ser el número de CPU, menos 1.

grep -c ^processor /proc/cpuinfo     

contará el número de líneas que comienzan con "procesador" en /proc/cpuinfo

Para sistemas con hiperprocesamiento, puede usar

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

que debería regresar (por ejemplo) 8(mientras que el comando anterior volvería 16)

Procesar los contenidos de /proc/cpuinfoes innecesariamente barroco. Utilice nproc, que forma parte de coreutils, por lo que debería estar disponible en la mayoría de las instalaciones de Linux.

Command nprocimprime la cantidad de unidades de procesamiento disponibles para el proceso actual, que puede ser menor que la cantidad de procesadores en línea.

Para encontrar el número de todos los núcleos / procesadores instalados, use nproc --all

En mi máquina de 8 núcleos:

$ nproc --all
8

La solución más portátil que he encontrado es el getconfcomando:

getconf _NPROCESSORS_ONLN

Esto funciona tanto en Linux como en Mac OS X. Otro beneficio de esto sobre algunos de los otros enfoques es que getconf ha existido durante mucho tiempo. Algunas de las máquinas Linux más antiguas en las que tengo que hacer desarrollo no tienen los comandos nproco lscpudisponibles, pero los tienen getconf.

^{Nota del editor: Si bien la getconf utilidad es un mandato POSIX , los valores específicos _NPROCESSORS_ONLNy no lo son. Dicho esto, como se dijo, funcionan en plataformas Linux y en macOS; en FreeBSD / PC-BSD, debe omitir el líder ._NPROCESSORS_CONF _}

Prefacio:

• El problema con las /proc/cpuinforespuestas basadas es que analizan la información destinada al consumo humano y, por lo tanto, carece de un formato estable diseñado para el análisis de la máquina : el formato de salida puede diferir entre plataformas y condiciones de tiempo de ejecución; el uso lscpu -pen Linux (y sysctlen macOS) evita ese problema .

• getconf _NPROCESSORS_ONLN/ getconf NPROCESSORS_ONLNno distingue entre CPU lógicas y físicas .

Aquí hay un shfragmento (compatible con POSIX) que funciona en Linux y macOS para determinar el número de CPU físicas o lógicas en línea ; ver los comentarios para más detalles.

Usos lscpupara Linux y sysctlpara macOS.

Nota de terminología : CPU se refiere a la unidad de procesamiento más pequeña vista por el sistema operativo. Los núcleos sin hiperprocesamiento corresponden a 1 CPU, mientras que los núcleos con hiperprocesamiento contienen más de 1 (normalmente: 2) - lógica - CPU.
Linux usa la siguiente taxonomía ^[1] , comenzando con la unidad más pequeña:
CPU < núcleo < socket < libro < nodo
con cada nivel que comprende 1 o más instancias del siguiente nivel inferior.

#!/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] documentación de macOSsysctl (3)

Tenga en cuenta que los sistemas derivados de BSD que no sean macOS, por ejemplo, FreeBSD, solo admiten la hw.ncpuclave sysctl, que están en desuso en macOS; Estoy claro de cuál de las nuevas claves hw.npucorresponde a: hw.(logical|physical)cpu_[max].

^{Punta del sombrero a @teambob para ayudar a corregir el lscpucomando físico-CPU-count .}

Advertencia : la lscpu -psalida NO incluye una columna de "libro" (la manpágina menciona "libros" como una entidad entre el socket y el nodo en la jerarquía taxonómica). Si hay "libros" en juego en un sistema Linux dado ( ¿alguien sabe cuándo y cómo? ), El comando físico-CPU-count puede estar bajo- informe (esto se basa en la suposición de que lscpuinforma ID que no son únicos en los niveles superiores) entidades de nivel ; por ejemplo: 2 núcleos diferentes de 2 zócalos diferentes podrían tener la misma ID).

Si guarda el código anterior como, por ejemplo, script de shellcpus , lo hace ejecutable chmod +x cpusy lo coloca en la carpeta en su $PATH, verá resultados como los siguientes:

$ cpus
logical  4
physical 4

^{[1] Xaekai arroja luz sobre lo que es un libro : "un libro es un módulo que aloja una placa de circuito con zócalos de CPU, zócalos de RAM, conexiones de E / S a lo largo del borde y un gancho para la integración del sistema de refrigeración. Se utilizan en los mainframes de IBM Más información: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf "}

lscpu reúne el formulario de información de arquitectura de CPU / proc / cpuinfon en formato de lectura humana:

# 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

Consulte también /unix/468766/understanding-output-of-lscpu .

Esto funcionó para mí. tail -nXle permite tomar solo las últimas X líneas.

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

Si tiene hyperthreading, esto debería funcionar para obtener el número de núcleos físicos .

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

Para el número total de núcleos físicos:

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

En máquinas con múltiples sockets (o siempre), multiplique el resultado anterior por el número de sockets:

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

@ mklement0 tiene una buena respuesta a continuación usando lscpu. He escrito una versión más sucinta en los comentarios.

¡También puedes usar Python! Para obtener la cantidad de núcleos físicos:

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

Para obtener el número de núcleos hiperprocesados:

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

Solución de plataforma cruzada para Linux, MacOS, Windows:

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

Esta es la forma en que uso para contar la cantidad de núcleos físicos que están en línea en Linux:

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

o en resumen:

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

Ejemplo (1 zócalo):

> 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

Ejemplo (2 enchufes):

> 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

Ejemplo (4 enchufes):

> 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

El uso de getconf es de hecho la forma más portátil, sin embargo, la variable tiene diferentes nombres en BSD y Linux para getconf, por lo que debe probar ambos, como sugiere esta esencia: https://gist.github.com/jj1bdx/5746298 (también incluye una solución de Solaris usando ksh)

Yo personalmente uso:

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

Y si desea esto en Python, puede usar el syscall getconf utiliza importando el módulo os:

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

En cuanto a nproc, es parte de GNU Coreutils, por lo que no está disponible en BSD por defecto. Utiliza sysconf () también después de algunos otros métodos.

Si desea hacer esto para que funcione en Linux y OS X, puede hacer lo siguiente:

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

Es muy simple. Solo usa este comando:

lscpu

Puede usar uno de los siguientes métodos para determinar la cantidad de núcleos físicos de CPU.

• Cuente la cantidad de identificadores principales únicos (aproximadamente equivalentes a grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l).

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

• Multiplique el número de 'núcleos por socket' por el número de sockets.

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

• Cuente la cantidad de CPU lógicas únicas que utiliza el kernel de Linux. La -popción genera resultados para un análisis fácil y es compatible con versiones anteriores de lscpu.

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

Solo para reiterar lo que otros han dicho, hay una serie de propiedades relacionadas.

Para determinar la cantidad de procesadores disponibles:

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

Para determinar la cantidad de unidades de procesamiento disponibles (no necesariamente la misma que la cantidad de núcleos). Esto es consciente de hyperthreading.

nproc

No quiero ir demasiado lejos por la madriguera del conejo, pero también puede determinar la cantidad de procesadores configurados (a diferencia de los procesadores simplemente disponibles / en línea) a través de getconf _NPROCESSORS_CONF. Para determinar el número total de CPU (fuera de línea y en línea) de las que desea analizar la salida lscpu -ap.

También pensé cat /proc/cpuinfoque me daría la respuesta correcta, sin embargo, recientemente vi que mi sistema ARM de cuatro núcleos Cortex A53 solo mostraba un solo núcleo. Parece que / proc / cpuinfo solo muestra los núcleos activos, mientras que:

cat /sys/devices/system/cpu/present

es una mejor medida de lo que hay allí. Tú también puedes

cat /sys/devices/system/cpu/online

para ver qué núcleos están en línea, y

cat /sys/devices/system/cpu/offline

para ver qué núcleos están fuera de línea. Los online, offliney presentSYSFS entradas devuelven el índice de la CPU, así que un valor de retorno de 0sólo significa núcleo 0, mientras que un valor de retorno de1-3 medios núcleos de 1,2, y 3.

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

Lo siguiente debería proporcionarle el número de núcleos "reales" en un sistema con y sin subproceso. Al menos funcionó en todas mis pruebas.

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

No es mi página web, pero este comando de http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 me funciona muy bien en centos. Mostrará cpus real incluso cuando hyperthreading esté habilitado.

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

Cuente la "identificación del núcleo" por método de "identificación física" utilizando awk con el recuento del "procesador" si la "identificación del núcleo" no está disponible (como frambuesa)

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

Esto funcionó bien. Cuando probé la primera respuesta, obtuve 3 CPU como salida. Sé que tengo 4 CPU en el sistema, así que acabo de hacer un grepprocesador y la salida se ve así:

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

 dmidecode  | grep -i cpu | grep Version

me da

Versión: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Versión: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Cuál es el recuento correcto de zócalos: al buscar E5-2667me dice que cada zócalo tiene 8 cores, así que multiplique y termine16 cores cruzado 2 sockets.

Dónde lscpudarme 20 CPUs, que es totalmente incorrecto, no estoy seguro de por qué. (lo mismo vale para cat /proc/cpu- termina con 20.

Más rápido, sin tenedor.

Este trabajo con casi todos cáscara.

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

Para seguir siendo compatible con cáscara, guión, busyboxy otros, que he usado ncore=$((ncore+1))en lugar de ((ncore++)).

golpetazo versión

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

Si está bien que pueda usar Python, entonces el numexprmódulo tiene una función para esto:

In [5]: import numexpr as ne

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

también esto:

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

Para consultar esta información desde el símbolo del sistema, use:

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

O simplemente es posible obtener esta información de la multiprocessing.cpu_count()función

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

O incluso más, simplemente use os.cpu_count()

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

Si solo quieres contar núcleos físicos, este comando lo hizo por mí.

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

Bastante básico, pero parece contar núcleos físicos reales, ignorando el recuento lógico

Python 3 también proporciona algunas formas simples de obtenerlo:

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

4 4

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

4 4

Use la consulta a continuación para obtener detalles básicos

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

Resumen: para obtener CPU físicas, haga esto:

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

para obtener CPU físicas y lógicas haga esto:

grep -c ^processor /proc/cpuinfo

/proc << esta es la fuente de oro de cualquier información que necesite sobre procesos y

/proc/cpuinfo << es la fuente de oro de cualquier información de CPU.