Como obter o número de CPUs / núcleos no Linux na linha de comando?

Eu tenho esse script, mas não sei como obter o último elemento na impressão:

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

O último elemento deve ser o número de CPUs, menos 1.

grep -c ^processor /proc/cpuinfo     

contará o número de linhas começando com "processador" em /proc/cpuinfo

Para sistemas com hiperencadeamento, você pode usar

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

que deve retornar (por exemplo) 8(enquanto o comando acima retornaria 16)

O processamento do conteúdo /proc/cpuinfoé desnecessariamente barroco. Use o nproc, que faz parte do coreutils, para que ele esteja disponível na maioria das instalações do Linux.

O comando nprocimprime o número de unidades de processamento disponíveis para o processo atual, que pode ser menor que o número de processadores online.

Para encontrar o número de todos os núcleos / processadores instalados, use nproc --all

Na minha máquina de 8 núcleos:

$ nproc --all
8

A solução mais portátil que encontrei é o getconfcomando:

getconf _NPROCESSORS_ONLN

Isso funciona no Linux e no Mac OS X. Outro benefício disso em relação a outras abordagens é que o getconf existe há muito tempo. Algumas das máquinas Linux mais antigas nas quais tenho que fazer desenvolvimento não têm os comandos nprocou lscpudisponíveis, mas eles têm getconf.

^{Nota do editor: Embora o getconf utilitário seja obrigatório para POSIX , o específico _NPROCESSORS_ONLNe os _NPROCESSORS_CONF valores não são. Dito isto, como afirmado, eles funcionam em plataformas Linux e no macOS; no FreeBSD / PC-BSD, você deve omitir o líder _.}

Prefácio:

• O problema com as /proc/cpuinforespostas baseadas é que elas analisam informações destinadas ao consumo humano e, portanto, não possuem um formato estável projetado para análise de máquinas : o formato de saída pode diferir entre plataformas e condições de tempo de execução; o uso lscpu -pno Linux (e sysctlno macOS) contorna esse problema .

• getconf _NPROCESSORS_ONLN/ getconf NPROCESSORS_ONLNnão faz distinção entre CPUs lógicas e físicas .

Aqui está um shtrecho (compatível com POSIX) que funciona no Linux e macOS para determinar o número de CPUs físicas ou lógicas - online ; veja os comentários para detalhes.

Usa lscpupara Linux e sysctlpara macOS.

Nota sobre terminologia : CPU refere-se à menor unidade de processamento, conforme visto pelo sistema operacional. Cada um dos núcleos sem hiper-threading corresponde a 1 CPU, enquanto os núcleos com hiper-threading contêm mais de 1 (normalmente: 2) - lógica - CPU.
O Linux usa a seguinte taxonomia ^[1] , começando com a menor unidade: nó
CPU < núcleo < soquete < livro <, com cada nível compreendendo 1 ou mais instâncias do próximo nível inferior.

#!/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] documentação do macOSsysctl (3)

Observe que outros sistemas derivados do BSD que não o macOS - por exemplo, FreeBSD - suportam apenas a hw.ncpuchave sysctl, que está obsoleta no macOS; Eu sou incerto sobre qual das novas chaves hw.npucorresponde a: hw.(logical|physical)cpu_[max].

^{Dica para o @teambob por ajudar a corrigir o lscpucomando físico-CPU-count .}

Advertência : a lscpu -psaída NÃO inclui uma coluna "livro" (a manpágina menciona "livros" como uma entidade entre o soquete e o nó na hierarquia taxonômica). Se "livros" estão em jogo em um determinado sistema Linux ( alguém sabe quando e como? ), O comando-CPU-contagem física pode sob -report (isto é baseado na suposição de que lscpurelatórios IDs que são não-exclusivo através maior entidades de nível superior ; por exemplo: 2 núcleos diferentes de 2 soquetes diferentes podem ter o mesmo ID).

Se você salvar o código acima como, digamos, shell scriptcpus , torná-lo executável chmod +x cpuse colocá-lo na pasta $PATH, verá uma saída como a seguinte:

