-sdy-close-shardings

टेंसर शार्डिंग को बंद करता है और रेप्लकेट किए गए ऐक्सिस को हटाता है.

-sdy-constant-or-scalar-merger

एक जैसे कॉन्स्टेंट और स्केलर एक्सपैंशन को मैचिंग शार्डिंग के साथ मर्ज करता है.

एक जैसी शार्डिंग वाले कॉन्स्टेंट पर, हल्का-फुल्का CSE करता है.

इंपोर्ट पाइपलाइन, कॉन्स्टेंट और स्केलर एक्सपैंशन को इस तरह से बांटती और डुप्लीकेट करती है कि कॉन्स्टेंट सब-कैलकुलेशन के अलग-अलग इस्तेमाल के बीच शार्डिंग को आगे न बढ़ाया जा सके. अगर कॉन्स्टेंट में आगे बढ़ाने के बाद भी एक जैसी शार्डिंग है, तो यह पास उन्हें मर्ज कर देता है, ताकि कंपाइलेशन में लगने वाला समय बचाया जा सके. ज़्यादा जानकारी के लिए, -sdy-constant-or-scalar-splitter देखें.

-sdy-convert-global-to-local

किसी SDY प्रोग्राम को ग्लोबल शेप से लोकल शेप में बदलता है.

शार्डिंग एट्रिब्यूट के आधार पर, लॉजिकल डाइमेंशन को बांटकर, किसी SDY प्रोग्राम को ग्लोबल शेप से लोकल शेप में बदलता है.

यह पास, रैंक वाले टेंसर टाइप को ग्लोबल लॉजिकल शेप से डिवाइस-लोकल फ़िज़िकल शेप में मैप करने के लिए, टाइप कनवर्टर का इस्तेमाल करता है.

विकल्प

-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

प्रोग्राम से, मेश ऑप और शार्डिंग नोटेशन को हटाता है.

विकल्प

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

-sdy-drop-sharding-rules

रजिस्टर किए गए सभी ऑप से, OpShardingRuleAttr को हटाता है.

-sdy-export-named-computations

NamedComputationOp से कॉल की आउटलाइन बनाता है.

एक ऐसा पास बनाता है जो NamedComputationOp को CallOp में बदलता है. इसमें, NamedComputationOp के name को नाम का एक नया निजी फ़ंक्शन कहा जाता है. नए FuncOp और CallOp में वही शार्डिंग होती है जो ओरिजनल NamedComputationOp के ऑपरेंड/नतीजों में होती है.

अगर मॉड्यूल में NamedComputationOp के नाम वाला कोई फ़ंक्शन है, तो MLIR सिंबल टेबल उसे {name}_# में बदल देगी.

-sdy-insert-explicit-reshards

सभी कार्रवाइयों में, एक जैसी शार्डिंग करने के लिए, साफ़ तौर पर रीशार्डिंग की सुविधा जोड़ता है.

एक जैसी शार्डिंग का मतलब है कि कार्रवाई, शार्ड किए गए ऑपरेंड को स्वीकार कर सकती है और रीशार्डिंग के लिए किसी भी तरह के कम्यूनिकेशन की ज़रूरत के बिना, शार्ड किया गया नतीजा दे सकती है. ध्यान दें कि कार्रवाई के लिए, अब भी कम्यूनिकेशन की ज़रूरत पड़ सकती है. जैसे, ऑल-रिड्यूस या हेलो-स्वैप.

आगे बढ़ाने के बाद भी, कुछ कार्रवाइयों में अलग-अलग शार्डिंग हो सकती हैं.

ध्यान दें कि जब किसी ऐक्सिस (या सब-ऐक्सिस) का इस्तेमाल, कई टेंसर में, नॉन-कॉरस्पॉन्डिंग डाइमेंशन (जैसे, मैटमैल में नॉन-कॉन्ट्रैक्टिंग डाइमेंशन) को शार्ड करने के लिए किया जाता है या जब कोई ऐक्सिस, एक टेंसर में किसी डाइमेंशन को शार्ड करता है, लेकिन दूसरे टेंसर में कॉरस्पॉन्डिंग डाइमेंशन को शार्ड नहीं करता, तो कहा जाता है कि कार्रवाई में शार्डिंग से जुड़ी समस्या है. इसलिए, इस पास के बाद, कार्रवाइयों में शार्डिंग से जुड़ी समस्या नहीं होती.

यह पास, रीशार्डिंग की कार्रवाइयों को साफ़ तौर पर जोड़ता है, ताकि हर कार्रवाई के लिए, कॉरस्पॉन्डिंग डाइमेंशन, सभी ऑपरेंड और नतीजों में एक ही तरीके से शार्ड किए जा सकें. साथ ही, हर ऐक्सिस (या सब-ऐक्सिस) का इस्तेमाल, सिर्फ़ एक डाइमेंशन टाइप को शार्ड करने के लिए किया जा सके.

उदाहरण:

इनपुट:

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 पर साफ़ तौर पर रीशार्डिंग की सुविधा जोड़ता है, ताकि डॉट कार्रवाई में एक जैसी शार्डिंग हो.

विकल्प

-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

