OpenXLA Project

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

`-sdy-close-shardings`

Ferme les partitionnements de Tensor et supprime les axes répliqués.

`-sdy-constant-or-scalar-merger`

Fusionne les constantes identiques et les expansions scalaires avec des partitionnements correspondants.

Effectue une CSE légère sur les constantes avec des partitionnements identiques.

Le pipeline d'importation divise et duplique les constantes et les expansions scalaires de sorte que le partitionnement ne soit pas propagé entre différentes utilisations d'un sous-calcul constant. Si les constantes ont les mêmes partitionnements après la 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 partitionnement.

Cette passe utilise un convertisseur de type pour mapper RankedTensorType des formes logiques globales aux formes physiques locales de l'appareil.

`-sdy-drop-sharding-rules`

Supprime OpShardingRuleAttr de toutes les opérations enregistrées.

`-sdy-insert-explicit-reshards`

Insère des repartitionnements explicites pour que toutes les opérations aient des partitionnements compatibles.

Un partitionnement compatible signifie essentiellement que l'opération peut accepter les opérandes partitionnés et produire un résultat partitionné sans nécessiter de communications de repartitionnement (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 partitionnements incompatibles.

Notez que lorsqu'un axe (ou un sous-axe) est utilisé pour partitionner des dimensions non correspondantes (par exemple, des dimensions non contractuelles dans matmul) sur plusieurs Tensors, ou lorsqu'un axe partitionne 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 partitionnement. Par conséquent, après cette passe, les opérations ne présentent plus de conflit.

Cette passe injecte explicitement des opérations de repartitionnement afin que, pour chaque opération, les dimensions correspondantes soient partitionné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 partitionner 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 partitionnés sur l'axe "x" sur leurs dimensions non contractuelles, ce qui est incompatible. La passe insère un repartitionnement explicite sur rhs avant l'opération de point, de sorte que l'opération de point présente des partitionnements compatibles.

Options

-enable-full-version                  : Enable full version.
-avoid-reshards-on-named-computations : Avoid explicit reshards/collectives on named computations.

`-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-dispersion dans le modèle point + réduction-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 partitionnements d'origine) lors de l'exportation.

`-sdy-remove-sharding-groups`

Supprime ShardingGroupOps après la propagation.

`-sdy-remove-sub-axes-in-input-output-shardings`

Supprime les sous-axes dans les partitionnements d'entrée/de sortie.

Certains utilisateurs de Shardy s'attendent à ce que les entrées/sorties de la fonction aient des partitionnements sans sous-axes. Cette passe supprime les sous-axes et leurs axes de fin des partitionnements 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 partitionnements non divisibles.

`-sdy-reshard-to-collectives`

Convertit ReshardOp en différentes opérations collectives Shardy.

Fait correspondre les opérations de repartitionnement et les réécrit en différentes opérations collectives Shardy. Après cette passe, aucune opération de repartitionnement ne reste dans le module.

Si keepRedundantReshards est défini sur "true", les seules opérations de repartitionnement qui restent sont les opérations redondantes. Par défaut, il suppose que des repartitionnements explicites ont déjà été insérés (sdy-insert-explicit-reshards) et ne conserve pas les repartitionnements redondants. Il doit conserver les repartitionnements redondants si des repartitionnements explicites n'ont peut-être pas déjà été insérés.

Exemple :

Entrée :

mesh = <"x"=2, "y"=2, "z"=2>
%0 : tensor<16x2xf32> {sdy.sharding<@mesh, \[{"x", "y", "z"}, {}\]>
%1 = sdy.reshard %arg0 <@mesh, \[{"x"}, {}\]> : tensor<16x2xf32>

Résultat :

mesh = <"x"=2, "y"=2, "z"=2>
%0 : tensor<16x2xf32> {sdy.sharding<@mesh, \[{"x", "y", "z"}, {}\]>
%1 = sdy.all_gather \[{"y", "z"}, {}\] %arg0 out_sharding=<@mesh, \[{"x"}, {}\]> : tensor<16x2xf32>

Dans l'exemple ci-dessus, le Tensor %0 : tensor<16x2xf32> est partitionné en tant que \[{"x", "y", "z"}, {}\]. Ensuite, une opération reshard le repartitionne en tant que \[{"x"}, {}\]. Sur les premiers axes, étant donné que le suffixe {"y", "z"} est supprimé après le repartitionnement, nous déduisons que nous avons collecté globalement {"y", "z"}. La deuxième dimension n'est pas modifiée.

Options

-keep-redundant-reshards : Whether it keeps redundant reshards or removes.

`-sdy-sharding-constraint-to-reshard`

Convertit ShardingConstraintOp en ReshardOp.

`-sdy-sink-data-flow-edges`

Fait passer tous les DataFlowEdgeOp dans leur entrée.

Déplace le partitionnement 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-update-non-divisible-input-output-shardings`

Partitionne uniformément les entrées/sorties FuncOp, ce qui élimine tout besoin de remplissage en raison de partitionnements non divisibles.

Les utilisateurs de Shardy s'attendent à ce que les entrées/sorties de la fonction soient uniformément divisibles/partitionnables 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 partitionnement de dimension du partitionnement d'origine qui est uniformément partitionné.