-sdy-close-shardings

टेंसर को अलग-अलग हिस्सों में बांटने की प्रोसेस बंद कर देता है और डुप्लीकेट किए गए ऐक्सिस हटा देता है.

-sdy-drop-sharding-rules

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

-sdy-insert-explicit-reshards

सभी ऑपरेशन के लिए काम करने वाली shardings बनाने के लिए, साफ़ तौर पर reshards डालता है.

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

प्रोपेगेशन के बाद भी, हो सकता है कि कुछ ऑपरेशन में काम न करने वाली शार्डिंग मौजूद हों.

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

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

इस बारे में साफ़ तौर पर बताने वाला उदाहरण:

इनपुट:

mesh = <"x"=4, "y"=2>
%lhs : tensor<8x32xf32> {sdy.sharding=<@mesh, \[{"y"},{"x"}\]>}
%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 टेंसर को फिर से शेयर किया गया है, ताकि इसे सिर्फ़ अपने पहले डाइमेंशन और अक्ष "x" पर शेयर किया जा सके. इस तरह, बिंदु के साथ काम करने की सुविधा काम करती है.

-sdy-remove-sharding-groups

प्रोपगेशन के बाद, ShardingGroupOps को हटा देता है.

-sdy-sharding-constraint-to-reshard

ShardingConstraintOp को ReshardOp में बदलता है.

-sdy-sink-data-flow-edges

सभी DataFlowEdgeOp को अपने इनपुट में सिंक करता है.

हर DataFlowEdgeOp की शर्डिंग को उसके इनपुट (एज के रूट टारगेट) पर ले जाता है और ऑपरेशन को उसके इनपुट से बदल देता है.

TODO(tomnatan): sharding को उन सभी टारगेट पर ले जाने पर विचार करें जिनमें sharding जोड़ी जा सकती है.

-sdy-update-non-divisible-input-output-shardings

इससे FuncOp के इनपुट/आउटपुट को बराबर हिस्सों में बांटा जाता है. साथ ही, बंटने लायक शर्डिंग न होने की वजह से, पैडिंग की ज़रूरत नहीं होती.

Shardy के उपयोगकर्ताओं को उम्मीद है कि फ़ंक्शन के इनपुट/आउटपुट को बराबर हिस्सों में बांटा जा सकता है/शर्ड किया जा सकता है, ताकि उन्हें अपने टेंसर को पैड करने की ज़रूरत न पड़े. प्रॉपेगेशन की वजह से, इनपुट/आउटपुट में ऐसे शर्ड हो सकते हैं जिन्हें बंटाया नहीं जा सकता. इसलिए, यह पास उन्हें ओरिजनल शर्डिंग के सबसे बड़े डाइमेंशन शर्डिंग प्रीफ़िक्स में अपडेट करता है, जो बराबर हिस्सों में बंट जाता है.