Comment obtenir le nombre de CPU / cœurs sous Linux à partir de la ligne de commande?

J'ai ce script, mais je ne sais pas comment obtenir le dernier élément de l'impression:

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

Le dernier élément doit être le nombre de CPU, moins 1.

grep -c ^processor /proc/cpuinfo     

comptera le nombre de lignes commençant par "processeur" dans /proc/cpuinfo

Pour les systèmes avec hyper-threading, vous pouvez utiliser

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

qui devrait retourner (par exemple) 8(alors que la commande ci-dessus retournerait 16)

Le traitement du contenu /proc/cpuinfoest inutilement baroque. Utilisez nproc qui fait partie de coreutils, il devrait donc être disponible sur la plupart des installations Linux.

La commande nprocimprime le nombre d'unités de traitement disponibles pour le processus en cours, qui peut être inférieur au nombre de processeurs en ligne.

Pour trouver le nombre de tous les cœurs / processeurs installés, utilisez nproc --all

Sur ma machine à 8 cœurs:

$ nproc --all
8

La solution la plus portable que j'ai trouvée est la getconfcommande:

getconf _NPROCESSORS_ONLN

Cela fonctionne à la fois sur Linux et Mac OS X. Un autre avantage de cela par rapport à certaines des autres approches est que getconf existe depuis longtemps. Certaines des anciennes machines Linux sur lesquelles je dois faire du développement n'ont pas les commandes nprocou lscpudisponibles, mais elles ontgetconf .

^{Note de l'éditeur: bien que l' getconf utilitaire soit mandaté par POSIX , les valeurs spécifiques _NPROCESSORS_ONLNet _NPROCESSORS_CONF ne le sont pas. Cela dit, comme indiqué, ils fonctionnent sur les plates-formes Linux ainsi que sur macOS; sur FreeBSD / PC-BSD, vous devez omettre le début _.}

Préface:

• Le problème avec les /proc/cpuinforéponses basées sur le fait qu'elles analysent les informations destinées à la consommation humaine et n'ont donc pas de format stable conçu pour l'analyse de la machine : le format de sortie peut différer d'une plate-forme à l'autre et de conditions d'exécution; l'utilisation lscpu -psur Linux (et sysctlsur macOS) contourne ce problème .

• getconf _NPROCESSORS_ONLN/ getconf NPROCESSORS_ONLNne fait pas de distinction entre les processeurs logiques et physiques .

Voici un shextrait (compatible POSIX) qui fonctionne sur Linux et macOS pour déterminer le nombre de processeurs logiques ou physiques - en ligne - ; voir les commentaires pour plus de détails.

Utilise lscpupour Linux et sysctlpour macOS.

Note terminologique : CPU désigne la plus petite unité de traitement vue par le système d'exploitation. Les cœurs non hyper-threading correspondent chacun à 1 CPU, tandis que les cœurs hyper-threading contiennent plus de 1 (généralement: 2) - logique - CPU.
Linux utilise la taxonomie suivante ^[1] , en commençant par la plus petite unité:
CPU < core < socket < book < node
avec chaque niveau comprenant 1 ou plusieurs instances du niveau inférieur suivant.

#!/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] documentation macOSsysctl (3)

Notez que les systèmes dérivés de BSD autres que macOS - par exemple, FreeBSD - ne prennent en charge que la hw.ncpuclé pour sysctl, qui sont obsolètes sur macOS; Je ne suis pas clair sur lequel des nouvelles clés hw.npucorrespond à: hw.(logical|physical)cpu_[max].

^{Astuce du chapeau à @teambob pour aider à corriger la commande Physical-CPU-count lscpu.}

