hwloc-calc - En ligne dans le Cloud

PROGRAMME:

Nom

hwloc-calc - Fonctionne sur des chaînes et des objets de masque de processeur

SYNOPSIS

hwloc-calc [Options] [ [...] ]

Notez que coquelicot(7) fournit une explication détaillée du système hwloc et des
formats ; il doit être lu avant de lire cette page de manuel.

OPTIONS

-p --physique
Utilisez des index OS/physiques au lieu d'index logiques pour l'entrée et la sortie.

-l --logique
Utilisez des index logiques au lieu d'index physiques/OS pour l'entrée et la sortie
(défaut).

--pi --entrée-physique
Utilisez des index OS/physiques au lieu d'index logiques pour l'entrée.

--li --logique-entrée
Utilisez des index logiques au lieu d'index physiques/OS pour l'entrée (par défaut).

--po --sortie-physique
Utilisez des index OS/physiques au lieu d'index logiques pour la sortie.

--lo --logique-sortie
Utilisez des index logiques au lieu d'index physiques/OS pour la sortie (par défaut, sauf
pour les cpusets qui sont toujours physiques).

-N --nombre de
Signaler le nombre d'objets du type ou de la profondeur donnés qui coupent le CPU
ensemble. C'est pratique pour trouver combien de cœurs, de nœuds NUMA ou de PU sont
disponible dans une machine.

-I --couper
Trouver la liste des objets du type ou de la profondeur donnés qui coupent l'ensemble CPU
et rapporter la liste séparée par des virgules de leurs index au lieu du masque cpu
chaîne de caractères. Cela peut être utilisé pour déterminer la liste des objets au-dessus ou au-dessous de la
objets d'entrée. Lorsqu'il est combiné avec --physique, il est commode de passer la liste à
des outils externes tels que tasket ou numactl --physcpubind or --membind. C'est
différent de --largest puisque ce dernier exige que tous les objets signalés soient
strictement inclus à l'intérieur des objets d'entrée.

-H --hiérarchique . ...
Retrouver la liste des objets de type qui croisent l'ensemble CPU et rapportent
la liste séparée par des espaces de leurs index hiérarchiques par rapport à ,
, etc. Par exemple, si paquet.core est donné, la sortie serait
Paquet:1.Core:2 Paquet:2.Core:3 si l'entrée contient le troisième noyau du
deuxième paquet et le quatrième noyau du troisième paquet.

--le plus grand Rapport (dans un format lisible par l'homme) la liste des plus gros objets qui exactement
inclure tous les objets d'entrée. Aucun de ces objets de sortie ne se coupe,
et la somme d'entre eux est exactement équivalente à l'entrée. Aucun objet le plus grand n'est
inclus dans l'entrée Ceci est différent de --intersect où les objets rapportés
peut ne pas être strictement inclus dans l'entrée.

--SEP
Modifiez le séparateur de champ dans la sortie. Par défaut, un espace est utilisé pour
objets de sortie séparés (par exemple lorsque --hiérarchique or --le plus grand est donné)
tandis qu'une virgule est utilisée pour séparer les index (par exemple lorsque --couper is
étant donné).

--Célibataire Singlifiez la sortie à un seul processeur.

--ensemble de tâches Afficher les chaînes d'ensemble de processeurs dans le format reconnu par la ligne de commande de l'ensemble de tâches
programme au lieu du format de chaîne de définition de CPU spécifique à hwloc. Cette option n'a pas
impact sur le format des chaînes de jeu de CPU d'entrée, les deux formats sont toujours acceptés.

--restreindre
Restreindre la topologie au cpuset donné.

--l'ensemble du système
Ne tenez pas compte des limitations administratives.

-i , --saisir
Lire la topologie à partir du fichier XML (au lieu de découvrir la topologie sur le
machine locale). Si est "-", l'entrée standard est utilisée. La prise en charge de XML doit
ont été compilés dans hwloc pour que cette option soit utilisable.

-i , --saisir
Lire la topologie à partir du chroot spécifié par (au lieu de découvrir
la topologie sur la machine locale). Cette option n'est généralement disponible que sur
Linux. Le chroot était généralement créé en rassemblant une autre topologie de machine
avec hwloc-gather-topology.

-i , --saisir
Simuler une fausse hiérarchie (au lieu de découvrir la topologie sur le local
machine). Si est "node:2 pu:3", la topologie contiendra deux
Nœuds NUMA avec 3 unités de traitement dans chacun d'eux. Les chaîne de caractères
doit se terminer par un certain nombre de PU.

--si , --format-d'entrée
Appliquer l'entrée dans le format donné, parmi xml, racine_fs et haute .

-q --silencieux
Masquer les messages d'erreur non fatals. Il comprend principalement des emplacements pointant vers des
objets existants.

-v --verbeux
Sortie verbeuse.

--version Rapporter la version et quitter.

DESCRIPTION

hwloc-calc génère et manipule des chaînes ou des objets de masque CPU. Entrée et sortie
peut être soit des objets (avec des index physiques ou logiques), des listes de CPU (avec des index physiques ou
index logiques) ou des chaînes de masques CPU (toujours indexées physiquement).

