OpenXLA Project

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

`-sdy-close-shardings`

Cierra la fragmentación de tensores y descarta los ejes replicados.

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

Combina las constantes idénticas y las expansiones escalares con fragmentaciones coincidentes.

Realiza una CSE ligera en constantes con fragmentaciones idénticas.

La canalización de importación divide y duplica las constantes y las expansiones escalares de modo que el fragmentado no se propague entre los diferentes usos de un subcálculo constante. Si las constantes tienen el mismo sharding después de la propagación, este paso las combina para ahorrar tiempo de compilación. Consulta -sdy-constant-or-scalar-splitter para obtener más información.

`-sdy-convert-global-to-local`

Convierte un programa de SDY de formas globales a formas locales.

Convierte un programa de SDY de formas globales a formas locales particionando dimensiones lógicas según atributos de fragmentación.

Este paso aprovecha un convertidor de tipos para asignar RankedTensorType desde formas lógicas globales a formas físicas locales del dispositivo.

`-sdy-drop-sharding-rules`

Regalías OpShardingRuleAttr de todas las operaciones registradas.

`-sdy-insert-explicit-reshards`

Inserta fragmentaciones explícitas para que todas las operaciones tengan fragmentaciones compatibles.

Un sharding compatible significa, esencialmente, que la operación puede aceptar los operandos fragmentados y producir un resultado fragmentado sin requerir ninguna comunicación de resharding (ten en cuenta que la operación aún podría requerir comunicación, como all-reduce o halo-swaps).

Después de la propagación, es posible que algunas operaciones sigan teniendo fragmentaciones incompatibles.

Ten en cuenta que, cuando se usa un eje (o subeje) para fragmentar dimensiones no correspondientes (p.ej., dimensiones que no se contraen en matmul) en varios tensores, o cuando un eje fragmenta una dimensión en un tensor, pero no la dimensión correspondiente en el otro tensor, se dice que la operación tiene un conflicto de fragmentación. Por lo tanto, después de este paso, las operaciones dejan de tener conflictos.

Este paso inyecta operaciones de refragmentación de forma explícita para que, en cada operación, las dimensiones correspondientes se fragmenten de la misma manera en todos los operandos y resultados, y cada eje (o subeje) solo se pueda usar para fragmentar un solo tipo de dimensión.

Ejemplo:

Entrada:

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>

Resultado:

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>

En el ejemplo anterior, lhs y rhs se fragmentan en el eje "x" en sus dimensiones no contractivas, lo que es incompatible. El pase inserta un reshard explícito en rhs antes de la operación de punto, de modo que esta tenga fragmentaciones compatibles.

Opciones

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

_Quita sdy.all_gather y sdy.reducescatter para CMV1.

Quita la operación de recopilación total en el patrón de recopilación total + punto. Quita reduce-scatter en el patrón punto + reduce-scatter. Este paso es para la compatibilidad con la multiplicación de matrices colectiva V1 (CMV1). Es una solución temporal para b/432019089.

`-sdy-remove-propagation-debug-info`

Quita la información de depuración de la propagación (bordes de propagación y fragmentación de origen) durante la exportación.

`-sdy-remove-sharding-groups`

Quita ShardingGroupOps después de la propagación.

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

Quita los subejes en las particiones de entrada y salida.

Algunos usuarios de Shardy esperan que las entradas y salidas de la función tengan fragmentaciones sin subejes. Este paso quita los subejes y sus ejes finales de las particiones de entrada y salida. Por lo general, este paso se realiza después de sdy-update-non-divisible-input-output-shardings para garantizar que la eliminación de subejes no introduzca ninguna fragmentación no divisible.

`-sdy-reshard-to-collectives`

Convierte ReshardOp en varias operaciones colectivas de Shardy.

Coincide con las operaciones de cambio de partición y las reescribe en varias operaciones colectivas de Shardy. Después de este paso, no quedarán operaciones de cambio de fragmentación en el módulo.

De manera opcional, si keepRedundantReshards es verdadero, las únicas operaciones de cambio de fragmentación que quedan son las redundantes. De forma predeterminada, se supone que ya se insertaron fragmentaciones explícitas (sdy-insert-explicit-reshards) y no se conservan las fragmentaciones redundantes. Debe conservar los fragmentos redundantes si es posible que aún no se hayan insertado fragmentos explícitos.

Ejemplo:

Entrada:

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

Resultado:

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>

En el ejemplo anterior, el tensor %0 : tensor<16x2xf32> se fragmenta como \[{"x", "y", "z"}, {}\]. Luego, hay una operación de reshard que vuelve a fragmentar como \[{"x"}, {}\]. En los primeros ejes, como el sufijo {"y", "z"} se quita después del nuevo fragmentado, inferimos que tenemos todos los datos recopilados de {"y", "z"}. La segunda dimensión no se cambia.

Opciones

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

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

Convierte ShardingConstraintOp en ReshardOp.

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

Sincroniza todos los DataFlowEdgeOp con su entrada.

Mueve el sharding de cada DataFlowEdgeOp a su entrada (el destino raíz del borde) y reemplaza la operación con su entrada.

Opciones

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

Hace que las entradas y salidas de FuncOp se fragmenten de manera uniforme, lo que elimina la necesidad de relleno debido a fragmentaciones no divisibles.

Los usuarios de Shardy esperan que las entradas y salidas de la función se puedan dividir o fragmentar de manera uniforme para evitar tener que agregar relleno a sus tensores. La propagación puede hacer que las entradas o salidas tengan fragmentaciones no divisibles, por lo que este pase las actualiza al prefijo de fragmentación de dimensión más grande de la fragmentación original que se fragmenta de manera uniforme.