-sdy-close-shardings

Schließt Tensor-Shardings und verwirft replizierte Achsen.

-sdy-constant-or-scalar-merger

Führt identische Konstanten und Skalarerweiterungen mit übereinstimmenden Shardings zusammen.

Führt eine einfache CSE für Konstanten mit identischen Shardings aus.

Die Importpipeline teilt und dupliziert die Konstanten und Skalarerweiterungen so, dass das Sharding nicht zwischen verschiedenen Verwendungen einer konstanten Unterberechnung weitergegeben wird. Wenn die Konstanten nach der Weitergabe dieselben Shardings haben, werden sie in diesem Durchlauf zusammengeführt, um Kompilierungszeit zu sparen. Weitere Informationen finden Sie unter -sdy-constant-or-scalar-splitter.

-sdy-convert-global-to-local

Konvertiert ein SDY-Programm von globalen zu lokalen Formen.

Konvertiert ein SDY-Programm von globalen zu lokalen Formen, indem logische Dimensionen basierend auf Sharding-Attributen partitioniert werden.

In diesem Durchlauf wird ein Typkonverter verwendet, um RankedTensorType von globalen logischen Formen zu gerätespezifischen physischen Formen zuzuordnen.

Optionen

-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

Entfernt den Mesh-Vorgang und die Sharding-Notation aus dem Programm.

-sdy-drop-sharding-rules

Entfernt OpShardingRuleAttr aus allen registrierten Vorgängen.

-sdy-export-named-computations

Gliedert Aufrufe von NamedComputationOp.

Erstellt einen Durchlauf, der einen NamedComputationOp in einen CallOp mit einer neuen privaten Funktion konvertiert, die den name von NamedComputationOp hat. Der neue FuncOp und CallOp haben dieselben Shardings wie die Operanden/Ergebnisse des ursprünglichen NamedComputationOp.

Wenn im Modul eine Funktion mit demselben Namen wie der NamedComputationOp vorhanden ist, ändert die MLIR-Symboltabelle sie in {name}_#.

-sdy-insert-explicit-reshards

Fügt explizite Reshards ein, damit alle Vorgänge kompatible Shardings haben.

Ein kompatibles Sharding bedeutet im Wesentlichen, dass der Vorgang die Sharding-Operanden akzeptieren und ein Sharding-Ergebnis erzeugen kann, ohne dass eine Reshard-Kommunikation erforderlich ist. Der Vorgang erfordert möglicherweise weiterhin eine Kommunikation wie All-Reduce oder Halo-Swaps.

Nach der Weitergabe haben einige Vorgänge möglicherweise immer noch inkompatible Shardings.

Wenn eine Achse (oder Unterachse) verwendet wird, um nicht übereinstimmende Dimensionen (z.B. nicht zusammenziehende Dimensionen in Matmul) über mehrere Tensoren hinweg zu sharden, oder wenn eine Achse eine Dimension in einem Tensor shardet, aber nicht die entsprechende Dimension im anderen Tensor, spricht man von einem Sharding-Konflikt. Nach diesem Durchlauf sind die Vorgänge daher konfliktfrei.

In diesem Durchlauf werden Reshard-Vorgänge explizit eingefügt, sodass entsprechende Dimensionen für jeden Vorgang auf dieselbe Weise über alle Operanden und Ergebnisse hinweg geshardet werden. Jede Achse (oder Unterachse) kann nur verwendet werden, um einen einzelnen Dimensionstyp zu sharden.

Beispiel:

Eingabe:

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>

Ausgabe:

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>

Im obigen Beispiel werden lhs und rhs beide auf der Achse „x“ auf ihren nicht zusammenziehenden Dimensionen geshardet, was inkompatibel ist. Der Durchlauf fügt vor dem Punktvorgang ein explizites Reshard für rhs ein, sodass der Punktvorgang kompatible Shardings hat.

Optionen