Si des objets ou des chaînes de masque CPU sont donnés sur la ligne de commande, ils sont combinés et un
une seule sortie est imprimée. Si aucun objet ou chaîne de masque CPU n'est donné sur la ligne de commande,
le programme lira l'entrée standard. Il combinera plusieurs objets ou masque CPU
les chaînes qui sont données sur la même ligne de la ligne d'entrée standard avec des espaces comme
séparateurs. Les différentes lignes d'entrée seront traitées séparément.

Les arguments et options de la ligne de commande sont traités dans l'ordre. Par exemple, cela signifie que
changer le type des index d'entrée avec --li ou changer la topologie d'entrée avec -i uniquement
affecte le traitement des arguments suivants.

NOTE: Il est fortement recommandé de lire le coquelicot(7) page d'aperçu avant de lire
cette page de manuel. La plupart des concepts décrits dans coquelicot(7) s'appliquent directement au hwloc-
utilitaire de calcul.

EXEMPLES

Le fonctionnement de hwloc-calc est mieux décrit à travers plusieurs exemples.

Pour afficher le masque CPU (physique) correspondant au deuxième package :

$ paquet hwloc-calc:1
0x000000f0

Pour afficher le masque CPU (physique) correspondant au troisième pacakge, à l'exclusion de son pair
processeurs logiques numérotés :

$ package hwloc-calc:2 ~PU:pair
0x00000c00

Pour combiner deux masques CPU (physiques) :

$ hwloc-calc 0x0000ffff 0xff000000
0xff00ffff

Pour afficher la liste des numéros logiques de processeurs inclus dans le deuxième package :

$ hwloc-calc --intersect paquet PU : 1
4,5,6,7

Pour lier logiquement les threads GNU OpenMP sur l'ensemble de la machine, nous devons utiliser des
sortie numérique à la place :

$ export GOMP_CPU_AFFINITY=`hwloc-calc --physical-output --intersect PU machine :0`
$ écho $GOMP_CPU_AFFINITY
0,4,1,5,2,6,3,7

Pour afficher la liste des nœuds NUMA, par index physiques, qui coupent un donné (physique)
Masque CPU :

$ hwloc-calc --physical --intersect NUMAnode 0xf0f0f0f0
0,2

Pour afficher l'indice physique d'un processeur donné par son indice logique :

$ hwloc-calc PU:2 --physique-sortie --intersect PU
3

Pour afficher l'ensemble des CPU près de l'interface réseau eth0 :

$ hwloc-calc os=eth0
MONITORING

Pour afficher les index des packages à proximité du périphérique PCI dont l'ID de bus est 0000:01:02.0 :

$ hwloc-calc pci=0000:01:02.0 --intersect Paquet
1

Pour afficher la liste des cœurs par package qui croisent l'entrée :

$ hwloc-calc 0x00003c00 --hierarchical package.core
Paquet : 2.Core:1 Paquet :3.Core :0

Pour afficher le masque CPU (physique) de toute la topologie à l'exception du troisième package :

$ hwloc-calc tout ~paquet:3
0x0000f0ff

Pour combiner les index physiques et logiques en entrée :

$ hwloc-calc PU:2 --entrée physique PU:3
0x0000000c

Pour synthétiser un ensemble de cœurs en objets les plus volumineux sur une machine à 2 nœuds, 2 packages et 2 cœurs :

$ hwloc-calc core:0 --le plus grand
Noyau: 0
$ hwloc-calc core:0-1 --le plus grand
Paquet: 0
$ hwloc-calc core:4-7 --le plus grand
NUMANOde:1
$ hwloc-calc core:2-6 --le plus grand
Paquet:1 Paquet:2 Noyau:6
$ hwloc-calc pack:2 --le plus grand
Paquet: 2
$ package hwloc-calc:2-3 --largest
NUMANOde:1

Pour obtenir l'ensemble des premiers threads de tous les cœurs :

$ hwloc-calc core:all.pu:0

Cela peut également être très utile pour que GNU OpenMP utilise exactement un thread par cœur,
et dans l'ordre logique du noyau :

$ export OMP_NUM_THREADS=`hwloc-calc --number-of core machine:0`
$ écho $OMP_NUM_THREADS
4
$ export GOMP_CPU_AFFINITY=`hwloc-calc --physical-output --intersect PU core:all.pu:0`
$ écho $GOMP_CPU_AFFINITY
0,2,1,3

RETOUR VALEURE

Une fois l'exécution réussie, hwloc-calc affiche la chaîne de masque (physique) du processeur (physique
ou logique) liste d'objets ou liste de numéros d'objets (physiques ou logiques). La valeur de retour est
0.

hwloc-calc renverra une valeur différente de zéro si un type d'erreur se produit, tel que (mais sans s'y limiter) :
échec de l'analyse de la ligne de commande.

Utilisez hwloc-calc en ligne en utilisant les services onworks.net