Comment obtenir le nombre de CPUs/Core sous Linux à partir de la ligne de commande?

traiter le contenu de /proc/cpuinfo est inutilement baroque. Utilisez nproc qui fait partie de coreutils, il devrait donc être disponible sur la plupart des installations Linux.

Commande nproc imprime le nombre d'unités de traitement disponibles pour le processus actuel, qui peut être inférieur au nombre de ligne de processeurs.

pour trouver le nombre de tous les cœurs/processeurs installés utiliser nproc --all

sur ma machine à 8 cœurs:

$ nproc --all
8

la solution la plus portable que j'ai trouvée est la commande getconf :

getconf _NPROCESSORS_ONLN

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

^{note de L'éditeur: le getconf utilitaire est POSIX-mandat , les _NPROCESSORS_ONLN et _NPROCESSORS_CONF valeurs ne le sont pas. Cela dit, comme indiqué, ils travaillent sur les plateformes Linux aussi bien que sur macOS; sur FreeBSD/PC-BSD, Vous devez omettre le leader _ .}

préface:

• le problème avec le /proc/cpuinfo réponses basées est qu'ils analysent l'information qui a été conçu pour humaine consommation et donc manque un format stable conçu pour la machine parsing : le format de sortie peut différer entre les plates-formes et les conditions d'exécution; en utilisant lscpu -p sur Linux (et sysctl sur macOS) ce problème .

• getconf _NPROCESSORS_ONLN / getconf NPROCESSORS_ONLN ne fait pas de distinction entre logique et physique CPU.

voici un sh (conforme à POSIX) snippet qui fonctionne sur Linux et macOS pour déterminer le nombre de - en ligne - logique ou physique Processeurs ; voir les commentaires pour plus de détails.

utilise lscpu Pour Linux, et sysctl pour macOS.

Note terminologique : CPU se réfère à la plus petite unité de traitement comme vu par L'OS. Les noyaux sans filetage hyper correspondent chacun à 1 CPU, alors que les noyaux avec filetage hyper contiennent plus de 1 (typiquement: 2)-logical - CPU.

Linux utilise la taxonomie, en commençant par la plus petite unité: CPU < de base < socket < livre < nœud , avec chaque niveau comprenant 1 ou plusieurs instances du niveau inférieur suivant.

mes connaissances sont quelque peu chancelantes ici - faites-moi savoir si je me trompe. est-ce que quelqu'un sait ce "livre" est dans ce contexte, ?

#!/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) documentation

notez que les systèmes dérivés de BSD autres que macOS-par exemple, FreeBSD - ne supportent que la clé hw.ncpu pour sysctl , qui sont dépréciés sur macOS; Je ne sais pas sur laquelle des nouvelles clés hw.npu correspond à: hw.(logical|physical)cpu_[max] .

^{pointe du chapeau à @teambob pour aide à corriger la commande physical-CPU-count lscpu .}

Caveat : lscpu -p ne comprend pas une colonne "livre" (la page man mentionne "livres" comme entité entre socket et noeud dans la hiérarchie taxonomique). Si les "livres" sont en jeu, sur un système Linux ( quelqu'un sait quand et comment? ), la commande physical-CPU-count mai sous - report (this est basée sur l'hypothèse que lscpu déclare Des Id qui ne sont pas uniques parmi les entités de niveau supérieur ; par exemple: 2 cœurs différents de 2 sockets différents pourraient avoir le même ID).

ça a marché pour moi. tail -nX vous permet de saisir seulement les dernières lignes de X.

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

si vous avez hyperthreading, cela devrait fonctionner pour saisir le nombre de physique cœurs.

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

lscpu rassemble l'architecture du PROCESSEUR formulaire d'information /proc/cpuinfon dans l'homme-lire-mesure format:

# 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

pour le nombre total de noyaux physiques:

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

sur les machines à prises multiples (ou toujours), multiplier le résultat ci-dessus par le nombre de prises:

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

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

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

j'utilise personnellement:

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

et si vous voulez cela en python vous pouvez simplement utiliser les utilisations syscall getconf en important le module os:

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

comme pour nproc , il fait partie de GNU Coreutils, donc pas disponible en BSD par défaut. Il utilise sysconf () ainsi que d'autres méthodes.

Compatible solution pour Linux, MacOS, Windows:

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

si vous voulez faire cela pour que cela fonctionne sur linux et OS X, vous pouvez le faire:

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

vous pouvez aussi utiliser Python! Pour obtenir le nombre de noyaux physiques:

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

pour obtenir le nombre de cœurs hyperthreaded:

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

ce qui suit devrait vous donner le nombre de cœurs" réels " sur un système hyperthreaded et non-hyperthreaded. Au moins, ça a marché dans tous mes tests.

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

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

• comptez le nombre d'identificateurs uniques du noyau (environ l'équivalent de grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l ).

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

• Multiplier 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'option -p génère une sortie pour l'analyse facile et est compatible avec les versions précédentes de lscpu .

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

pour reprendre ce que d'autres ont dit, il y a un certain nombre de propriétés connexes.

Pour déterminer le nombre de Transformateurs disponibles:

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

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

nproc

Je ne veux pas aller trop loin dans le Terrier, 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) que vous souhaitez analyser la sortie de lscpu -ap .

Count "identité de base" par "physique" id de méthode à l'aide de awk avec repli sur "processeur" comptent "identité de base" ne sont pas disponibles (comme la framboise)

echo $(awk '{ if ("151900920"~/^physical id/) { p=$NF }; if ("151900920"~/^core id/) { cores[p$NF]=p$NF }; if ("151900920"~/processor/) { cpu++ } } END { for (key in cores) { n++ } } END { if (n) {print n} else {print cpu} }' /proc/cpuinfo)

Voici la façon dont j'utilise pour compter le nombre de noyaux 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

cat /proc/cpuinfo | grep processor

ça a bien marché. Quand j'ai essayé la première réponse j'ai eu 3 CPU comme sortie. Je sais que j'ai 4 CPU sur le système donc j'ai juste fait un grep pour le processeur et la sortie ressemblait à ceci:

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

plus rapide, sans fourche

ce travail avec presque tous shell .

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

pour rester compatible avec shell , dash , busybox et autres, j'ai utilisé ncore=$((ncore+1)) au lieu de ((ncore++)) .

bash version

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

si vous êtes d'accord que vous pouvez utiliser Python, alors numexpr module 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 demander ces informations à partir de la commande prompt use:

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

Cette commande:

echo $(nproc)

doit renvoyer le nombre ou les noyaux disponibles pour le système

pas ma page web, mais cette commande de http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 me va très bien sur centos. Il affichera les CPU 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

 dmidecode  | grep -i cpu | grep Version

donne-moi

Version: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20 GHz

Version: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20 GHz

qui est le nombre de douilles correct - en regardant le E5-2667 me dit que chaque douille a 8 cores , donc multiplier et finir avec 16 cores à travers 2 sockets .

où lscpu donnez-moi 20 CPUs - ce qui est totalement faux - pas sûr de savoir pourquoi. (idem pour cat /proc/cpu - se termine par 20 .

Python 3 fournit aussi quelques moyens simples pour l'obtenir:

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

4

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

4