$ cpus
logical  4
physical 4

^{[1] Xaekai esclarece o que é um livro : "um livro é um módulo que abriga uma placa de circuito com soquetes de CPU, soquetes de RAM, conexões de E / S ao longo da borda e um gancho para integração do sistema de refrigeração. Eles são usados ​​nos mainframes da IBM Mais informações: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf "}

lscpu reúne o formulário de informações da arquitetura da CPU / proc / cpuinfon no formato legível 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

Veja também /unix/468766/understanding-output-of-lscpu .

Isso funcionou para mim. tail -nXpermite que você pegue apenas as últimas X linhas.

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

Se você tem hyperthreading, isso deve funcionar para capturar o número de núcleos físicos .

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

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

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

Em máquinas com vários soquetes (ou sempre), multiplique o resultado acima pelo número de soquetes:

echo $(($(grep "^physical id" /proc/cpuinfo | awk '{print $4}' | sort -un | tail -1)+1))

@ mklement0 tem uma boa resposta abaixo usando lscpu. Eu escrevi uma versão mais sucinta nos comentários

Você também pode usar o Python! Para obter o número de núcleos físicos:

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

Para obter o número de núcleos com hyperthread:

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

Solução de plataforma cruzada para Linux, MacOS, Windows:

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

Aqui está a maneira que eu uso para contar o número de núcleos físicos que estão online no Linux:

lscpu --online --parse=Core,Socket | grep --invert-match '^#' | sort --unique | wc --lines

ou em resumo:

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

Exemplo (1 soquete):

> lscpu
...
CPU(s):                28
Thread(s) per core:    2
Core(s) per socket:    14
Socket(s):             1
....
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
14

Exemplo (2 tomadas):

> lscpu
...
CPU(s):                56
Thread(s) per core:    2
Core(s) per socket:    14
Socket(s):             2
...
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
28

Exemplo (4 tomadas):

> lscpu
...
CPU(s):                64
Thread(s) per core:    2
Core(s) per socket:    8
Socket(s):             4
...
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
32

Usar o getconf é realmente a maneira mais portátil, no entanto, a variável tem nomes diferentes no BSD e no Linux para obter o getconf; portanto, você deve testar os dois, conforme sugere esta essência: https://gist.github.com/jj1bdx/5746298 (também inclui uma correção do Solaris usando o ksh)

Eu pessoalmente uso:

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

E se você quiser isso em python, você pode simplesmente usar o syscall getconf, importando o módulo os:

$ python -c 'import os; print os.sysconf(os.sysconf_names["SC_NPROCESSORS_ONLN"]);'

Quanto a nproc , faz parte do GNU Coreutils, portanto não está disponível no BSD por padrão. Ele usa sysconf () também após alguns outros métodos.

Se você quiser fazer isso para que ele funcione no linux e no OS X, você pode:

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

É muito simples. Basta usar este comando:

lscpu

Você pode usar um dos seguintes métodos para determinar o número de núcleos físicos da CPU.

