-sdy-close-shardings

ปิดการแบ่งย่อยของ Tensor และนำแกนที่จำลองออก

-sdy-constant-or-scalar-merger

ผสานค่าคงที่และการขยายสเกลาร์ที่เหมือนกันด้วยการแบ่งย่อยที่ตรงกัน

ดำเนินการ CSE แบบเบาๆ กับค่าคงที่ที่มีการแบ่งย่อยเหมือนกัน

ไปป์ไลน์การนำเข้าจะแยกและทำซ้ำค่าคงที่และการขยายสเกลาร์เพื่อให้ไม่มีการเผยแพร่การแบ่งย่อยระหว่างการใช้งานที่แตกต่างกันของการคำนวณย่อยแบบค่าคงที่ หากค่าคงที่มีการแบ่งย่อยเหมือนกันหลังจากการเผยแพร่ การส่งผ่านนี้จะผสานค่าคงที่เพื่อประหยัดเวลาคอมไพล์ ดูข้อมูลเพิ่มเติมได้ที่ -sdy-constant-or-scalar-splitter

-sdy-convert-global-to-local

แปลงโปรแกรม SDY จากรูปร่างส่วนกลางเป็นรูปร่างในเครื่อง

แปลงโปรแกรม SDY จากรูปร่างส่วนกลางเป็นรูปร่างในเครื่องโดยการแบ่งพาร์ติชันมิติข้อมูลเชิงตรรกะตามแอตทริบิวต์การแบ่งย่อย

การส่งผ่านนี้ใช้ตัวแปลงประเภทเพื่อแมป RankedTensorType จากรูปร่างเชิงตรรกะส่วนกลางเป็นรูปร่างทางกายภาพในอุปกรณ์

ตัวเลือก

-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

นำ Op Mesh และสัญกรณ์การแบ่งย่อยออกจากโปรแกรม

ตัวเลือก

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

-sdy-drop-sharding-rules

นำ OpShardingRuleAttrออกจาก Op ที่ลงทะเบียนทั้งหมด

-sdy-export-named-computations

สรุปการเรียกจาก NamedComputationOp.

สร้างการส่งผ่านที่แปลง NamedComputationOp เป็น CallOp ด้วยฟังก์ชันส่วนตัวใหม่ที่เรียกว่า name ของ NamedComputationOp FuncOp และ CallOp ใหม่มีการแบ่งย่อยเหมือนกับตัวถูกดำเนินการ/ผลลัพธ์ของ NamedComputationOp เดิม

หากมีฟังก์ชันที่มีชื่อเหมือนกับ NamedComputationOp ในโมดูล ตารางสัญลักษณ์ MLIR จะเปลี่ยนชื่อฟังก์ชันเป็น {name}_#

-sdy-insert-explicit-reshards

แทรกการแบ่งย่อยใหม่ที่ชัดเจนเพื่อให้การดำเนินการทั้งหมดมีการแบ่งย่อยที่เข้ากันได้

การแบ่งย่อยที่เข้ากันได้หมายความว่าการดำเนินการสามารถยอมรับตัวถูกดำเนินการที่แบ่งย่อยและสร้างผลลัพธ์ที่แบ่งย่อยได้โดยไม่ต้องมีการสื่อสารการแบ่งย่อยใหม่ (โปรดทราบว่าการดำเนินการอาจยังต้องมีการสื่อสาร เช่น การลดทั้งหมดหรือการสลับฮาโล)

หลังจากการเผยแพร่ การดำเนินการบางอย่างอาจยังมีการแบ่งย่อยที่ไม่เข้ากัน