कलेक्टिव कम्यूनिकेशन कार्रवाइयों को ऑप्टिमाइज़ करता है.

स्प्लिट डाइमेंशन को डीकंपोज़ करके और कंबाइंड ऑल-टू-ऑल में फ़्यूज़ करके, ऑल-टू-ऑल चेन से पहले मौजूद, फ़ालतू कलेक्टिव-परम्यूट कार्रवाइयों को हटाता है.

-sdy-pad-for-divisibility

नॉन-डिविज़िबल शार्डिंग वाले टेंसर को, डिविज़िबल शेप में पैड करता है.

-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

_CMV1 के लिए, sdy.all_gather और sdy.reducescatter को हटाता है.

ऑल-गैदर + डॉट पैटर्न में, ऑल-गैदर को हटाता है. डॉट + रिड्यूस-स्कैटर पैटर्न में, रिड्यूस-स्कैटर को हटाता है. यह पास, कलेक्टिव मैटमैल 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 को, Shardy के अलग-अलग कलेक्टिव ऑप में बदलता है.

रीशार्ड ऑप को मैच करता है और उन्हें Shardy के अलग-अलग कलेक्टिव ऑप में फिर से लिखता है. इस पास के बाद, मॉड्यूल में कोई रीशार्ड ऑप नहीं रहता.

अगर keepRedundantReshards की वैल्यू 'सही है' पर सेट है, तो सिर्फ़ फ़ालतू रीशार्ड ऑप ही बचे रहते हैं. डिफ़ॉल्ट रूप से, यह मान लिया जाता है कि साफ़ तौर पर रीशार्डिंग की सुविधा पहले ही जोड़ दी गई है (sdy-insert-explicit-reshards). साथ ही, यह फ़ालतू रीशार्डिंग को बरकरार नहीं रखता. अगर साफ़ तौर पर रीशार्डिंग की सुविधा पहले से नहीं जोड़ी गई है, तो इसे फ़ालतू रीशार्डिंग को बरकरार रखना चाहिए.

उदाहरण:

इनपुट:

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

आउटपुट:

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

ऊपर दिए गए उदाहरण में, टेंसर %0 : tensor<16x2xf32> को \[{"x", "y", "z"}, {}\] के तौर पर शार्ड किया गया है. इसके बाद, एक reshard ऑप, इसे \[{"x"}, {}\] के तौर पर रीशार्ड करता है. पहले ऐक्सिस पर, रीशार्ड के बाद सफ़िक्स {"y", "z"} हटा दिया जाता है . इससे हम यह अनुमान लगाते हैं कि हमने {"y", "z"} को ऑल-गैदर किया है. दूसरे डाइमेंशन में कोई बदलाव नहीं किया जाता.

विकल्प

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

-sdy-resolve-permutation-factors

kPermutation फ़ैक्टर पर मैप किए गए डाइमेंशन पर शार्डिंग को हल करता है.

kPermutation फ़ैक्टर वाले शार्डिंग डाइमेंशन के लिए, क्रॉस-डिवाइस कम्यूनिकेशन की ज़रूरत पड़ सकती है. जैसे, विंडो के लिए हेलो एक्सचेंज या रिवर्स के लिए कलेक्टिव परम्यूट.

अगर enableHaloExchange की वैल्यू 'सही है' पर सेट है, तो पास, परम्यूटेशन फ़ैक्टर को हल करने के लिए, ऑप्टिमाइज़ किए गए कम्यूनिकेशन लॉजिक का इस्तेमाल करेगा. इसके अलावा, पास उन डाइमेंशन को रेप्लिकेट करने के लिए, सिर्फ़ 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 की शार्डिंग को उसके इनपुट (एज का रूट टारगेट) में ले जाता है और ऑप को उसके इनपुट से बदल देता है.

विकल्प

-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 की शार्डिंग को उसके इनपुट में ले जाता है और ऑप को उसके इनपुट से बदल देता है.

-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 के उपयोगकर्ता चाहते हैं कि फ़ंक्शन के इनपुट/आउटपुट, बराबर तौर पर डिविज़िबल/शार्ड किए जा सकें, ताकि उन्हें अपने टेंसर को पैड न करना पड़े. आगे बढ़ाने की वजह से, इनपुट/आउटपुट में नॉन-डिविज़िबल शार्डिंग हो सकती है. इसलिए, यह पास उन्हें ओरिजनल शार्डिंग के सबसे बड़े डाइमेंशन शार्डिंग प्रीफ़िक्स में अपडेट करता है, जो बराबर तौर पर शार्ड किया गया हो.

-sdy-verify-unreduced-axes

अनरिड्यूस किए गए ऐक्सिस के इस्तेमाल की सुसंगतता की पुष्टि करता है.

पुष्टि करता है कि हर कार्रवाई के लिए, अगर उसके ऑपरेंड में अनरिड्यूस किए गए ऐक्सिस हैं, तो कार्रवाई या तो उन्हें साफ़ तौर पर रिड्यूस करती है (जैसे, sdy.reshard के ज़रिए) या उन्हें अपने नतीजों में पास करती है. इसके अलावा, यह func.call जैसे बाउंडिंग ऑपरेशन भी हो सकता है.