Attention : la lscpu -psortie n'inclut PAS de colonne "livre" (la manpage mentionne "livres" comme une entité entre socket et nœud dans la hiérarchie taxonomique). Si des "livres" sont en cours de lecture sur un système Linux donné ( est-ce que quelqu'un sait quand et comment? ), La commande physical-CPU-count peut sous- signaler (ceci est basé sur l'hypothèse que les lscpuID de rapports qui ne sont pas uniques sur des niveaux supérieurs entités de niveau ; par exemple: 2 cœurs différents de 2 sockets différents pourraient avoir le même ID).

Si vous enregistrez le code ci-dessus en tant que, par exemple, un script shellcpus , le rendez exécutable avec chmod +x cpuset le placez dans un dossier dans votre $PATH, vous verrez une sortie telle que la suivante:

$ cpus
logical  4
physical 4

^{[1] Xaekai met en lumière ce qu'est un livre : "un livre est un module qui contient une carte de circuit imprimé avec des sockets CPU, des sockets RAM, des connexions IO le long du bord et un crochet pour l'intégration du système de refroidissement. Ils sont utilisés dans les mainframes IBM . Pour plus d'informations: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf "}

lscpu rassemble le formulaire d'informations sur l'architecture du processeur / proc / cpuinfon dans un format lisible par l'homme:

# 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

Voir également /unix/468766/understanding-output-of-lscpu .

Cela a fonctionné pour moi. tail -nXvous permet de saisir uniquement les dernières lignes X.

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

Si vous avez un hyperthreading, cela devrait fonctionner pour saisir le nombre de cœurs physiques .

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

Pour le nombre total de cœurs physiques:

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

Sur les machines à plusieurs sockets (ou toujours), multipliez le résultat ci-dessus par le nombre de sockets:

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

@ mklement0 a une assez bonne réponse ci-dessous en utilisant lscpu. J'ai écrit une version plus succincte dans les commentaires

Vous pouvez également utiliser Python! Pour obtenir le nombre de cœurs physiques:

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

Pour obtenir le nombre de cœurs hyperthreadés:

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

Solution multiplateforme pour Linux, MacOS, Windows:

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

Voici la façon dont j'utilise pour compter le nombre de cœurs physiques qui sont en ligne sur Linux:

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

ou en bref:

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

Exemple (1 socket):

> 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

Exemple (2 prises):

> 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

Exemple (4 prises):

> 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

L'utilisation de getconf est en effet le moyen le plus portable, mais la variable a des noms différents dans BSD et Linux pour getconf, vous devez donc tester les deux, comme le suggère cet essentiel: https://gist.github.com/jj1bdx/5746298 (comprend également un correctif Solaris utilisant ksh)

J'utilise personnellement:

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

Et si vous le souhaitez en python, vous pouvez simplement utiliser le syscall getconf utilise en important le module os:

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

Quant à nproc, il fait partie de GNU Coreutils, donc non disponible dans BSD par défaut. Il utilise également sysconf () après quelques autres méthodes.

Si vous voulez le faire pour qu'il fonctionne sur Linux et OS X, vous pouvez faire:

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

C'est très simple. Utilisez simplement cette commande:

lscpu

Vous pouvez utiliser l'une des méthodes suivantes pour déterminer le nombre de cœurs CPU physiques .

• Comptez le nombre d'ID de noyau uniques (à peu près équivalents à grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l).

  awk '/^core id\t/ {cores[$NF]++} END {print length(cores)}' /proc/cpuinfo

• Multipliez le nombre de «cœurs par socket» par le nombre de sockets.

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

• Comptez le nombre de CPU logiques uniques utilisés par le noyau Linux. L' -poption génère une sortie pour une analyse facile et est compatible avec les versions antérieures de lscpu.

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

Pour réitérer ce que d'autres ont dit, il existe un certain nombre de propriétés connexes.

Pour déterminer le nombre de processeurs disponibles:

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

Déterminer le nombre d'unités de traitement disponibles (pas nécessairement le même que le nombre de cœurs). Ceci est sensible à l'hyperthreading.

nproc

Je ne veux pas aller trop loin dans le lapin, mais vous pouvez également déterminer le nombre de processeurs configurés (par opposition aux processeurs simplement disponibles / en ligne) via getconf _NPROCESSORS_CONF. Pour déterminer le nombre total de CPU (hors ligne et en ligne) dont vous souhaitez analyser la sortie lscpu -ap.

J'ai également pensé que cat /proc/cpuinfocela me donnerait la bonne réponse, mais j'ai récemment vu que mon système ARM quad core Cortex A53 ne montrait qu'un seul cœur. Il semble que / proc / cpuinfo ne montre que les cœurs actifs, alors que:

cat /sys/devices/system/cpu/present

est une meilleure mesure de ce qui existe. Vous pouvez également

cat /sys/devices/system/cpu/online

pour voir quels cœurs sont en ligne, et

cat /sys/devices/system/cpu/offline

pour voir quels cœurs sont hors ligne. Les online, offlineet presentsysfs entrées renvoient l'index des CPU, de sorte qu'une valeur de retour de 0tout moyen de base 0, alors une valeur de retour des 1-3moyens noyaux 1,2 et 3.

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

Ce qui suit devrait vous donner le nombre de "vrais" cœurs sur un système hyperthreadé et non hyperthreadé. Au moins, cela a fonctionné dans tous mes tests.

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

Pas ma page Web, mais cette commande de http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 fonctionne bien pour moi sur centos. Il montrera les processeurs réels même lorsque l'hyperthreading est activé.

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

Compter "core id" par la méthode "physical id" en utilisant awk avec repli sur "processor" count si "core id" n'est pas disponible (comme framboise)

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

Cela a bien fonctionné. Quand j'ai essayé la première réponse, j'ai eu 3 processeurs en sortie. Je sais que j'ai 4 processeurs sur le système, donc je viens de faire un grepprocesseur et la sortie ressemblait à ceci:

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

 dmidecode  | grep -i cpu | grep Version

Donne moi

Version: CPU Intel (R) Xeon (R) E5-2667 v4 à 3,20 GHz

Version: CPU Intel (R) Xeon (R) E5-2667 v4 à 3,20 GHz

Quel est le nombre de prises correct - en recherchant le E5-2667me dit que chaque prise a 8 cores, alors multipliez et finissez avec à 16 corestravers 2 sockets.

Où lscpume donner 20 CPUs- ce qui est totalement incorrect - je ne sais pas pourquoi. (il en va de même cat /proc/cpu- finit par20 .

Plus rapide, sans fourche

Ce travail avec presque tous coquille.

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

Afin de rester compatible avec coquille, tiret, occupéet d'autres, j'ai utilisé ncore=$((ncore+1))au lieu de ((ncore++)).

frapper version

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

Si vous pouvez utiliser Python, le numexprmodule a une fonction pour cela:

In [5]: import numexpr as ne

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

aussi ceci:

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

Pour interroger ces informations à partir de l'invite de commande, utilisez:

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

Ou tout simplement il est possible d'obtenir ces informations à partir de la multiprocessing.cpu_count()fonction

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

Ou encore plus simplement utiliser os.cpu_count()

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

Si vous voulez simplement compter les cœurs physiques, cette commande l'a fait pour moi.

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

Assez basique, mais semble compter les cœurs physiques réels, ignorant le nombre logique

Python 3 fournit également quelques moyens simples pour l'obtenir:

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

4

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

4

Utilisez la requête ci-dessous pour obtenir les détails de base

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

Résumé: pour obtenir des CPU physiques, procédez comme suit :

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

pour obtenir des CPU physiques et logiques, procédez comme suit:

grep -c ^processor /proc/cpuinfo

/proc << c'est la source d'or de toutes les informations dont vous avez besoin sur les processus et

/proc/cpuinfo << est la source d'or de toute information CPU.