-sdy-close-shardings

Chiude le suddivisioni dei tensori ed elimina gli assi replicati.

-sdy-constant-merger

Unisci costanti identiche con suddivisioni corrispondenti.

Esegue una crittografia lato client leggera sulle costanti con suddivisioni identiche.

La pipeline di importazione suddivide e duplica le costanti in modo che lo sharding non venga propagato tra usi diversi di un sottocalcolo costante. Se le costanti hanno gli stessi shard dopo la propagazione, questo passaggio le unisce per risparmiare tempo di compilazione.

-sdy-drop-sharding-rules

Abbassa OpShardingRuleAttr da tutte le opzioni registrate.

-sdy-insert-explicit-reshards

Inserisce reshard espliciti per fare in modo che tutte le operazioni abbiano suddivisioni compatibili.

Uno sharding compatibile significa essenzialmente che l'operazione può accettare gli operatori suddivisi in parti e produrre un risultato suddiviso in parti senza richiedere comunicazioni di suddivisione in parti (tieni presente che l'operazione potrebbe comunque richiedere comunicazioni come all-reduce o halo-swap).

Dopo la propagazione, alcune operazioni potrebbero avere ancora partizioni incompatibili.

Tieni presente che quando un asse (o un asse secondario) viene utilizzato per suddividere dimensioni non corrispondenti (ad es. dimensioni non contrattabili in matmul) in più tensori o quando un asse suddivide una dimensione in un tensore, ma non la dimensione corrispondente nell'altro tensore, si dice che l'operazione presenta un conflitto di suddivisione. Di conseguenza, dopo questo passaggio, le operazioni diventano senza conflitti.

Questo passaggio inserisce esplicitamente le operazioni di suddivisione in modo che, per ogni operazione, le dimensioni corrispondenti vengano suddivise nello stesso modo in tutti gli operandi e i risultati e ogni asse (o sottoasse) possa essere utilizzato solo per suddividere un singolo tipo di dimensione.

Esempio:

Input:

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>

Output:

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>

Nell'esempio precedente, lhs e rhs sono entrambi suddivisi in parti sull'asse "x" per le loro dimensioni non contrattabili, il che è incompatibile. Il pass inserisce un reshard esplicito su rhs prima dell'operazione con punto, in modo che l'operazione con punto abbia suddivisioni compatibili.

-sdy-remove-sharding-groups

Rimuove ShardingGroupOps dopo la propagazione.

-sdy-reshard-to-collectives

Converte ReshardOp in varie operazioni collettive Shardy.

Corrisponde alle operazioni di reshard e le riscrive in varie operazioni collettive di Shardy. Dopo questo passaggio, non rimangono operazioni di reshard nel modulo. Questo passaggio presuppone che siano già stati inseriti resharding espliciti (sdy-insert-explicit-reshards).

Esempio:

Input:

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

Output:

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>

Nell'esempio precedente, il tensore %0 : tensor<16x2xf32> viene suddiviso come \[{"x", "y", "z"}, {}\]. Poi c'è un'operazione reshard che esegue il sharding come \[{"x"}, {}\]. Sui primi assi, poiché il suffisso {"y", "z"} viene rimosso dopo il reshard, deduciamo che abbiamo {"y", "z"} all-gathered. La seconda dimensione non viene modificata.

-sdy-sharding-constraint-to-reshard

Converte ShardingConstraintOp in ReshardOp.

-sdy-sink-data-flow-edges

Incanala tutto il DataFlowEdgeOp nell'input.

Sposta lo sharding di ogni DataFlowEdgeOp al relativo input (il target principale dell'edge) e sostituisce l'operazione con il relativo input.

Opzioni

-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-temp-explicit-reshards-for-optimizations

Inserisce reshard espliciti per ottimizzazioni specifiche.

Questo permesso è una soluzione temporanea finché non potremo attivare il permesso sdy-insert-explicit-reshards per impostazione predefinita.

Ci consente di inserire reshard espliciti su operazioni specifiche per le ottimizzazioni.

-sdy-update-non-divisible-input-output-shardings

Esegue lo sharding uniforme degli input/output di FuncOp, eliminando la necessità di spaziatura aggiuntiva a causa di sharding non divisibile.

Gli utenti di Shardy si aspettano che gli input/output della funzione siano equamente divisibile/suddividibili per evitare di dover aggiungere spazi ai tensori. La propagazione può fare in modo che gli input/output abbiano suddivisioni non divisibile, quindi questo passaggio li aggiorna al prefisso di suddivisione delle dimensioni più grande del suddivisione originale che è suddiviso in modo uniforme.