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