โปรดทราบว่าเมื่อใช้แกน (หรือแกนย่อย) เพื่อแบ่งย่อยมิติข้อมูลที่ไม่เกี่ยวข้อง (เช่น มิติข้อมูลที่ไม่หดตัวใน Matmul) ใน Tensor หลายรายการ หรือเมื่อแกนแบ่งย่อยมิติข้อมูลใน Tensor หนึ่งรายการแต่ไม่ได้แบ่งย่อยมิติข้อมูลที่เกี่ยวข้องใน Tensor อื่นๆ เราจะกล่าวว่าการดำเนินการมีการขัดแย้งในการแบ่งย่อย ดังนั้น หลังจากการส่งผ่านนี้ การดำเนินการจะไม่มีการขัดแย้ง

การส่งผ่านนี้จะแทรกการดำเนินการแบ่งย่อยใหม่อย่างชัดเจนเพื่อให้การดำเนินการแต่ละรายการ มิติข้อมูลที่เกี่ยวข้องจะถูกแบ่งย่อยในลักษณะเดียวกันในตัวถูกดำเนินการและผลลัพธ์ทั้งหมด และแกน (หรือแกนย่อย) แต่ละแกนจะใช้เพื่อแบ่งย่อยมิติข้อมูลประเภทเดียวเท่านั้น

ตัวอย่าง

อินพุต

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>

เอาต์พุต

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>

ในตัวอย่างด้านบน lhs และ rhs ถูกแบ่งย่อยในแกน "x" ในมิติข้อมูลที่ไม่หดตัว ซึ่งไม่เข้ากัน การส่งผ่านจะแทรกการแบ่งย่อยใหม่ที่ชัดเจนใน rhs ก่อนการดำเนินการ Dot เพื่อให้การดำเนินการ Dot มีการแบ่งย่อยที่เข้ากันได้

ตัวเลือก

-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

แทรกการแบ่งย่อยใหม่สำหรับการขัดแย้งในการแบ่งย่อยของฟังก์ชันและการเรียก

แทรกการแบ่งย่อยใหม่สำหรับการขัดแย้งในการแบ่งย่อยของฟังก์ชันและการเรียกในผลลัพธ์

-sdy-optimize-collectives

เพิ่มประสิทธิภาพการดำเนินการสื่อสารแบบกลุ่ม

ขจัดการดำเนินการ Collective-Permute ที่ซ้ำซ้อนซึ่งนำหน้าเชนแบบ All-to-All โดยการแยกมิติข้อมูลที่แยกออกและผสานเป็นแบบ All-to-All ที่รวมกัน

-sdy-pad-for-divisibility

เพิ่ม Tensor ที่มีการแบ่งย่อยที่ไม่สามารถหารได้ลงในรูปร่างที่สามารถหารได้

-sdy-per-instruction-partitioning

แยกคำสั่งเป้าหมายออกอย่างเลือกสรร เรียกใช้ไปป์ไลน์ตัวแบ่งพาร์ติชันในคำสั่งเหล่านั้นเพื่อสร้างโค้ดในอุปกรณ์ และห่อโค้ดเหล่านั้นใน sdy.manualcomputation

สำหรับการดีบักและการแบ่งครึ่ง ให้แบ่งพาร์ติชันคำสั่งแต่ละรายการอย่างเลือกสรรโดยใช้ไปป์ไลน์ตัวแบ่งพาร์ติชัน Shardy แบบสแตนด์อโลน (resolve-permutation-factors, reshard-to-collectives, pad-for-divisibility, convert-global-to-local) และห่อโค้ดในอุปกรณ์ที่ได้ไว้ใน sdy.manual_computation ซึ่งจะทำให้โปรแกรมส่วนกลางที่เหลืออยู่เหมือนเดิม เพื่อให้พาร์ติชัน XLA SPMD แบ่งพาร์ติชันเฉพาะคำสั่งส่วนกลางที่ไม่ได้ห่อ

ตัวเลือก

-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

เผยแพร่การแบ่งย่อยจากตัวสิ้นสุดฟังก์ชันไปยังผลลัพธ์ของฟังก์ชัน