• Conte o número de IDs principais exclusivos (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 o número de 'núcleos por soquete' pelo número de soquetes.

  lscpu | awk '/^Core\(s\) per socket:/ {cores=$NF}; /^Socket\(s\):/ {sockets=$NF}; END{print cores*sockets}'

• Conte o número de CPUs lógicas únicas usadas pelo kernel do Linux. A -popção gera saída para fácil análise e é compatível com versões anteriores do lscpu.

  lscpu -p | awk -F, '$0 !~ /^#/ {cores[$1]++} END {print length(cores)}'

Apenas para reiterar o que os outros disseram, há várias propriedades relacionadas.

Para determinar o número de processadores disponíveis:

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

Para determinar o número de unidades de processamento disponíveis (não necessariamente o mesmo que o número de núcleos). Isso é compatível com hyperthreading.

nproc

Eu não quero ir muito longe na toca do coelho, mas você também pode determinar o número de processadores configurados (em oposição aos processadores simplesmente disponíveis / on-line) via getconf _NPROCESSORS_CONF. Para determinar o número total de CPUs (offline e online), você deseja analisar a saída de lscpu -ap.

Eu também pensei cat /proc/cpuinfoque me daria a resposta correta, no entanto, vi recentemente que meu sistema ARM quad core Cortex A53 mostrava apenas um único núcleo. Parece que / proc / cpuinfo mostra apenas os núcleos ativos, enquanto:

cat /sys/devices/system/cpu/present

é uma medida melhor do que está lá. Você também pode

cat /sys/devices/system/cpu/online

para ver quais núcleos estão online e

cat /sys/devices/system/cpu/offline

para ver quais núcleos estão offline. Os online, offlinee presentsysfs entradas retornar o índice das CPUs, portanto, um valor de retorno de 0meio apenas do núcleo 0, enquanto que um valor de retorno de 1-3meios núcleos de 1,2, e 3.

Consulte https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-system-cpu

A seguir, você deve fornecer o número de núcleos "reais" em um sistema com ou sem hyperthread. Pelo menos funcionou em todos os meus testes.

awk -F: '/^physical/ && !ID[$2] { P++; ID[$2]=1 }; /^cpu cores/ { CORES=$2 };  END { print CORES*P }' /proc/cpuinfo

Não é minha página da web, mas esse comando de http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 funciona bem para mim no centos. Ele mostrará o cpus real, mesmo quando o hyperthreading estiver ativado.

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

Contar "id principal" por método "id físico" usando awk com fallback back na contagem de "processador" se "id principal" não estiver disponível (como framboesa)

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)

cat /proc/cpuinfo | grep processor

Isso funcionou bem. Quando tentei a primeira resposta, obtive 3 CPUs como saída. Eu sei que tenho 4 CPUs no sistema, então fiz apenas um greppara o processador e a saída ficou assim:

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

 dmidecode  | grep -i cpu | grep Version

me dá

Versão: CPU Intel (R) Xeon (R) E5-2667 v4 a 3.20GHz

Versão: CPU Intel (R) Xeon (R) E5-2667 v4 a 3.20GHz

Que é contagem tomada correta - olhando acima do E5-2667diz-me cada socket tem 8 cores, por isso, se multiplicam e acabar com 16 corestoda 2 sockets.

Onde lscpume dê 20 CPUs- o que é totalmente incorreto - não sei por quê. (o mesmo vale para cat /proc/cpu- termina com 20.

Mais rápido, sem garfo

Este trabalho com quase todos Concha.

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

Para permanecer compatível com Concha, traço, busyboxe outros, eu usei em ncore=$((ncore+1))vez de ((ncore++)).

bater versão

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

Se não há problema em você usar o Python, o numexprmódulo tem uma função para isso:

In [5]: import numexpr as ne

In [6]: ne.detect_number_of_cores()
Out[6]: 8

também isso:

In [7]: ne.ncores
Out[7]: 8

Para consultar essas informações no prompt de comando, use:

# runs whatever valid Python code given as a string with `-c` option
$ python -c "import numexpr as ne; print(ne.ncores)"
8

Ou simplesmente é possível obter essas informações da multiprocessing.cpu_count()função

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

Ou ainda mais simplesmente, use os.cpu_count()

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

Se você quiser apenas contar núcleos físicos, esse comando fez isso por mim.

lscpu -e | tail -n +2 | tr -s " " | cut -d " " -f 4 | sort | uniq | wc -w

Bastante básico, mas parece contar núcleos físicos reais, ignorando a contagem lógica

O Python 3 também fornece algumas maneiras simples de obtê-lo:

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

4

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

4

Use a consulta abaixo para obter detalhes principais

[oracle@orahost](TESTDB)$ grep -c ^processor /proc/cpuinfo
8

Resumo: para obter CPUs físicas, faça o seguinte:

grep 'core id' /proc/cpuinfo | sort -u

para obter CPUs físicas e lógicas, faça o seguinte:

grep -c ^processor /proc/cpuinfo

/proc << esta é a fonte de ouro de qualquer informação necessária sobre processos e

/proc/cpuinfo << é a fonte de ouro de qualquer informação da CPU.