Quería saber cuántos núcleos tiene mi sistema, así que busqué la misma pregunta en Google. Tengo algunos comandos como el lscpucomando. Cuando probé este comando, me dio el siguiente resultado:

$ lscpu
Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                4
On-line CPU(s) list:   0-3
Thread(s) per core:    1
Core(s) per socket:    4
Socket(s):             1
NUMA node(s):          1
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 23
Stepping:              10
CPU MHz:               1998.000
BogoMIPS:              5302.48
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              2048K
NUMA node0 CPU(s):     0-3

En particular, esta salida muestra:

• CPU (s): 4
• Núcleo (s) por zócalo: 4
• Familia de CPU: 6

¿Cuál de esos indica núcleos de un sistema Linux?

¿Hay algún otro comando para decir la cantidad de núcleos, o estoy asumiendo que está completamente equivocado?

Tienes que mirar los zócalos y los núcleos por zócalo. En este caso, tiene 1 CPU física (socket) que tiene 4 núcleos (núcleos por socket).

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

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

Las CPU son lo que ves cuando corres 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 nproccorresponde al recuento de CPU de lscpu. Para la máquina de escritorio anterior, esto debe coincidir con las 8 CPU informadas por lscpu:

$ nproc --all
8

La salida de /proc/cpuinfodebería 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 coresreportado por /proc/cpuinfocorresponde al Core(s) per socketreportado por lscpu. Para la máquina de escritorio anterior, esto debería 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 zócalo 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 dmidecodequé salidas por información de 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 lscpucomando tiene una serie de opciones útiles que puede consultar, por ejemplo:

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

Ver man lscpupara 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 por nproc(1)comando

$ 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:

• Ejecutas procesos ("programas") en tu 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 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 unidades de hardware . Por ejemplo, las instrucciones aritméticas son realmente realizadas por una ALU ( unidad aritmética / lógica), mientras que las instrucciones que cargan / almacenan desde la memoria son ejecutadas por algún tipo de unidad 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 ...

• Un zócalo 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 exactamente cuatro instrucciones en un momento dado, 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 puede usar el comando cat /proc/cpuinfoque 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 : 3como en este caso, su máquina tiene 4 núcleos.

getconf _NPROCESSORS_ONLN

(getconf es parte de glibc)

[root@xxxxx ~]#  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

$ 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.

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'.

La familia de CPU es irrelevante aquí.

• CPU (s) = tomas físicas
• Núcleo (s) por socket, como dice
• entonces número total de núcleos = CPU (s) * Núcleo (s) por socket

En su caso, tiene un total de 4 núcleos completos.

Lo que también puede ser importante es "Hilo (s) por núcleo". Pero tienes 1, así que no en tu caso.

Una forma sencilla de calcular la cantidad de CPU es emitiendo los siguientes comandos:

cat /proc/interrupts | egrep -i 'cpu'