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

ver caracteristicas de mi pc linux centos

Question

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.

Answer 1

Más rápido, sin horquilla.

Este trabajo con casi todas las shell .

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

Para mantener la compatibilidad 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 </proc/cpuinfo
echo $ncore
4

Answer 2

¡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

Answer 3

Cuente el "id de núcleo" por el método de "id físico" usando awk con un retroceso en el conteo de "procesador" si "id de núcleo" no está disponible (como la 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)

Answer 4

El procesamiento de 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 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

Answer 5

Esta es la forma que utilizo 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 pocas palabras:

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

Answer 6

Este comando:

echo $(nproc)

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

Answer 7

Esto funcionó para mí. tail -nX te permite agarrar solo las ultimas X lineas.

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

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

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

Answer 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 por 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 la utilidad getconf es obligatoria para POSIX , los _NPROCESSORS_ONLN específicos _NPROCESSORS_ONLN y _NPROCESSORS_CONF no lo son. Dicho esto, como se dijo, funcionan en plataformas Linux así como en macOS; en FreeBSD / PC-BSD, debe omitir el _ principal.}

Answer 9

Lo siguiente debería proporcionarle la cantidad de núcleos "reales" en un sistema de subprocesamiento hiper y sin hilos. 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

Answer 10

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 bien para mí en centos. Mostrará las CPU reales incluso cuando el subproceso está habilitado.

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

Answer 11

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.

Answer 12

Prefacio:

• El problema con las respuestas basadas en /proc/cpuinfo 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 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 de código 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 ; Vea 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. Cada uno de los núcleos no de subprocesamiento corresponde a 1 CPU, mientras que los núcleos de subproceso contienen más de 1 (normalmente: 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 que comprende 1 o más instancias del siguiente nivel inferior.
Mi conocimiento es un tanto inestable aquí. Déjame saber si estoy equivocado. ¿Alguien sabe qué 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 - 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] macOS sysctl (3) documentación

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 en desuso en macOS; No tengo claro cuál de las nuevas claves hw.npu corresponde a: hw.(logical|physical)cpu_[max] .

^{Sugerencia del sombrero a @teambob para ayudar a corregir el comando físico-CPU-count lscpu .}

Advertencia : la salida de lscpu -p NO incluye una columna de "libro" (la página de man menciona "libros" como una entidad entre el zócalo y el nodo en la jerarquía taxonómica). Si hay "libros" en juego en un sistema Linux determinado ( ¿alguien sabe cuándo y cómo? ), El comando físico-CPU-count puede ser un informe bajo (esto se basa en el supuesto de que lscpu informa los ID que no son únicos en entidades de nivel superior , por ejemplo: 2 núcleos diferentes de 2 sockets diferentes podrían tener la misma ID).

Si guarda el código anterior como, por ejemplo, shell script cpus , cpus ejecutable con chmod +x cpus y colóquelo en la carpeta en su $PATH , verá resultados como los siguientes:

$ cpus
logical  4
physical 4

Answer 13

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

• Cuente el número de grep -P ''^core id/t'' /proc/cpuinfo | sort -u | wc -l de núcleo único (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 kernel de Linux. La opción -p 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 el número 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 hiper-threading-consciente.

nproc

No quiero ir demasiado lejos por el agujero de 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), querría analizar la salida de lscpu -ap .

Answer 14

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

Answer 15

Si está bien que puedas 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

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

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

Answer 16

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)

Answer 17

Solución multiplataforma para Linux, MacOS, Windows:

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

Answer 18

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 este gist: https://gist.github.com/jj1bdx/5746298 (también incluye una corrección de Solaris utilizando ksh)

Yo personalmente uso:

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

Y si quieres esto en Python, solo puedes usar el syscall que usa getconf 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.

Answer 19

lscpu recopila la información de la arquitectura de la CPU de / proc / cpuinfon en formato legible por humanos:

# 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

Answer 20

 dmidecode  | grep -i cpu | grep Version

me da

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

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

¿Cuál es el recuento correcto de zócalos? Al buscar el E5-2667 , cada zócalo 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 .

Answer 21

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

Answer 22

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 hice un grep para el procesador y la salida tenía este aspecto:

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