-enable-full-version : Enable full version.

-sdy-insert-func-call-reshards

Fügt Reshards für Sharding-Konflikte bei Funktionen und Aufrufen ein.

Fügt Reshards für Sharding-Konflikte bei Funktionen und Aufrufen für Ergebnisse ein.

-sdy-optimize-collectives

Optimiert kollektive Kommunikationsvorgänge.

Entfernt redundante kollektive Permutationsvorgänge vor All-to-All-Ketten, indem Dimensionen aufgeteilt und zu einem kombinierten All-to-All zusammengeführt werden.

-sdy-pad-for-divisibility

Füllt Tensoren mit nicht teilbaren Shardings auf teilbare Formen auf.

-sdy-per-instruction-partitioning

_Extrahiert selektiv Zielanweisungen, führt die Partitionierungspipeline für sie aus, um gerätespezifischen Code zu generieren, und umschließt sie mit sdy.manualcomputation.

Zu Debugging- und Bisektionszwecken werden einzelne Anweisungen selektiv mit der eigenständigen Shardy-Partitionierungspipeline partitioniert (resolve-permutation-factors, reshard-to-collectives, pad-for-divisibility, convert-global-to-local) und der resultierende gerätespezifische Code wird in sdy.manual_computation eingeschlossen. Der Rest des globalen Programms bleibt unverändert, sodass XLA SPMD nur die nicht eingeschlossenen globalen Anweisungen partitioniert.

Optionen

-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'.
-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).

-sdy-propagate-to-func-results

Gibt Shardings vom Funktionsabschluss an Funktionsergebnisse weiter.

Kopiert die Shardings der Funktionsabschlusswerte in die entsprechenden func.func-Ergebnisse und behält die vorhandenen Shardings für die Hauptfunktion bei.

-sdy-remove-all-gather-reduce-scatter-for-cmv1

_Entfernt sdy.all_gather und sdy.reducescatter für CMV1.

Entfernt All-Gather im Muster All-Gather + Punkt. Entfernt Reduce-Scatter im Muster Punkt + Reduce-Scatter. Dieser Durchlauf dient der Kompatibilität mit Collective Matmul V1 (CMV1). Es handelt sich um eine Übergangslösung für b/432019089.

-sdy-remove-propagation-debug-info

Entfernt Debug-Informationen zur Weitergabe (Weitergabekanten und Ursprungs-Shardings) während des Exports.

-sdy-remove-sharding-groups

Entfernt ShardingGroupOps nach der Weitergabe.

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

Entfernt Unterachsen in Shardings für Eingabe/Ausgabe.

Einige Nutzer von Shardy erwarten, dass die Funktions-Ein-/Ausgaben Shardings ohne Unterachsen haben. In diesem Durchlauf werden Unterachsen und ihre nachfolgenden Achsen aus Shardings für offene Dimensionen für Eingabe/Ausgabe entfernt. Dieser Durchlauf erfolgt normalerweise nach sdy-update-non-divisible-input-output-shardings, um sicherzustellen, dass durch das Entfernen von Unterachsen keine nicht teilbaren Shardings entstehen.

-sdy-reshard-to-collectives

Konvertiert ReshardOp in verschiedene kollektive Shardy-Vorgänge.

Gleicht Reshard-Vorgänge ab und schreibt sie in verschiedene kollektive Shardy-Vorgänge um. Nach diesem Durchlauf sind keine Reshard-Vorgänge mehr im Modul vorhanden.

Optional bleiben nur die redundanten Reshard-Vorgänge übrig, wenn keepRedundantReshards auf „true“ gesetzt ist. Standardmäßig wird davon ausgegangen, dass explizite Reshards bereits eingefügt wurden (sdy-insert-explicit-reshards), und redundante Reshards werden nicht beibehalten. Redundante Reshards sollten beibehalten werden, wenn explizite Reshards möglicherweise noch nicht eingefügt wurden.

