-sdy-close-shardings
Ferme les partages de Tensor et supprime les axes répliqués.
-sdy-constant-or-scalar-merger
Fusionne les constantes identiques et les expansions scalaires avec des partages correspondants.
Effectue une CSE légère sur les constantes avec des partages identiques.
Le pipeline d'importation divise et duplique les constantes et les expansions scalaires de sorte que le partage ne soit pas propagé entre différentes utilisations d'une sous-computation constante. Si les constantes ont les mêmes partages après propagation, cette passe les fusionne pour gagner du temps de compilation. Pour en savoir plus, consultez -sdy-constant-or-scalar-splitter.
-sdy-convert-global-to-local
Convertit un programme SDY de formes globales en formes locales.
Convertit un programme SDY de formes globales en formes locales en partitionnant les dimensions logiques en fonction des attributs de segmentation.
Cette passe utilise un convertisseur de type pour mapper RankedTensorType des formes logiques globales aux formes physiques locales de l'appareil.
Options
-per-dim-all-gather : Keep per-dimension all-gather without combining them into a single all-gather.
-combine-multi-dimension-reduce-scatter : Combine multi-dimension reduce-scatter into a single reduce-scatter.
-enable-rgv3 : Use StableHLO ReplicaGroupV3 (mesh-axes based) for collectives.
-replica-count : Number of replicas (data parallelism).
-partition-count : Number of partitions (model parallelism).
-sdy-drop-sharding-and-mesh
Supprime l'opération de maillage et la notation de segmentation du programme.
Options
-keep-module-sharding-metadata : Whether to keep module-level sharding metadata (sdy.parameters_shardings and sdy.output_shardings).
-sdy-drop-sharding-rules
Supprime OpShardingRuleAttr de toutes les opérations enregistrées.
-sdy-export-named-computations
Appels de contour de NamedComputationOp.
Crée une passe qui convertit un NamedComputationOp en CallOp avec une nouvelle fonction privée appelée name de NamedComputationOp. Les nouveaux FuncOp et CallOp ont les mêmes partages que les opérandes/résultats NamedComputationOp d'origine.
S'il existe une fonction portant le même nom que NamedComputationOp dans le module, la table de symboles MLIR la remplacera par {name}_#.
-sdy-insert-explicit-reshards
Insère des partages explicites pour que toutes les opérations aient des partages compatibles.
Un partage compatible signifie essentiellement que l'opération peut accepter les opérandes partagés et produire un résultat partagé sans nécessiter de communication de partage (notez que l'opération peut toujours nécessiter une communication telle que la réduction globale ou les échanges de halo).
Après la propagation, certaines opérations peuvent toujours avoir des partages incompatibles.
Notez que lorsqu'un axe (ou un sous-axe) est utilisé pour partager des dimensions non correspondantes (par exemple, des dimensions non contractuelles dans matmul) sur plusieurs Tensors, ou lorsqu'un axe partage une dimension dans un Tensor, mais pas la dimension correspondante dans l'autre Tensor, on dit que l'opération présente un conflit de partage. Par conséquent, après cette passe, les opérations ne présentent plus de conflit.
Cette passe injecte explicitement des opérations de partage afin que, pour chaque opération, les dimensions correspondantes soient partagées de la même manière sur tous les opérandes et résultats, et que chaque axe (ou sous-axe) ne puisse être utilisé que pour partager un seul type de dimension.
Exemple :
Entrée :
mesh = <"x"=4, "y"=2>
%lhs : tensor<8x32xf32> {sdy.sharding=<@mesh, \[{"x"}, {"y"}\]>}
%rhs : tensor<32x16xf32> {sdy.sharding=<@mesh, \[{"y"}, {"x"}\]>}
stablehlo.dot %lhs, %rhs {sdy.sharding_per_value=<[<@mesh, \[{"x"}, {}\]>]>}
: (tensor<8x32xf32>, tensor<32x16xf32>) -> tensor<8x16xf32>
Résultat :
sdy.mesh = <"x"=4, "y"=2>
%lhs : tensor<8x32xf32> {sdy.sharding=<@mesh, \[{"x"}, {"y"}\]>}
%rhs : tensor<32x16xf32> {sdy.sharding=<@mesh, \[{"y"}, {"x"}\]>}
%0 = sdy.reshard %rhs <@mesh, \[{"y"}, {}\]> : tensor<32x16xf32>
stablehlo.dot %lhs, %0 {sdy.sharding_per_value=<[<@mesh, \[{"x"}, {}\]>]>}
: (tensor<8x32xf32>, tensor<32x16xf32>) -> tensor<8x16xf32>
Dans l'exemple ci-dessus, lhs et rhs sont tous deux partagés sur l'axe "x" sur leurs dimensions non contractuelles, ce qui est incompatible. La passe insère un partage explicite sur rhs avant l'opération de point, de sorte que l'opération de point présente des partages compatibles.
Options
-enable-full-version : Enable full version.
-mark-partial-result-with-unreduced-axes : Whether to mark partial reduction results with unreduced axes.
-sdy-insert-func-call-reshards
Insère des partages pour les conflits de partage de fonction et d'appel.
Insère des partages pour les conflits de partage de fonction et d'appel sur les résultats.
-sdy-optimize-collectives
Optimise les opérations de communication collective.
Élimine les opérations de permutation collective redondantes précédant les chaînes de tous à tous en décomposant les dimensions divisées et en les fusionnant dans un tout-à-tous combiné.
-sdy-pad-for-divisibility
Remplit les Tensors avec des partages non divisibles en formes divisibles.
-sdy-per-instruction-partitioning
_Extrait sélectivement les instructions cibles, exécute le pipeline de partitionnement sur celles-ci pour générer du code local à l'appareil et les encapsule dans sdy.manualcomputation.
À des fins de débogage et de bissection, partitionne sélectivement des instructions individuelles à l'aide du pipeline de partitionnement Shardy autonome (resolve-permutation-factors, reshard-to-collectives, pad-for-divisibility, convert-global-to-local) et encapsule le code local de l'appareil résultant dans sdy.manual_computation. Le reste du programme global reste intact, de sorte que les partitions XLA SPMD ne partitionnent que les instructions globales non encapsulées.
Options
-filter : Filter string for selective partitioning. Can be empty (all sharded ops), comma-separated op name substrings (e.g. 'dot, pad'), or key-values like 'selectLow=0, selectHigh=10, func=subroutine'.
-enable-halo-exchange : Implement halo exchange logic for windowed operations inside the sub-pipeline.
-replica-count : Number of replicas (data parallelism).
-partition-count : Number of partitions (model parallelism).
-rng-bit-generator-unsafe : Whether to allow unsafe partitioning of stablehlo.rng_bit_generator.
-sdy-propagate-to-func-results
Propage les partages du terminateur de fonction aux résultats de la fonction.
Copie les partages des valeurs du terminateur de fonction dans les résultats func.func correspondants, en conservant les partages existants sur la fonction principale.
-sdy-remove-all-gather-reduce-scatter-for-cmv1
_Supprime sdy.all_gather et sdy.reducescatter pour CMV1.
Supprime la collecte globale dans le modèle collecte globale + point. Supprime la réduction de la dispersion dans le modèle point + réduction de la dispersion. Cette passe est destinée à la compatibilité avec la matmul collective V1 (CMV1). Il s'agit d'une solution temporaire pour b/432019089.
-sdy-remove-propagation-debug-info
Supprime les informations de débogage de la propagation (arêtes de propagation et partages d'origine) lors de l'exportation.
-sdy-remove-sharding-groups
Supprime ShardingGroupOps après propagation.
-sdy-remove-sub-axes-in-input-output-shardings
Supprime les sous-axes dans les partages d'entrée/de sortie.
Certains utilisateurs de Shardy s'attendent à ce que les entrées/sorties de la fonction aient des partages sans sous-axes. Cette passe supprime les sous-axes et leurs axes de fin des partages de dimension ouverte d'entrée/de sortie. Cette passe est généralement effectuée après sdy-update-non-divisible-input-output-shardings pour s'assurer que la suppression des sous-axes n'introduit pas de partages non divisibles.
-sdy-reshard-to-collectives
Convertit ReshardOp en différentes opérations collectives Shardy.
Fait correspondre les opérations de partage et les réécrit en différentes opérations collectives Shardy. Après cette passe, aucune opération de partage ne reste dans le module.
Si keepRedundantReshards est défini sur "true", les seules opérations de partage qui restent sont les opérations redondantes. Par défaut, il suppose que des partages explicites ont déjà été insérés (sdy-insert-explicit-reshards) et ne conserve pas les partages redondants. Il doit conserver les partages redondants si des partages explicites n'ont pas encore été insérés.
Exemple :
Entrée :
mesh = <"x"=2, &q>uot;y"=<2, ">;z"=2
%0 <: tensor16x2xf32 {sdy.sharding>@mesh, \[{"x",< "y", &quo>t;z"<}, {}\]<>/span>
%1 = sdy.reshard %arg0 @mesh, \[{"x"}, {}\] : tensor16x2xf32
Résultat :
mesh = <"x"=2, &q>uot;y"=<2, ">;z"=2
%0 <: tensor16x2xf32 {sdy.sharding>@mesh, \[{"x", "y", "z"}, {}\]<
%1 = sdy.all_gather> \[{&quo<t;y">;, "z"}, {}\] %arg0 out_sharding=@mesh, \[{"x"}, {}\] : tensor16x2xf32
Dans l'exemple ci-dessus, le Tensor %0 : tensor<16x2xf32> est partagé en
\[{"x", "y", "z"}, {}\]. Ensuite, une opération reshard le partage en
\[{"x"}, {}\]. Sur les premiers axes, comme le suffixe {"y", "z"} est supprimé
après le partage, nous déduisons que nous avons collecté {"y", "z"}. La deuxième dimension n'est pas modifiée.
Options
-keep-redundant-reshards : Whether it keeps redundant reshards or removes.
-sdy-resolve-permutation-factors
Résout la segmentation sur les dimensions mappées aux facteurs kPermutation.
La segmentation de dimensions avec des facteurs kPermutation peut nécessiter une communication inter-appareil (par exemple, un échange de halo pour les fenêtres ou des permutations collectives pour les inversions).
Si enableHaloExchange est défini sur "true", la passe utilise une logique de communication optimisée disponible pour résoudre les facteurs de permutation. Sinon, la passe insère simplement des opérations sdy.reshard pour répliquer ces dimensions. La valeur par défaut de enableHaloExchange est "true".
Options
-enable-halo-exchange : Implement halo exchange logic for windowed operations.
-replica-count : Number of replicas (data parallelism).
-partition-count : Number of partitions (model parallelism).
-rng-bit-generator-unsafe : Whether to allow unsafe partitioning of stablehlo.rng_bit_generator.
-sdy-resolve-single-device-sharding
Réduit les opérations sur un seul appareil en stablehlo.if protégé par l'ID de l'appareil cible.
Options
-replica-count : Number of replicas per partition.
-partition-count : Number of partitions per replica.
-sdy-sharding-constraint-to-reshard
Convertit ShardingConstraintOp en ReshardOp.
-sdy-sink-data-flow-edges
Plonge tous les DataFlowEdgeOp dans leur entrée.
Déplace le partage de chaque DataFlowEdgeOp vers son entrée (la cible racine de l'arête) et remplace l'opération par son entrée.
Options
-sink-debug-sharding-origins : Whether to sink the debug sharding origins info. See `debug-sharding-origins` option in propagation for more info.
-sink-debug-propagation-edge-sharding : Whether to sink the debug propagation edge sharding info. See `debug-propagation-edge-sharding` option in propagation for more info.
-sdy-sink-func-data-flow-edges
Plonge tous les FuncDataFlowEdgeOp dans leur entrée.
Déplace le partage de chaque FuncDataFlowEdgeOp vers son entrée et remplace l'opération par son entrée.
-sdy-unflatten-call-graph
Aplatit le graphique d'appel.
Aplatit le graphique. Il déduplique les fonctions avec les mêmes partages d'entrée/de sortie et la même origine que celle décrite par l'attribut 'original_func_name' associé aux fonctions.
Options
-dedup-functions-fully : If true, regardless of the input and output shardings of functions, it keeps one callee function for each caller function. The default is false, meaning it will deduplicate only if the input and output shardings are the same.
-sdy-update-non-divisible-input-output-shardings
Partage uniformément les entrées/sorties FuncOp, ce qui élimine tout besoin de remplissage en raison de partages non divisibles.
Les utilisateurs de Shardy s'attendent à ce que les entrées/sorties de la fonction soient uniformément divisibles/partageables pour éviter d'avoir à remplir leurs Tensors. La propagation peut rendre les entrées/sorties non divisibles, de sorte que cette passe les met à jour avec le plus grand préfixe de partage de dimension du partage d'origine qui est uniformément partagé.
-sdy-verify-unreduced-axes
Vérifie la cohérence de l'utilisation des axes non réduits.
Vérifie que pour chaque opération, si ses opérandes comportent des axes non réduits, l'opération les réduit explicitement (par exemple, via sdy.reshard) ou les transmet à ses résultats (ou est une opération de délimitation comme func.call).