OpenXLA Project

Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

`-sdy-close-shardings`

Cierra las divisiones de tensores y quita los ejes replicados.

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

Combina constantes idénticas y expansiones escalares con divisiones coincidentes.

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

La canalización de importación divide y duplica las constantes y las expansiones escalares de modo que la división no se propague entre los diferentes usos de una subcomputación constante. Si las constantes tienen las mismas divisiones 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 SDY de formas globales a formas locales.

Convierte un programa SDY de formas globales a formas locales mediante la partición de dimensiones lógicas en función de los atributos de división.

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

Opciones

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

Quita la op de malla y la notación de fragmentación del programa.

Opciones

-keep-module-sharding-metadata : Whether to keep module-level sharding metadata (sdy.parameters_shardings and sdy.output_shardings).

`-sdy-drop-sharding-rules`

Quita OpShardingRuleAttr de todas las operaciones registradas.

`-sdy-export-named-computations`

Llama a NamedComputationOp.

Crea un paso que convierte un NamedComputationOp en un CallOp con una nueva función privada llamada name de NamedComputationOp. El nuevo FuncOp y CallOp tienen las mismas divisiones que los operandos o resultados originales de NamedComputationOp.

Si hay una función con el mismo nombre que NamedComputationOp en el módulo, la tabla de símbolos MLIR la cambiará a {name}_#.

`-sdy-insert-explicit-reshards`

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

Una división compatible significa que la operación puede aceptar los operandos divididos y producir un resultado dividido sin requerir ninguna comunicación de división (ten en cuenta que la operación aún puede requerir comunicación, como all-reduce o halo-swaps).

Después de la propagación, es posible que algunas operaciones aún tengan divisiones incompatibles.

Ten en cuenta que, cuando se usa un eje (o subeje) para dividir dimensiones no correspondientes (p.ej., dimensiones no contractivas en matmul) en varios tensores, o cuando un eje divide 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 división. Por lo tanto, después de este paso, las operaciones dejan de tener conflictos.

Este paso inserta operaciones de división de forma explícita para que, en cada operación, las dimensiones correspondientes se dividan de la misma manera en todos los operandos y resultados, y cada eje (o subeje) solo se pueda usar para dividir 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 dividen en el eje "x" en sus dimensiones no contractivas, lo que es incompatible. El paso inserta una división explícita en rhs antes de la operación de punto, de modo que la operación de punto tenga divisiones compatibles.

Opciones

-enable-full-version                     : Enable full version.
-mark-partial-result-with-unreduced-axes : Whether to mark partial reduction results with unreduced axes.

`-sdy-insert-func-call-reshards`

Inserta divisiones para conflictos de división de funciones y llamadas.

Inserta divisiones para conflictos de división de funciones y llamadas en los resultados.

`-sdy-optimize-collectives`

Optimiza las operaciones de comunicación colectiva.

Elimina las operaciones colectivas-permute redundantes que preceden a las cadenas all-to-all mediante la descomposición de las dimensiones divididas y la fusión en un all-to-all combinado.

`-sdy-pad-for-divisibility`

Rellena tensores con divisiones no divisibles a formas divisibles.

`-sdy-per-instruction-partitioning`

Extrae de forma selectiva las instrucciones de destino, ejecuta la canalización de particionador en ellas para generar código local del dispositivo y las encapsula en sdy.manualcomputation.

Para la depuración y la bisección, divide de forma selectiva las instrucciones individuales con la canalización de particionador Shardy independiente (resolve-permutation-factors, reshard-to-collectives, pad-for-divisibility, convert-global-to-local) y encapsula el código local del dispositivo resultante dentro de sdy.manual_computation. Esto mantiene intacto el resto del programa global, por lo que las particiones XLA SPMD solo dividen las instrucciones globales no encapsuladas.

Opciones

-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, func=subroutine'.
-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).
-rng-bit-generator-unsafe : Whether to allow unsafe partitioning of stablehlo.rng_bit_generator.

`-sdy-propagate-to-func-results`

Propaga las divisiones del terminador de funciones a los resultados de las funciones.

Copia las divisiones de los valores del terminador de funciones a los resultados func.func correspondientes, y conserva las divisiones existentes en la función principal.

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

_Quita sdy.all_gather y sdy.reducescatter para CMV1.

Quita all-gather en el patrón all-gather + punto. Quita reduce-scatter en el patrón punto + reduce-scatter. Este paso es para la compatibilidad con la matriz colectiva V1 (CMV1). Es una solución temporal para b/432019089.

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