คัดลอกการแบ่งย่อยของค่าตัวสิ้นสุดฟังก์ชันไปยังผลลัพธ์ func.func ที่เกี่ยวข้อง โดยคงการแบ่งย่อยที่มีอยู่ในฟังก์ชันหลักไว้

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

นำ sdy.all_gather และ sdy.reducescatter ออกสำหรับ CMV1

นำ All-Gather ออกในรูปแบบ All-Gather + Dot นำ Reduce-Scatter ออกในรูปแบบ Dot + Reduce-Scatter การส่งผ่านนี้มีไว้เพื่อให้เข้ากันได้กับ Collective Matmul V1 (CMV1) ซึ่งเป็นโซลูชันชั่วคราวสำหรับ b/432019089

-sdy-remove-propagation-debug-info

นำข้อมูลการแก้ไขข้อบกพร่องการเผยแพร่ (ขอบการเผยแพร่และการแบ่งย่อยต้นทาง) ออกระหว่างการส่งออก

-sdy-remove-sharding-groups

นำ ShardingGroupOps ออกหลังจากการเผยแพร่

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

นำแกนย่อยในการแบ่งย่อยอินพุต/เอาต์พุตออก

ผู้ใช้ Shardy บางรายคาดหวังว่าอินพุต/เอาต์พุตของฟังก์ชันจะมีการแบ่งย่อยโดยไม่มีแกนย่อย การส่งผ่านนี้จะนำแกนย่อยและแกนต่อท้ายออกจากมิติข้อมูลการแบ่งย่อยแบบเปิดของอินพุต/เอาต์พุต โดยปกติแล้วการส่งผ่านนี้จะเกิดขึ้นหลังจากการส่งผ่าน sdy-update-non-divisible-input-output-shardings เพื่อให้แน่ใจว่าการนำแกนย่อยออกจะไม่ทำให้เกิดการแบ่งย่อยที่ไม่สามารถหารได้

-sdy-reshard-to-collectives

แปลง ReshardOp เป็น Op แบบกลุ่มต่างๆ ของ Shardy

จับคู่ Op การแบ่งย่อยใหม่และเขียน Op เหล่านั้นใหม่เป็น Op แบบกลุ่มต่างๆ ของ Shardy หลังจากการส่งผ่านนี้ จะไม่มี Op การแบ่งย่อยใหม่เหลืออยู่ในโมดูล

หาก keepRedundantReshards เป็นจริง Op การแบ่งย่อยใหม่ที่เหลืออยู่จะเป็น Op ที่ซ้ำซ้อนเท่านั้น โดยค่าเริ่มต้น ระบบจะถือว่ามีการแทรกการแบ่งย่อยใหม่ที่ชัดเจนแล้ว (sdy-insert-explicit-reshards) และจะไม่เก็บการแบ่งย่อยใหม่ที่ซ้ำซ้อน ระบบควรเก็บการแบ่งย่อยใหม่ที่ซ้ำซ้อนไว้หากยังไม่ได้แทรกการแบ่งย่อยใหม่ที่ชัดเจน

ตัวอย่าง

อินพุต

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

เอาต์พุต

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>

ในตัวอย่างด้านบน Tensor %0 : tensor<16x2xf32> ถูกแบ่งย่อยเป็น \[{"x", "y", "z"}, {}\] จากนั้นจะมี Op reshard ที่แบ่งย่อยใหม่เป็น \[{"x"}, {}\] ในแกนแรก เนื่องจากมีการนำคำต่อท้าย {"y", "z"} ออก หลังจากการแบ่งย่อยใหม่ เราจึงอนุมานได้ว่าเราได้รวบรวม {"y", "z"} ทั้งหมด มิติข้อมูลที่ 2 ไม่มีการเปลี่ยนแปลง

ตัวเลือก

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

-sdy-resolve-permutation-factors

แก้ปัญหาการแบ่งย่อยในมิติข้อมูลที่แมปกับปัจจัย kPermutation