Beispiel:

Eingabe:

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

Ausgabe:

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>

Im obigen Beispiel wird der Tensor %0 : tensor<16x2xf32> als \[{"x", "y", "z"}, {}\] geshardet. Dann gibt es einen reshard Vorgang, der ihn als \[{"x"}, {}\] reshardet. Da das Suffix {"y", "z"} nach dem Reshard für die ersten Achsen entfernt wird, schließen wir daraus, dass {"y", "z"} vollständig erfasst wurde. Die zweite Dimension wird nicht geändert.

Optionen

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

-sdy-resolve-permutation-factors

Löst Sharding für Dimensionen auf, die kPermutation-Faktoren zugeordnet sind.

Für das Sharding von Dimensionen mit kPermutation-Faktoren ist möglicherweise eine geräteübergreifende Kommunikation erforderlich (z.B. Halo-Austausch für Fenster oder kollektive Permutationen für Umkehrungen).

Wenn enableHaloExchange auf „true“ gesetzt ist, verwendet der Durchlauf eine verfügbare optimierte Kommunikationslogik, um die Permutationsfaktoren aufzulösen. Andernfalls fügt der Durchlauf einfach sdy.reshard-Vorgänge ein, um diese Dimensionen zu replizieren. Der Standardwert von enableHaloExchange ist „true“.

Optionen

-enable-halo-exchange : Implement halo exchange logic for windowed operations.
-replica-count        : Number of replicas (data parallelism).
-partition-count      : Number of partitions (model parallelism).

-sdy-resolve-single-device-sharding

Reduziert Vorgänge auf einem einzelnen Gerät auf StableHLO, wenn sie durch die Zielgeräte-ID geschützt sind.

Optionen

-replica-count   : Number of replicas per partition.
-partition-count : Number of partitions per replica.

-sdy-sharding-constraint-to-reshard

Konvertiert ShardingConstraintOp in ReshardOp.

-sdy-sink-data-flow-edges

Senkt alle DataFlowEdgeOp in ihre Eingabe ab.

Verschiebt das Sharding jedes DataFlowEdgeOp in seine Eingabe (das Ziel der Kante) und ersetzt den Vorgang durch seine Eingabe.

Optionen

-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

Senkt alle FuncDataFlowEdgeOp in ihre Eingabe ab.

Verschiebt das Sharding jedes FuncDataFlowEdgeOp in seine Eingabe und ersetzt den Vorgang durch seine Eingabe.

-sdy-unflatten-call-graph

Entflacht den Aufrufgraphen.

Entflacht den Graphen. Dabei werden Funktionen mit denselben Shardings für Ein-/Ausgabe und demselben Ursprung dedupliziert, wie durch das Attribut „original_func_name“ beschrieben, das an die Funktionen angehängt ist.

Optionen

-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

Sorgt dafür, dass die Ein-/Ausgaben von FuncOp gleichmäßig geshardet werden, sodass keine Auffüllung aufgrund von nicht teilbaren Shardings erforderlich ist.

Nutzer von Shardy erwarten, dass die Funktions-Ein-/Ausgaben gleichmäßig teilbar/shardbar sind, damit sie ihre Tensoren nicht auffüllen müssen. Durch die Weitergabe können Ein-/Ausgaben nicht teilbare Shardings haben. In diesem Durchlauf werden sie daher auf das größte Sharding-Präfix der ursprünglichen Shardings aktualisiert, das gleichmäßig geshardet ist.

-sdy-verify-unreduced-axes

Prüft die Konsistenz der Verwendung von nicht reduzierten Achsen.

Prüft, ob für jeden Vorgang, wenn seine Operanden nicht reduzierte Achsen haben, der Vorgang sie entweder explizit reduziert (z.B. über sdy.reshard) oder an seine Ergebnisse weitergibt (oder ein begrenzender Vorgang wie func.call ist).