Quita la información de depuración de propagación (bordes de propagación y divisiones 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 divisiones de entrada/salida.

Algunos usuarios de Shardy esperan que las entradas y salidas de la función tengan divisiones sin subejes. Este paso quita los subejes y sus ejes finales de las divisiones de dimensión abierta de entrada/salida. Este paso suele ser posterior a sdy-update-non-divisible-input-output-shardings para garantizar que la eliminación de subejes no introduzca divisiones no divisibles.

`-sdy-reshard-to-collectives`

Convierte ReshardOp en varias operaciones colectivas de Shardy.

Hace coincidir las operaciones de división y las reescribe en varias operaciones colectivas de Shardy. Después de este paso, no quedan operaciones de división en el módulo.

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

Ejemplo:

Entrada:

mesh = <"x"=2, &q>uot;y"=<2, ">;z"=2
%0 <: tensor16x2xf32 {sdy.sharding>@mesh, \[{"x",< "y", &quo>t;z"<}, {}\]<>/span>
%1 = sdy.reshard %arg0 @mesh, \[{"x"}, {}\] : tensor16x2xf32

Resultado:

mesh = <"x"=2, &q>uot;y"=<2, ">;z"=2
%0 <: tensor16x2xf32 {sdy.sharding>@mesh, \[{"x", "y", "z"}, {}\]<
%1 = sdy.all_gather> \[{&quo<t;y">;, "z"}, {}\] %arg0 out_sharding=@mesh, \[{"x"}, {}\] : tensor16x2xf32

En el ejemplo anterior, el tensor %0 : tensor<16x2xf32> se divide como \[{"x", "y", "z"}, {}\]. Luego, hay una operación reshard que la divide como \[{"x"}, {}\]. En los primeros ejes, como el sufijo {"y", "z"} se quita después de la división, inferimos que hemos recopilado {"y", "z"}. La segunda dimensión no cambia.

Opciones

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

`-sdy-resolve-permutation-factors`

Resuelve la división en dimensiones asignadas a factores kPermutation.

Las dimensiones de división con factores kPermutation pueden requerir comunicación entre dispositivos (p.ej., intercambio de halo para ventanas o permutaciones colectivas para reversas).

Si enableHaloExchange es verdadero, el paso usará una lógica de comunicación optimizada disponible para resolver los factores de permutación. De lo contrario, el paso simplemente insertará operaciones sdy.reshard para replicar esas dimensiones. El valor predeterminado de enableHaloExchange es verdadero.

Opciones

-enable-halo-exchange     : Implement halo exchange logic for windowed operations.
-replica-count            : Number of replicas (data parallelism).
-partition-count          : Number of partitions (model parallelism).
-rng-bit-generator-unsafe : Whether to allow unsafe partitioning of stablehlo.rng_bit_generator.

`-sdy-resolve-single-device-sharding`

Reduce las operaciones de un solo dispositivo a stablehlo.if protegidas por el ID del dispositivo de destino.

Opciones

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

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

Convierte ShardingConstraintOp en ReshardOp.

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

Introduce todos los DataFlowEdgeOp en su entrada.

Mueve la división de cada DataFlowEdgeOp a su entrada (el destino raíz del borde) y reemplaza la operación por 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-sink-func-data-flow-edges`

Introduce todos los FuncDataFlowEdgeOp en su entrada.

Mueve la división de cada FuncDataFlowEdgeOp a su entrada y reemplaza la operación por su entrada.

`-sdy-unflatten-call-graph`

Desacopla el grafo de llamadas.

Desacopla el grafo. Deduplica las funciones con las mismas divisiones de entrada/salida y el mismo origen, como se describe en el atributo "original_func_name" adjunto a las funciones.

Opciones

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

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

Los usuarios de Shardy esperan que las entradas y salidas de la función sean divisibles o divididas de manera uniforme para evitar tener que rellenar sus tensores. La propagación puede hacer que las entradas y salidas tengan divisiones no divisibles, por lo que este paso las actualiza al prefijo de división de dimensión más grande de la división original que se divide de manera uniforme.

`-sdy-verify-unreduced-axes`

Verifica la coherencia del uso de ejes no reducidos.

Verifica que, para cada operación, si sus operandos tienen ejes no reducidos, la operación los reduce de forma explícita (p.ej., a través de sdy.reshard) o los pasa a sus resultados (o es una operación de límite como func.call).