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

Procesar el contenido de /proc/cpuinfo es innecesariamente barroco. Uso nproc que es parte de coreutils, por lo que debería estar disponible en la mayoría de las instalaciones de Linux.

El comando nproc imprime el número de unidades de procesamiento disponibles para el proceso actual, que puede ser menor que el número 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 comando getconf:

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 desarrollar no tienen los comandos nproc o lscpu disponibles, pero tienen getconf.

^{Nota del editor: Mientras que el getconf utilidad es POSIX-mandated , el específico _NPROCESSORS_ONLN y _NPROCESSORS_CONF los valores no lo son. Dicho esto, como se ha dicho, funcionan en plataformas Linux, así como en macOS; en FreeBSD/PC-BSD, debe omitir el encabezado _.}

Prefacio:

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

• getconf _NPROCESSORS_ONLN / getconf NPROCESSORS_ONLN no distingue entre lógico y CPUs físicas .

Aquí hay un fragmento sh (compatible con POSIX) que funciona en Linux y macOS para determinar el número de cpu-online - lógicas o físicas; consulte los comentarios para obtener más detalles.

Usa lscpu para Linux, y sysctl para macOS.

Nota terminológica: CPU se refiere a la unidad de procesamiento más pequeña vista por el sistema operativo. Los núcleos no hyper-threading corresponden cada uno a 1 CPU, mientras que los núcleos hyper-threading contienen más de 1 (típicamente: 2) - CPU lógica.
Linux utiliza la siguiente taxonomía, comenzando con la unidad más pequeña: CPU core zócalo libro nodo, con cada nivel consta de 1 o más instancias del siguiente nivel inferior.
Mi conocimiento es algo inestable aquí-hágamelo saber si estoy equivocado. ¿Alguien sabe lo que es un "libro" en esto context ?

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

Tenga en cuenta que los sistemas derivados de BSD que no sean macOS-por ejemplo, FreeBSD - solo admiten la clave hw.ncpu para sysctl, que están obsoletos en macOS; no estoy claro cuál de las nuevas claves hw.npu corresponde a: hw.(logical|physical)cpu_[max].

^{Punta del sombrero a @teambob para ayudar a corregir el comando physical-CPU-count lscpu.}

Advertencia: lscpu -p la salida NO incluye una columna "libro" (el man page menciona "books" como una entidad entre socket y nodo en la jerarquía taxonómica). Si los "libros" están en juego en un sistema Linux dado ( ¿alguien sabe cuándo y cómo?), el comando physical-CPU-count puede bajo-report (esto se basa en la suposición de que lscpu informa ID que no son únicos a través de entidades de nivel superior; por ejemplo: 2 núcleos diferentes de 2 sockets diferentes podrían tener el mismo ID).

Esto funcionó para mí. tail -nX le permite agarrar 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

Lscpu reúne la información de la arquitectura de la CPU form / proc / cpuinfon en formato capaz 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

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

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

En máquinas de 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

Usar getconf es de hecho la forma más portátil, sin embargo, la variable tiene nombres diferentes en BSD y Linux para getconf, por lo que debe probar ambos, como sugiere este gist: 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 quieres esto en python puedes usar el syscall que getconf usa 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 predeterminado. También usa sysconf () después de otros métodos.

Solución Crossplatform para Linux, macOS, Windows:

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

Si quieres hacer esto para que funcione en linux y OS X, puedes hacer:

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

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

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

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

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

Lo siguiente debería darle el número de núcleos "reales" tanto en un sistema hyperthreaded como en un sistema no hyperthreaded. 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

Puede utilizar uno de los siguientes métodos para determinar el número de núcleos físicos de la CPU.

• Cuente el número de identificadores de núcleo únicos (aproximadamente equivalente 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 el número de CPU lógicas únicas utilizadas por el núcleo Linux. La opción -p genera salida 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 el número de procesadores disponibles:

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

Para determinar el número de unidades de procesamiento disponibles (no necesariamente el mismo que el número de núcleos). Esto es hyperthreading-aware.

nproc

No quiero ir demasiado lejos en la madriguera del conejo, pero también puede determinar el número 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) que desea analizar la salida de lscpu -ap.

Contar "core id" por el método "physical id" usando awk con respaldo en" processor "contar si" core id " no están disponibles (como 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)

Esta es la forma en que uso para contar el número 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 breve:

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

cat /proc/cpuinfo | grep processor

Esto funcionó bien. Cuando intenté la primera respuesta conseguí 3 CPU como la salida. Sé que tengo 4 CPU en el sistema, así que solo hice un grep para el procesador y la salida se veía así:

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

Más rápido, sin tenedor

Este trabajo con casi todos shell.

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

Con el fin De mantenerse compatible con shell, dash, busybox y demás, he usado ncore=$((ncore+1)) en lugar de ((ncore++)).

Bash version

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

Si está bien que puedas usar Python, entonces numexpr el mó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

Este comando:

echo $(nproc)

Debe devolver el número o núcleos disponibles para el sistema

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{[3]funciona muy bien para mí en Centos. Mostrará cpu reales 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

 dmidecode  | grep -i cpu | grep Version

Me da

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

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

Que es el conteo correcto de sockets - mirando hacia arriba el E5-2667 me dice que cada socket tiene 8 cores, así que multiplique y termine con 16 cores a través de 2 sockets.

Donde lscpu dame 20 CPUs - lo cual es totalmente incorrecto - no sé por qué. (lo mismo va para cat /proc/cpu - termina con 20.

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

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

4

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

4