มิติข้อมูลการแบ่งย่อยที่มีปัจจัย kPermutation อาจต้องมีการสื่อสารข้ามอุปกรณ์ (เช่น การแลกเปลี่ยนฮาโลสำหรับหน้าต่างหรือการสลับแบบกลุ่มสำหรับการย้อนกลับ)

หาก enableHaloExchange เป็นจริง การส่งผ่านจะใช้ตรรกะการสื่อสารที่เพิ่มประสิทธิภาพแล้วที่มีอยู่เพื่อแก้ปัญหาปัจจัยการสลับ มิเช่นนั้น การส่งผ่านจะแทรก Op sdy.reshard เพื่อจำลองมิติข้อมูลเหล่านั้น ค่าเริ่มต้นของ enableHaloExchange คือจริง

ตัวเลือก

-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

ลดการดำเนินการในอุปกรณ์เดียวลงใน StableHLO.if ที่มีการป้องกันด้วยรหัสอุปกรณ์เป้าหมาย

ตัวเลือก

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

-sdy-sharding-constraint-to-reshard

แปลง ShardingConstraintOp เป็น ReshardOp

-sdy-sink-data-flow-edges

รวม DataFlowEdgeOpทั้งหมดไว้ในอินพุต

ย้ายการแบ่งย่อยของ DataFlowEdgeOp แต่ละรายการไปยังอินพุต (เป้าหมายรากของขอบ) และแทนที่ Op ด้วยอินพุต

ตัวเลือก

-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

รวม FuncDataFlowEdgeOpทั้งหมดไว้ในอินพุต

ย้ายการแบ่งย่อยของ FuncDataFlowEdgeOp แต่ละรายการไปยังอินพุตและแทนที่ Op ด้วยอินพุต

-sdy-unflatten-call-graph

ยกเลิกการทำให้กราฟการเรียกแบน

ยกเลิกการทำให้กราฟแบน โดยจะขจัดฟังก์ชันที่ซ้ำกันซึ่งมีการแบ่งย่อยอินพุต/เอาต์พุตเหมือนกัน และ มีต้นทางเดียวกันตามที่อธิบายไว้ในแอตทริบิวต์ 'original_func_name' ที่แนบกับฟังก์ชัน

ตัวเลือก

-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

ทำให้อินพุต/เอาต์พุตของ FuncOp ถูกแบ่งย่อยอย่างเท่าเทียมกัน โดยไม่จำเป็นต้องเพิ่มเนื่องจากการแบ่งย่อยที่ไม่สามารถหารได้

ผู้ใช้ Shardy คาดหวังว่าอินพุต/เอาต์พุตของฟังก์ชันจะสามารถหาร/แบ่งย่อยได้อย่างเท่าเทียมกันเพื่อหลีกเลี่ยงการเพิ่ม Tensor การเผยแพร่จะทำให้อินพุต/เอาต์พุตมีการแบ่งย่อยที่ไม่สามารถหารได้ ดังนั้นการส่งผ่านนี้จะอัปเดตอินพุต/เอาต์พุตเป็นคำนำหน้าการแบ่งย่อยมิติข้อมูลที่ใหญ่ที่สุดของการแบ่งย่อยเดิมที่ถูกแบ่งย่อยอย่างเท่าเทียมกัน

-sdy-verify-unreduced-axes

ตรวจสอบความสอดคล้องของการใช้แกนที่ไม่ลดลง

ตรวจสอบว่าสำหรับการดำเนินการทุกรายการ หากตัวถูกดำเนินการมีแกนที่ไม่ลดลง การดำเนินการจะลดแกนเหล่านั้นอย่างชัดเจน (เช่น ผ่าน sdy.reshard) หรือส่งแกนเหล่านั้นไปยังผลลัพธ์ (หรือเป็นการดำเนินการแบบจำกัด เช่น func.call)