¿Cómo saber el número de núcleos de un sistema en Linux?

Para obtener una imagen completa, debe mirar el número de hilos por núcleo, núcleos por zócalo y zócalos . Si multiplica estos números, obtendrá el número de CP en su sistema.

CPU = Subprocesos por núcleo X núcleos por socket X sockets

Las CPU son lo que ve cuando ejecuta htop (estas no equivalen a CPU físicas).

Aquí hay un ejemplo de una máquina de escritorio:

$ lscpu | grep -E '^Thread|^Core|^Socket|^CPU\('
CPU(s):                8
Thread(s) per core:    2
Core(s) per socket:    4
Socket(s):             1

Y un servidor:

$ lscpu | grep -E '^Thread|^Core|^Socket|^CPU\('
CPU(s):                32
Thread(s) per core:    2
Core(s) per socket:    8
Socket(s):             2

La salida de nproc corresponde al recuento de CPU de lscpu. Para la máquina de escritorio anterior, esto debería coincidir con las 8 CPU (s) informadas por lscpu:

$ nproc --all
8

La salida de /proc/cpuinfo Debe coincidir con esta información, por ejemplo, en el sistema de escritorio anterior, podemos ver que hay 8 procesadores (CPU) y 4 núcleos (core id 0-3):

$ grep -E 'processor|core id' /proc/cpuinfo
processor   : 0
core id     : 0
processor   : 1
core id     : 0
processor   : 2
core id     : 1
processor   : 3
core id     : 1
processor   : 4
core id     : 2
processor   : 5
core id     : 2
processor   : 6
core id     : 3
processor   : 7
core id     : 3

El cpu cores Informado por /proc/cpuinfo Corresponde a la Core(s) per socket informada por lscpu. Para la máquina de escritorio anterior, esto debe coincidir con los 4 núcleos por socket informados por lscpu:

$ grep -m 1 'cpu cores' /proc/cpuinfo
cpu cores   : 4

Para responder específicamente a su pregunta, diga cuántos núcleos tiene multiplicando la cantidad de núcleos que tiene por zócalo por la cantidad de zócalos que tiene.

Núcleos = Núcleos por socket X Zócalos

Para los sistemas de ejemplo sobre el escritorio tiene 4 núcleos:

$ echo "Cores = $(( $(lscpu | awk '/^Socket\(s\)/{ print $2 }') * $(lscpu | awk '/^Core\(s\) per socket/{ print $4 }') ))"
Cores = 4

Mientras el servidor tiene 16:

$ echo "Cores = $(( $(lscpu | awk '/^Socket\(s\)/{ print $2 }') * $(lscpu | awk '/^Core\(s\) per socket/{ print $4 }') ))"
Cores = 16

Otra utilidad útil es dmidecode que genera información por socket. En el caso del sistema de servidor mencionado anteriormente, esperamos ver 8 núcleos por socket y 16 hilos por socket:

$ Sudo dmidecode -t 4 | grep -E 'Socket Designation|Count'
    Socket Designation: CPU1
    Core Count: 8
    Thread Count: 16
    Socket Designation: CPU2
    Core Count: 8
    Thread Count: 16

El comando lscpu tiene una serie de opciones útiles que puede consultar, por ejemplo:

$ lscpu --all --extended
$ lscpu --all --parse=CPU,SOCKET,CORE | grep -v '^#'

Ver man lscpu Para más detalles.

En resumen:

• Debe tener en cuenta los enchufes, núcleos e hilos
• Debe tener cuidado con el término CPU, ya que significa diferentes cosas en diferentes contextos.

Puede obtener esta información mediante nproc(1) command

$ nproc --all
12

No requiere privilegios de root.

Para que la respuesta no sea confusa, debe comprender un par de conceptos simples de arquitectura de computadora:

• Ejecuta procesos ("programas") en su sistema Linux. Cada proceso consta de uno o más hilos
• Cada hilo es una secuencia separada de instrucciones. Se pueden ejecutar dos hilos en paralelo.
• Cada instrucción se entrega a una CPU CPU para ser ejecutada. Una CPU tiene una lógica que determina qué significan los bits de una instrucción y decide qué hacer con ella.

