¿Cómo obtener la cantidad de CPU / núcleos en Linux desde la línea de comando?

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 debería ser la cantidad de CPU, menos 1.

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

o simplemente

 grep -c ^processor /proc/cpuinfo 

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

Para sistemas con hiper-threading, puede usar

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

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

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

Command nproc imprime 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 la cantidad 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. Otra ventaja de esto sobre algunos de los otros enfoques es que getconf ha existido por mucho tiempo. Algunas de las máquinas Linux más antiguas en las que tengo que hacer desarrollo no tienen los comandos nproc o lscpu disponibles, pero tienen getconf .

Nota del editor: Si bien la utilidad getconf tiene el mandato POSIX , los _NPROCESSORS_ONLN específicos _NPROCESSORS_ONLN y _NPROCESSORS_CONF no lo son. Dicho esto, como se dijo, funcionan tanto en plataformas Linux como en macOS; en FreeBSD / PC-BSD, debe omitir el _ principal.

Prefacio:

  • El problema 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 automático : el formato de salida puede diferir según las plataformas y las condiciones de tiempo de ejecución; el uso de lscpu -p en Linux (y sysctl en macOS) evita ese problema .

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


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

Utiliza lscpu para Linux y sysctl para 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 que no son de hiper-threading corresponden a 1 CPU, mientras que los de hiper-threading contienen más de 1 (típicamente: 2) – lógico – CPU.
Linux usa la siguiente taxonomía, comenzando con la unidad más pequeña: CPU < core < socket < book < node , con cada nivel comprendiendo 1 o más instancias del siguiente nivel inferior.
Mi conocimiento es un poco inestable aquí. Háganme saber si estoy equivocado. ¿Alguien sabe lo que es un “libro” en este contexto ?

 #!/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 - ie, 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 < 

[1] documentación de macOS sysctl (3)

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

Consejo del sombrero a @teambob para ayudar a corregir el comando lscpu cómputo físico-CPU.

Advertencia : lscpu -p output NO incluye una columna de "libro" (la página de man menciona "libros" como una entidad entre socket y 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 de cómputo físico-CPU puede infrainformar (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 la misma ID).

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

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

Si tiene hyperthreading, esto debería funcionar para agarrar la cantidad de núcleos físicos .

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

lscpu reúne la forma de información de la architecture de la 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 

Para la cantidad total de núcleos físicos:

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

En máquinas de socket múltiple (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 debajo 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 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 corrección de Solaris usando ksh)

Yo personalmente uso:

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

Y si quiere 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.

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 desea hacer esto para que funcione en Linux y OS X, puede hacer:

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

¡También puedes usar Python! Para obtener la cantidad 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 la cantidad de núcleos “reales” tanto en un sistema hyperthreaded como 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 usar uno de los siguientes métodos para determinar la cantidad de núcleos de CPU físicos .

  • Cuente la cantidad 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 la cantidad de CPU lógicas únicas que usa el kernel de Linux. La opción -p genera resultados para un análisis sencillo 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 lo mismo que la cantidad de núcleos). Esto es hyperthreading-aware.

 nproc 

No quiero ir demasiado lejos en la madriguera, pero también puedes 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), le conviene analizar la salida de lscpu -ap .

Contar el “identificador de núcleo” por el método de “identificación física” usando awk con recuperación en el recuento de “procesador” si “id de núcleo” 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 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 
 cat /proc/cpuinfo | grep processor 

Esto funcionó bien. Cuando probé la primera respuesta obtuve 3 CPU como salida. Sé que tengo 4 CPUs 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 almsost todos los shell .

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

Para seguir siendo compatible con shell , dash , busybox y otros, he usado ncore=$((ncore+1)) lugar de ((ncore++)) .

versión bash

 ncore=0 while read -a line ;do [ "$line" = "processor" ] && ((ncore++)) done  

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

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 funciona muy bien para mí en centos. Mostrará la real cpus 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.20GHz

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

¿Cuál es el recuento de socket correcto? Mirar hacia arriba el E5-2667 me dice que cada socket tiene 8 cores , así que multiplique y termine con 16 cores en 2 sockets .

Donde lscpu me da 20 CPUs , lo cual es totalmente incorrecto, no estoy seguro de por qué. (Lo mismo ocurre con cat /proc/cpu – termina con 20 .

Este comando:

 echo $(nproc) 

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