-sdy-close-shardings
Chiude gli sharding dei tensori ed elimina gli assi replicati.
-sdy-constant-or-scalar-merger
Unire costanti e espansioni scalari identiche con sharding corrispondenti.
Esegue un'eliminazione delle sottoespressioni comuni leggera sulle costanti con sharding identici.
La pipeline di importazione suddivide e duplica le espansioni costanti e scalari in modo che lo sharding non venga propagato tra i diversi utilizzi di un sottocalcolo costante. Se le costanti hanno gli stessi shard dopo la propagazione, questo passaggio le unisce per risparmiare tempo di compilazione. Per ulteriori informazioni, vedi -sdy-constant-or-scalar-splitter.
-sdy-convert-global-to-local
Converte un programma SDY da forme globali a forme locali.
Converte un programma SDY da forme globali a forme locali partizionando le dimensioni logiche in base agli attributi di sharding.
Questa passata utilizza un convertitore di tipi per mappare RankedTensorType dalle forme logiche globali alle forme fisiche locali del dispositivo.
-sdy-drop-sharding-rules
Gocce OpShardingRuleAttr da tutte le operazioni registrate.
-sdy-insert-explicit-reshards
Inserisce i ripartizionamenti espliciti per rendere tutte le operazioni compatibili.
Uno sharding compatibile significa essenzialmente che l'operazione può accettare gli operandi suddivisi in shard e produrre un risultato suddiviso in shard senza richiedere comunicazioni di resharding (tieni presente che l'operazione potrebbe comunque richiedere comunicazioni come all-reduce o halo-swap).
Dopo la propagazione, alcune operazioni potrebbero ancora avere partizionamenti incompatibili.
Tieni presente che quando un asse (o un asse secondario) viene utilizzato per suddividere dimensioni non corrispondenti (ad es. dimensioni non contrattuali 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 sharding. Pertanto, dopo questo passaggio, le operazioni diventano senza conflitti.
Questa passata inserisce esplicitamente le operazioni di resharding 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 sull'asse "x" nelle rispettive dimensioni non contrattuali, il che è incompatibile. Il pass inserisce un
reshard esplicito su rhs prima dell'operazione punto, in modo che l'operazione punto
abbia sharding compatibili.
Opzioni
-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
_Removes sdy.all_gather and sdy.reducescatter for CMV1.
Rimuove l'all-gather nel pattern all-gather + punto. Rimuove reduce-scatter nel pattern punto + reduce-scatter. Questo passaggio è per la compatibilità con matmul collettivo V1 (CMV1). Si tratta di una soluzione temporanea per il bug b/432019089.
-sdy-remove-propagation-debug-info
Rimuove le informazioni di debug della propagazione (bordi di propagazione e partizionamenti di origine) durante l'esportazione.
-sdy-remove-sharding-groups
Rimuove ShardingGroupOps dopo la propagazione.
-sdy-remove-sub-axes-in-input-output-shardings
Rimuove gli assi secondari negli sharding di input/output.
Alcuni utenti di Shardy si aspettano che gli input/output della funzione abbiano sharding
senza assi secondari. Questa passata rimuove gli assi secondari e i relativi assi finali dalle
distribuzioni degli input/output. Questo passaggio viene eseguito in genere dopo
sdy-update-non-divisible-input-output-shardings per garantire che la rimozione
degli assi secondari non introduca suddivisioni non divisibili.
-sdy-reshard-to-collectives
Converte ReshardOp in varie operazioni collettive Shardy.
Corrisponde alle operazioni di reshard e le riscrive in varie operazioni collettive Shardy. Dopo questo passaggio, nel modulo non rimangono operazioni di resharding.
Se keepRedundantReshards è true, le uniche operazioni di resharding che
rimangono sono quelle ridondanti. Per impostazione predefinita, presuppone che siano già stati inseriti
i ripartizionamenti espliciti (sdy-insert-explicit-reshards) e non
mantiene i ripartizionamenti ridondanti. Deve conservare i resharding ridondanti se i resharding espliciti potrebbero non essere ancora stati inseriti.
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> è suddiviso in \[{"x", "y", "z"}, {}\]. Poi, c'è un'operazione di resharding reshard che lo trasforma in \[{"x"}, {}\]. Sui primi assi, poiché il suffisso {"y", "z"} viene rimosso
dopo il resharding, deduciamo di aver raccolto tutti i dati {"y", "z"}. La seconda dimensione non viene modificata.
Opzioni
-keep-redundant-reshards : Whether it keeps redundant reshards or removes.
-sdy-sharding-constraint-to-reshard
Converte ShardingConstraintOp in ReshardOp.
-sdy-sink-data-flow-edges
Sinks all DataFlowEdgeOp into their input.
Sposta lo sharding di ogni DataFlowEdgeOp nel relativo input (la destinazione principale
del bordo) 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-update-non-divisible-input-output-shardings
Rende gli input/output di FuncOp uniformemente suddivisi, eliminando la necessità di padding a causa di suddivisioni non divisibili.
Gli utenti di Shardy si aspettano che gli input/output della funzione siano divisibili/frammentabili in modo uniforme per evitare di dover riempire i tensori. La propagazione potrebbe fare in modo che gli input/output abbiano sharding non divisibili, quindi questo passaggio li aggiorna al prefisso di sharding della dimensione più grande dello sharding originale che è suddiviso in modo uniforme.