• Hay diferentes tipos de instrucciones. La lógica de decisión dentro de una CPU enviará las diferentes instrucciones a diferentes nidades de hardware. Por ejemplo, las instrucciones aritméticas en realidad son ejecutadas por un ALU (unidad aritmética/lógica), mientras que las instrucciones que cargan/almacenan de la memoria son ejecutadas por algún tipo de - nidad de memoria.

• Un núcleo se refiere a un conjunto de hardware de ejecución real (es decir, cada núcleo tiene una ALU, una unidad de memoria, etc.)

• Puede tener múltiples CPU que compartan un núcleo, esto se llama hyperthreading.

  • La idea: el hilo A actualmente está haciendo aritmética, mientras que el hilo B está cargando algo de la memoria. Cuando eso es cierto, los hilos A y B pueden compartir eficientemente un solo núcleo sin interferir entre sí (A usa la ALU, B usa la unidad de memoria). Por supuesto, a veces ambos programas querrán la ALU, y luego tendrán que esperar el uno al otro ...

• A socket es la ranura física en la placa base en la que se inserta un chip. Este chip tiene una cierta cantidad de núcleos.

Ejemplos:

El ejemplo del OP:

CPU(s):                4
Thread(s) per core:    1
Core(s) per socket:    4
Socket(s):             1

• un zócalo físico, que contiene un chip con
• 4 núcleos físicos (piense 4 ALU y 4 unidades de memoria en total)
• Solo 1 hilo puede emitir instrucciones a un núcleo (sin hyperthreading), lo que significa que hay
• una CPU por núcleo, o 4 * 1 = 4 CPU

Otro ejemplo:

CPU(s):                16
Thread(s) per core:    2
Core(s) per socket:    4
Socket(s):             2

Dos enchufes físicos, cada uno con un chip con 4 núcleos físicos, lo que hace un total de 8 núcleos. Dos subprocesos emiten instrucciones para cada núcleo (esta máquina tiene hyperthreading), lo que significa que debe haber dos CPU conectadas a cada núcleo, lo que hace un total de 8 * 2 = 16 CPU

La primera máquina puede ejecutar con precisión cuatro instrucciones en un momento determinado, período. La segunda máquina puede ejecutar entre 8 y 16 instrucciones en cualquier momento dado: 16 se lograrán solo cuando cada par de CPU ejecute diferentes tipos de instrucciones y, por lo tanto, puedan compartir un núcleo sin esperar.

También puedes usar el comando cat /proc/cpuinfo que generará una porción de datos para cada núcleo. Cada fragmento comienza con esta información:

processor   : 3
vendor_id   : GenuineIntel
cpu family  : 6
model       : 60
model name  : Intel(R) Core(TM) i5-4210M CPU @ 2.60GHz
(...)

Los núcleos están numerados a partir de 0, por lo que si el último fragmento dice processor : 3 como en este caso, su máquina tiene 4 núcleos.

getconf _NPROCESSORS_ONLN

(getconf es parte de glibc)

$ grep -c processor /proc/cpuinfo
8

Eso es todo lo que necesitas. Es el número de núcleos en línea, independientemente de si hyperthreading está activado o desactivado.

$ ls -d /sys/devices/system/cpu/cpu* | wc -l
8

Otra forma fácil.

[[email protected] ~]#  dmidecode -t 4 | egrep -i "Designation|Intel|core|thread"
    Socket Designation: CPU1
    Manufacturer: Intel
            HTT (Multi-threading)
    Version: Intel(R) Xeon(R) CPU           L5640  @ 2.27GHz
    Core Count: 6
    Core Enabled: 6
    Thread Count: 12
    Socket Designation: CPU2
    Manufacturer: Intel
            HTT (Multi-threading)
    Version: Intel(R) Xeon(R) CPU           L5640  @ 2.27GHz
    Core Count: 6
    Core Enabled: 6
    Thread Count: 12

Encontré de esta manera:

echo $((`cat /sys/devices/system/cpu/present | sed 's/0-//'` + 1))

Solo quiero agregar información a la respuesta de @htaccess.

En CentOS 6.x, dmidecode no genera información de conteo de Core/Thread, y en realidad considera 'CPU' como 'CPU' o 'Core' en lscpu, no 'socket'.