Comment obtenir le nombre de processeurs/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 devrait être le nombre de processeurs, moins 1.
cat /proc/cpuinfo | awk '/^processor/{print $3}' | wc -l
ou simplement
grep -c ^processor /proc/cpuinfo
qui 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 renvoyer (par exemple) 8 (alors que la commande ci-dessus renverrait 16)
Le traitement du 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.
La commande nproc imprime 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 total de 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 commande getconf:
getconf _NPROCESSORS_ONLN
Cela fonctionne à la fois sous Linux et Mac OS X. Un autre avantage de cette approche par rapport aux 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 nproc ou lscpu disponibles, mais elles ont getconf.
Note de l'éditeur: Alors que la getconfutility est mandatée par POSIX , les _NPROCESSORS_ONLN et _NPROCESSORS_CONFvaleurs spécifiques ne le sont pas. .__ Cela dit, comme indiqué, ils fonctionnent sur les plates-formes Linux ainsi que sur macOS; sous FreeBSD/PC-BSD, vous devez omettre le _ qui précède.
Préface:
Le problème de avec les réponses basées sur
/proc/cpuinfo- est qu’elles analysent les informations destinées à la consommation humaine et donc n’a pas de format stable conçu pour l’analyse machine: le format de sortie peut conditions d'exécution; usinglscpu -psous Linux (etsysctlsur macOS) contourne ce problème.getconf _NPROCESSORS_ONLNgetconf NPROCESSORS_ONLNne fait pas la distinction entre les processeurs logiques et physiques.
Voici un extrait sh (compatible POSIX) qui fonctionne sur _/Linux et macOS pour déterminer le nombre de - en ligne - logiques ou physiques CPU; voir les commentaires pour plus de détails.
Utilise lscpu pour Linux et sysctl pour macOS.
Note de terminologie: CPU fait référence à la plus petite unité de traitement telle que vue par le système d'exploitation. Les cœurs non hyper-threading correspondent chacun à 1 CPU, alors que les cœurs hyper-threading contiennent plus d'un (typiquement: 2) - logique - CPU.
Linux utilise la taxonomie suivante, en commençant par la plus petite unité: CPU <cœur <socket <livre <noeud, avec chaque niveau comprenant 1 ou plusieurs instances du niveau inférieur suivant.
Mes connaissances sont quelque peu précaires, faites-le-moi savoir si je me trompe.Quelqu'un sait-il ce qu'est un "livre" 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] documentation macOS sysctl (3)
Notez que les systèmes dérivés de BSD autres que macOS - par exemple, FreeBSD - ne prennent en charge que la clé hw.ncpu pour sysctl, qui sont obsolètes sur macOS; Je ne sais pas sur laquelle des nouvelles clés hw.npu correspond à: hw.(logical|physical)cpu_[max].
Conseil du chapeau à @teambob pour avoir aidé à corriger la commande lscpu physical-CPU-count.
Caveat: La sortie de lscpu -p n'inclut PAS de colonne "book" (la page man mentionne "books" en tant qu'entité entre socket et noeud dans la hiérarchie taxonomique). Si des "livres" sont en jeu sur un système Linux donné (tout le monde sait-il quand et comment?), La commande physical-CPU-count peut sous -report (basé sur l'hypothèse que lscpu signale les identifiants non uniques parmi les entités de niveau supérieur; par exemple: 2 cœurs différents provenant de 2 sockets différents peuvent avoir le même identifiant).
Si vous enregistrez le code ci-dessus sous, par exemple, le script Shell cpus, rendez-le exécutable avec chmod +x cpus et placez-le dans le dossier de votre $PATH, le résultat obtenu sera le suivant:
$ cpus
logical 4
physical 4
lscpu rassemble les informations sur l’architecture de la CPU sous/proc/cpuinfon au format lisible par un humain:
# 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 aussi https://unix.stackexchange.com/questions/468766/understanding-output-of-lscpu .
Cela a fonctionné pour moi. tail -nX vous permet de ne saisir que les X dernières lignes.
cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1
Si vous avez hyperthreading, cela devrait fonctionner pour saisir le nombre de physiques cœurs.
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 multi-socket (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 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 noyaux hyperthreaded:
$ python -c "import psutil; print(psutil.cpu_count(logical=True))"
8
Utiliser getconf est en effet le moyen le plus portable. Cependant, la variable a des noms différents dans get et sous BSD. Vous devez donc tester les deux, comme le suggère Gist: https://Gist.github.com/jj1bdx/5746298 (Inclut é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 voulez cela en python, vous pouvez simplement utiliser le syscall utilisé par getconf 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, il n'est donc pas disponible par défaut dans BSD. Il utilise également sysconf () après d’autres méthodes.
Solution multiplateforme 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 faire:
CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
Ce qui suit devrait vous donner le nombre de "vrais" cœurs sur un système hyperthreaded et non hyperthreaded. 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
Voici comment je compte le nombre de cœurs physiques en ligne sous 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
Je pensais également que cat /proc/cpuinfo me donnerait la réponse correcte, mais j’ai récemment constaté que mon système ARM Cortex A53 à quatre coeurs 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 est là. Vous pouvez également
cat /sys/devices/system/cpu/online
pour voir quels noyaux sont en ligne, et
cat /sys/devices/system/cpu/offline
pour voir quels cœurs sont hors ligne. Les entrées online, offline et present sysfs renvoient l'index du CPUS, ainsi une valeur de retour de 0 signifie simplement le cœur 0, alors qu'une valeur de retour de 1-3 signifie les cœurs 1,2 et 3.
Voir https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-system-cpu
Si vous voulez juste compter les cœurs physiques, cette commande le 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, en ignorant le compte logique
Compter la méthode "core id" par "physical id" en utilisant awk avec un repli sur le "processeur" si "core id" n'est pas disponible
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)
Si 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 interroger ces informations à partir de la commande Invite use:
# runs whatever valid Python code given as a string with `-c` option
$ python -c "import numexpr as ne; print(ne.ncores)"
8
Ou simplement, il est possible d’obtenir ces informations à partir de multiprocessing.cpu_count() function
$ python -c "import multiprocessing; print(multiprocessing.cpu_count())"
Ou encore plus simplement, utilisez os.cpu_count()
$ python -c "import os; print(os.cpu_count())"
C'est très simple. Il suffit d'utiliser cette commande:
lscpu
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
Afin de 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
cat /proc/cpuinfo | grep processor
Cela a bien fonctionné. Quand j'ai essayé la première réponse, j'ai eu 3 CPU en sortie. Je sais que j'ai 4 processeurs sur le système, alors je viens de faire une grep pour le processeur et la sortie ressemblait à ceci:
[root@theservername ~]# cat /proc/cpuinfo | grep processor
processor : 0
processor : 1
processor : 2
processor : 3
Résumé: pour obtenir CPU physique faites ceci:
grep 'core id' /proc/cpuinfo | sort -u
pour obtenir physique et logique les CPU font ceci:
grep -c ^processor /proc/cpuinfo
/proc << C’est la source en or de toute information dont vous avez besoin sur les processus et
/proc/cpuinfo << est la source en or de toute information sur le processeur.
dmidecode | grep -i cpu | grep Version
donne moi
Version: CPU E5-2667 v4 @ 3.20GHz pour Intel (R) Xeon (R)
Version: CPU E5-2667 v4 @ 3.20GHz pour Intel (R) Xeon (R)
Quel est le nombre de sockets correct - regarder le E5-2667 me dit que chaque socket a 8 cores, multipliez-vous et terminez avec 16 cores sur 2 sockets.
Où lscpu donnez-moi 20 CPUs - ce qui est totalement incorrect - vous ne savez pas pourquoi. (idem pour cat /proc/cpu - se termine par 20.
Utilisez la requête ci-dessous pour obtenir les détails essentiels
[Oracle@orahost](TESTDB)$ grep -c ^processor /proc/cpuinfo
8
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
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