'sdy' উপভাষা

শার্ডি (এসডিওয়াই) উপভাষা

শার্ডি (SDY) ডায়ালেক্ট একটি অ্যাক্সিস-ভিত্তিক টেনসর শার্ডিং উপস্থাপনা এবং টেনসরের সাথে শার্ডিং সংযুক্ত করার জন্য অতিরিক্ত এপিআই উপাদান সংজ্ঞায়িত করে।

সংস্করণ লগ: ০.০.১: TensorShardingAttr-এ অপরিবর্তিত অক্ষগুলো যোগ করা হয়েছে।

অপারেশন

sdy.all_gather (sdy::AllGatherOp)

অক্ষ বরাবর একটি সর্বগ্রাহী যোগাযোগ সম্পাদন করে

সিনট্যাক্স:

operation ::= `sdy.all_gather` $gathering_axes $tensor `out_sharding````=```$out_sharding attr-dict `:` type($result)

gathering_axes এ নির্দিষ্ট করা অক্ষ বরাবর একটি টেনসরের খণ্ডাংশ সংগ্রহ করে।

The gathering_axes is a list of lists of axes. The outer list is over the dimensions of the tensor. Each inner list specifies the axes along which a separate gather should be performed on the respective dimension. It will be applied to the sharding of the operand ( tensor ) to obtain the sharding of the result ( out_sharding ).

Note that out_sharding is not used to determine the sharding of the result. Instead, the sharding of the result is determined by the sharding of the operand and the gathering_axes , and out_sharding must match this inferred sharding.

উদাহরণ:

%1 = stablehlo.tanh(%0) {sdy.sharding = #sdy.sharding_per_value<[<@mesh, [{"a", "b", "c"}, {}, {"d"}\]>]>} : tensor<8x8x8xf32>
%2 = sdy.all_gather [{"b", "c"}, {}, {"d"}\] %1 out_sharding=<@mesh, [{"a"}, {}, {}\]> : tensor<8x8x8xf32>

সীমাবদ্ধতা:

• Sdy_CollectiveOpInterface এ তালিকাভুক্ত সীমাবদ্ধতাগুলো অবশ্যই পূরণ করতে হবে।
• gathering_axes এর উপাদানগুলোকে অবশ্যই AxisRefListAttr এ তালিকাভুক্ত সীমাবদ্ধতাগুলো পূরণ করতে হবে।
• অপারেন্ড sharding-এর উপর gathering_axes প্রয়োগ করলে out_sharding পাওয়া যায়।

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেসসমূহ: InferTypeOpInterface , Sdy_CollectiveOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.all_reduce (sdy::AllReduceOp)

অক্ষ বরাবর একটি সর্ব-হ্রাস যোগাযোগ সম্পাদন করুন

সিনট্যাক্স:

operation ::= `sdy.all_reduce` ($reduction_op^)? $reduction_axes $tensor `out_sharding````=```$out_sharding attr-dict `:` type($result)

reduction_axes এ নির্দিষ্ট করা অক্ষ বরাবর একটি টেনসরের খণ্ডাংশ হ্রাস করে। ফলাফলের জন্য reduction_axes এর ক্রম গুরুত্বপূর্ণ নয়, তবে এটি সংশ্লিষ্ট রেপ্লিকা গ্রুপগুলির ক্রমকে প্রভাবিত করতে পারে।

সীমাবদ্ধতা:

• Sdy_CollectiveOpInterface এ তালিকাভুক্ত সীমাবদ্ধতাগুলো অবশ্যই পূরণ করতে হবে।
• reduction_axes অবশ্যই AxisRefListAttr এ তালিকাভুক্ত সীমাবদ্ধতাগুলো পূরণ করতে হবে।
• reduction_axes অবশ্যই মেশের সাপেক্ষে সর্ট করা থাকতে হবে।
• অপারেন্ড শার্ডিং এবং out_sharding ডাইমেনশন শার্ডিং অবশ্যই সমতুল্য হতে হবে।
• reduction_axes অবশ্যই operand dimension sharding এবং replicated axes-এর সাথে ওভারল্যাপ করবে না (তবে এটি unreduced axes-এর সাথে ওভারল্যাপ করতে পারে)।
• reduction_axes অবশ্যই out_sharding এর অপরিবর্তিত অক্ষগুলোর সাথে ওভারল্যাপ করবে না। অন্য কথায়, out_sharding অবশ্যই reduction_axes বরাবর প্রতিলিপিত হতে হবে (অন্তর্নিহিতভাবে বা সুস্পষ্টভাবে)।

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেসসমূহ: CollectiveOpInterface , InferTypeOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.all_slice (sdy::AllSliceOp)

অক্ষ বরাবর একটি ডাইনামিক-স্লাইস অপারেশন সম্পাদন করে

সিনট্যাক্স:

operation ::= `sdy.all_slice` $slicing_axes $tensor `out_sharding````=```$out_sharding attr-dict `:` type($result)

slicing_axes এ নির্দিষ্ট করা অক্ষ বরাবর একটি টেনসরের খণ্ডাংশ বিভক্ত করে। sdy.all_slice এবং sdy.all_gather মধ্যে একটি বীজগাণিতিক দ্বৈততা রয়েছে।

The slicing_axes is a list of lists of axes. The outer list is over the dimensions of the tensor. Each inner list specifies the axes along which a slice should be performed on the respective dimension. It will be applied to the sharding of the operand ( tensor ) to obtain the sharding of the result ( out_sharding ).

Note that out_sharding is not used to determine the sharding of the result. Instead, the sharding of the result is determined by the sharding of the operand and the slicing_axes , and out_sharding must match this inferred sharding.

উদাহরণ:

%1 = stablehlo.tanh(%0) {sdy.sharding = #sdy.sharding_per_value<[<@mesh, [{"a"}, {}, {}\]>]>} : tensor<8x8x8xf32>
%2 = sdy.all_slice [{"b", "c"}, {}, {"d"}\] %1 out_sharding=<@mesh, [{"a", "b", "c"}, {}, {"d"}\]> : tensor<8x8x8xf32>

সীমাবদ্ধতা:

• Sdy_CollectiveOpInterface এ তালিকাভুক্ত সীমাবদ্ধতাগুলো অবশ্যই পূরণ করতে হবে।
• slicing_axes এর উপাদানগুলোকে অবশ্যই AxisRefListAttr এ তালিকাভুক্ত সীমাবদ্ধতাগুলো পূরণ করতে হবে।
• অপারেন্ড শার্ডিং-এ slicing_axes প্রয়োগ করলে out_sharding পাওয়া যায়।

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেসসমূহ: CollectiveOpInterface , InferTypeOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.all_to_all (sdy::AllToAllOp)

অক্ষ বরাবর সর্বব্যাপী যোগাযোগ সম্পাদন করে

সিনট্যাক্স:

operation ::= `sdy.all_to_all` $params $tensor `out_sharding````=```$out_sharding attr-dict `:` type($result)

For each (axes, src_dim, tgt_dim) tuple in the parameter list, this operation slices chunks of a tensor along dimension tgt_dim and axes specified in axes , scatteres those chunks along the axes, and concatenates them along dimension src_dim .

এই অপারেশনটি মূলত src_dim এবং axes বরাবর একটি অল-গ্যাদার এবং এর পরে tgt_dim এবং axes বরাবর একটি অল-স্লাইসের সমন্বয়, অর্থাৎ, ইনপুট টেনসরের axes শার্ডিং ডাইমেনশন src_dim এর একটি সাফিক্স আউটপুট টেনসরের axes শার্ডিং ডাইমেনশন tgt_dim এর সাথে যুক্ত করা হয়।

ফলাফলের ( out_sharding ) শার্ডিং পাওয়ার জন্য অপারেন্ডের ( tensor ) শার্ডিং-এর উপর অল-টু-অল প্রয়োগ করা হবে।

উল্লেখ্য যে, ফলাফলের শার্ডিং নির্ধারণ করতে out_sharding ব্যবহার করা হয় না। এর পরিবর্তে, ফলাফলের শার্ডিং নির্ধারিত হয় অপারেন্ড, src_dim , tgt_dim এবং axes এর শার্ডিং দ্বারা, এবং out_sharding অবশ্যই এই অনুমিত শার্ডিংয়ের সাথে মিলতে হবে।

উদাহরণ:

%1 = stablehlo.tanh(%0) {sdy.sharding = #sdy.sharding_per_value<[<@mesh, [{"a", "b"}, {"c"}, {}, {}\]>]>} : tensor<8x8x4x4x32>
%2 = sdy.all_to_all [{"b"}: 0->2, {"c"}: 1->3] %1 out_sharding=<@mesh, [{"a"}, {}, {"b"}, {"c"}\]> : tensor<8x8x4x4x32>

সীমাবদ্ধতা:

• Sdy_CollectiveOpInterface এ তালিকাভুক্ত সীমাবদ্ধতাগুলো অবশ্যই পূরণ করতে হবে।
• প্যারামিটার তালিকাটি খালি থাকা যাবে না।
• params এর প্রতিটি প্যারামিটারের জন্য:
  • axes উপাদানগুলিকে অবশ্যই AxisRefAttr এর সীমাবদ্ধতাগুলি পূরণ করতে হবে।
  • src_dim এবং tgt_dim অবশ্যই বৈধ ডাইমেনশন হতে হবে (অঋণাত্মক এবং টেনসরের র‍্যাঙ্কের চেয়ে কম)।
  • যেকোনো src_dim বা tgt_dim অবশ্যই সকল প্যারামিটার জুড়ে অনন্য হতে হবে।
  • সমস্ত প্যারামিটার জুড়ে src_dim অবশ্যই আরোহী ক্রমে সাজানো থাকতে হবে।
• অপারেন্ড শার্ডিং-এ src_dim থেকে tgt_dim এ axes স্থানান্তর করলে out_sharding পাওয়া যায়।

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেসসমূহ: InferTypeOpInterface , Sdy_CollectiveOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.collective_permute (sdy::CollectivePermuteOp)

অক্ষগুলি প্রতিস্থাপন করতে একটি সম্মিলিত-স্থানান্তর যোগাযোগ সম্পাদন করে।

সিনট্যাক্স:

operation ::= `sdy.collective_permute` $tensor `out_sharding````=```$out_sharding attr-dict `:` type($result)

টেনসরটিকে খণ্ডিত করে এমন অক্ষগুলোকে পুনর্বিন্যাস বা প্রতিস্থাপন করার জন্য, প্রতিটি ডিভাইস থেকে ইনপুট টেনসরের একটি অংশ অন্য ডিভাইসে পাঠানো হয়।

A collective permute can transform the input sharding such that each dimension must be as sharded as it was before, ie, it must be sharded along axes whose product of sizes matches that of the axes that previously sharded the tensor.

এটি একটি ডাইমেনশনে বা বিভিন্ন ডাইমেনশন জুড়ে অ্যাক্সিসগুলোর পুনর্বিন্যাস করতে এবং শার্ড অ্যাক্সিসকে রেপ্লিকেটেড অ্যাক্সিসের সাথে অদলবদল করতে উপযোগী।

নিচের উদাহরণে, শার্ডেড টেনসরের আকার হলো tensor<1x4x2xf32> , এবং এটি কালেক্টিভ পারমিউটের মাধ্যমে সংরক্ষিত থাকে।

উদাহরণ:

sdy.mesh @mesh = <["a"=2, "b"=2, "c"=4, "d"=2, "e"=2, "f"=2]>
%1 = stablehlo.tanh(%0) {sdy.sharding = #sdy.sharding_per_value<[<@mesh, [{"a", "c"}, {"f"}, {"d", "e"}\]>]>} : tensor<8x8x8xf32>
%2 = sdy.collective_permute %1 out_sharding=<@mesh, [{"c":(1)2, "b", "f"}, {"a"}, {"e", "d"}\]> : tensor<8x8x8xf32>

সীমাবদ্ধতা:

• Sdy_CollectiveOpInterface এ তালিকাভুক্ত সীমাবদ্ধতাগুলো অবশ্যই পূরণ করতে হবে।
• যদি ইনপুট এবং আউটপুট শার্ডিং-এর মেশগুলো ভিন্ন হয়, তাহলে সেই মেশগুলোর অক্ষগুলো অবশ্যই হুবহু একই হতে হবে এবং ডিভাইস আইডিগুলোর ক্রম ভিন্ন হবে।
• প্রতিটি ডাইমেনশনের জন্য, out_sharding এ থাকা শার্ডিং অ্যাক্সিস সাইজগুলোর গুণফল অবশ্যই সংশ্লিষ্ট অপারেন্ড ডাইমেনশন শার্ডিং-এর গুণফলের সাথে মিলতে হবে।

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেসসমূহ: CollectiveOpInterface , InferTypeOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.constant (sdy::ConstantOp)

অবিরাম কার্যক্রম

একটি ধ্রুবক value থেকে একটি output টেনসর তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

উদাহরণ:

%output = sdy.constant dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait ইমপ্ল বৈশিষ্ট্য

ইন্টারফেসসমূহ: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

বৈশিষ্ট্যসমূহ:

ফলাফল:

sdy.data_flow_edge (sdy::DataFlowEdgeOp)

ডেটা ফ্লো এজ অপ।

সিনট্যাক্স:

operation ::= `sdy.data_flow_edge` $input (`sharding````=``` $sharding^)? attr-dict `:` type($result)

কোনো অপারেশন X-এর একটি ডেটা ফ্লো এজ এক সেট সোর্স (যার প্রতিটি হয় X-এর একটি অপারেন্ড অথবা X-এর ব্লক টার্মিনেটরের একটি অপারেন্ড) এবং এক সেট টার্গেট (যার প্রতিটি হয় X-এর একটি রেজাল্ট অথবা X-এর একটি ব্লক আর্গুমেন্ট)-এর মধ্যে একটি ব্রিজ সংজ্ঞায়িত করে, যাতে সমস্ত সোর্স এবং টার্গেট একই উপায়ে শার্ড করা হয়।

একটি অপারেশনের একাধিক ডেটা ফ্লো এজ থাকতে পারে, যেগুলো একে অপরের সাথে লম্বভাবে অবস্থিত।

উদাহরণস্বরূপ:

  y_0, ..., y_n = while (x_0, ..., x_n)
                  ((pred_arg_0,... , pred_arg_n) { ... })
                  ((body_arg_0,..., body_arg_n) {
                    ...
                    return return_value_0, ..., return_value_n
                  })

এই while op-টির n সংখ্যক ডেটা ফ্লো এজ রয়েছে, যেখানে i-তম ডেটা ফ্লো এজটি সোর্স x_i ও return_value_i এবং টার্গেট y_i , pred_arg_i ও body_arg_i মধ্যে অবস্থিত।

একটি sdy.data_flow_edge ইনপুট হিসেবে একটি এজ-এর মালিককে গ্রহণ করে (এটি যেকোনো টার্গেট হতে পারে, তবে ব্লক আর্গুমেন্টের পরিবর্তে একটি অপ রেজাল্ট হলে ভালো হয়), যার অন্য কোনো ব্যবহার থাকা উচিত নয়। এই অপ-টি পিওর নয়, কারণ এটি এমন একটি ইনপুট নিতে পারে যার মূলত কোনো ব্যবহার ছিল না।

The sdy.data_flow_edge also holds an optional sharding for all targets of the edge, and that sharding should be updated instead of the targets' sharding (if can be attached) during propagation. This is useful when an op has many edges, as it's much more efficient to:

• প্রতিটি প্রান্ত দিয়ে আলাদাভাবে সঞ্চারিত হয়।
• একসাথে সমস্ত টার্গেটের পরিবর্তে প্রতিটি এজের শার্ডিং আলাদাভাবে আপডেট করুন (যেমন, একটি অপ-এর রেজাল্ট শার্ডিং-এর জন্য একটিমাত্র অপরিবর্তনীয় TensorShardingPerValueAttr থাকে)।
• যখন কোনো সোর্সের শার্ডিং পরিবর্তিত হয়, তখন প্রতিটি এজকে আলাদাভাবে ওয়ার্কলিস্টে যুক্ত করুন।

প্রোপাগেশন একটি sdy.data_flow_edge এর সমস্ত সোর্স এবং টার্গেটের মধ্যে শার্ডিংগুলিকে এমনভাবে ছড়িয়ে দেবে, যেন এটি একটি রেগুলার অপ, যেখানে সোর্সগুলি অপারেন্ড এবং টার্গেটগুলি রেজাল্ট, এবং সাথে একটি আইডেন্টিটি sdy.op_sharding_rule রয়েছে। এর মানে হলো, ফরোয়ার্ড প্রোপাগেশন সোর্স থেকে টার্গেটের দিকে এবং ব্যাকওয়ার্ড প্রোপাগেশন টার্গেট থেকে সোর্সের দিকে হয়।

আমরা একটি sdy.data_flow_edge এর ইনপুটকে কোনো SdyDialect op দ্বারা সংজ্ঞায়িত করার অনুমতি দিই না, তাই আমরা ধরে নিতে পারি যে এটি এমন একটি op দ্বারা সংজ্ঞায়িত হয়েছে যার sdy.sharding অ্যাট্রিবিউটটি অনিবন্ধিত।

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেস: InferTypeOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.func_data_flow_edge (sdy::FuncDataFlowEdgeOp)

ফাংশন ইনপুট/আউটপুট ডেটা ফ্লো এজ অপারেশন।

সিনট্যাক্স:

operation ::= `sdy.func_data_flow_edge` $operand attr-dict `:` type($result)

A data flow edge op but for func arguments or call results. When its operand is a BlockArgument; it is a bridge from the caller callOp's argument to the users of the func argument. There is one func data flow edge for each func argument. When its operand is an OpResult; it is a bridge from the called funcOp's return value to the users of the call result. There is one func data flow edge for each call result.

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেস: InferTypeOpInterface , SymbolUserOpInterface

অপারেন্ড:

ফলাফল:

sdy.manual_computation (sdy::ManualComputationOp)

ম্যানুয়াল কালেক্টিভ ব্যবহার করে একাধিক ডিভাইসের সমান্তরাল অপারেশন

সিনট্যাক্স:

operation ::= `sdy.manual_computation` `(`operands`)`
              `in_shardings````=```custom<StrippedTensorShardingPerValueAttr>($in_shardings)
              `out_shardings````=```custom<StrippedTensorShardingPerValueAttr>($out_shardings)
              `manual_axes````=```$manual_axes
              custom<SingleBlockRegionNoBlockId>($body)
              attr-dict
              `:`
              functional-type(operands, results)

এমন একটি অঞ্চলে প্রবেশ করুন যা সুস্পষ্ট কালেক্টিভসহ প্রতি-ডিভাইস স্থানীয় কোডে লেখা, যেখানে লজিক্যাল শেপগুলো স্থানীয় প্রতি-ডিভাইস ফিজিক্যাল বাফার শেপের সাথে মেলে এবং কালেক্টিভগুলো ফিজিক্যাল ক্রস-ডিভাইস কমিউনিকেশনের সাথে হুবহু সঙ্গতিপূর্ণ।

বডিটি manual_axes-এর সাপেক্ষে স্থানীয়। বিস্তার বডির মধ্য দিয়ে যেকোনো মুক্ত অক্ষ বরাবর ঘটবে – অর্থাৎ যেগুলো manual_axes তালিকায় নেই।

উল্লেখ্য যে, যেকোনো র‍্যাঙ্কবিহীন টেনসরের শার্ডিং-এর র‍্যাঙ্ক ০, অর্থাৎ সম্পূর্ণ প্রতিলিপিকৃত হওয়ার কথা।

সীমাবদ্ধতা:

• in_shardings এবং out_shardings এর উপাদানগুলোকে অবশ্যই TensorShardingAttr এ তালিকাভুক্ত সীমাবদ্ধতাগুলো পূরণ করতে হবে।
• অপ অঞ্চলের গ্লোবাল ও লোকাল টেনসর ইনপুট/আউটপুটের সংখ্যা অবশ্যই সমান হতে হবে।
• প্রতিটি ডাইমেনশনাল শার্ডিং-এ ম্যানুয়াল অ্যাক্সিসগুলো অবশ্যই যেকোনো ফ্রি অ্যাক্সিসের আগে থাকতে হবে।
• ম্যানুয়াল অ্যাক্সিসে প্যাডিং যোগ করা যাবে না। অর্থাৎ, ডাইমেনশনের আকার অবশ্যই সংশ্লিষ্ট ম্যানুয়াল অ্যাক্সিসের আকার দ্বারা বিভাজ্য হতে হবে।
• অপ রিজিয়নগুলোর আর্গুমেন্ট/ফলাফলের গ্লোবাল এবং লোকাল আকৃতি অবশ্যই মিলতে হবে।

বৈশিষ্ট্য: IsolatedFromAbove , RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

ইন্টারফেস: ShardableDataFlowOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.mesh (sdy::MeshOp)

নামযুক্ত জাল

সিনট্যাক্স:

operation ::= `sdy.mesh` $sym_name `=` $mesh attr-dict

Defines a new named mesh. All meshes in a module must have the same number of devices (except for meshes with a single device_id). The mesh is a Symbol operation that appears in the module's SymbolTable and can be referenced by its name .

বৈশিষ্ট্য: HasParent<ModuleOp>

ইন্টারফেস: Symbol

বৈশিষ্ট্যসমূহ:

sdy.named_computation (sdy::NamedComputationOp)

Named computation operation

সিনট্যাক্স:

operation ::= `sdy.named_computation` `<`$name`>` `` `(` $operands `)`
              (`in_shardings````=```custom<StrippedTensorShardingPerValueAttr>($in_shardings)^)?
              (`out_shardings````=```custom<StrippedTensorShardingPerValueAttr>($out_shardings)^)?
              custom<SingleBlockRegionNoBlockId>($body)
              attr-dict
              `:` functional-type($operands, results)

একটি গণনা, অর্থাৎ একাধিক অপারেশনের একটি ব্লক, একত্রিত করে এবং এটিকে একটি নাম দেয়। প্রোপাগেশন রিজিয়নটির মধ্যে এমনভাবে প্রবাহিত হবে যেন সবকিছু ইনলাইন করা আছে।

This can be used to handle propagating through call instructions to other functions. Any users of Shardy should write an import/export pass that converts their call ops to sdy.named_computation ops, duplicating/copying the body of the called function into the body of the named_computation .

রিজিয়নের প্রতিটি ব্লক আর্গুমেন্ট এবং রিটার্ন করা ভ্যালুর টাইপ অবশ্যই অপ-এর অপারেন্ড এবং রেজাল্ট টাইপের সমান হতে হবে।

উদাহরণ:

%1 = sdy.named_computation<"foo">(%0) (%arg1: tensor<16x32xf32>) {
  sdy.return %arg1 : tensor<16x32xf32>
} : (tensor<16x32xf32>) -> tensor<16x32xf32>

বৈশিষ্ট্যসমূহ: IsolatedFromAbove , RecursiveMemoryEffects , RecursivelySpeculatableImplTrait , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

ইন্টারফেসসমূহ: ConditionallySpeculatable , InferTypeOpInterface , ShardableDataFlowOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

Operands:

ফলাফল:

sdy.propagation_barrier (sdy::PropagationBarrierOp)

প্রচার বাধা অপারেশন

সিনট্যাক্স:

operation ::= `sdy.propagation_barrier` $input `allowed_direction````=```$allowed_direction attr-dict `:` type($input)

এই অপারেশনটি একটি আইডেন্টিটি অপারেশনের মতো কাজ করে, যা ইনপুট হিসেবে নেওয়া মানটিই আউটপুট হিসেবে দেয়। কিন্তু প্রোপাগেশনের ক্ষেত্রে, এটি কেবল একটি নির্দিষ্ট দিকেই এর মধ্য দিয়ে প্রোপাগেশন প্রবাহিত হতে দেয়।

এটি ব্যারিয়ার অপ-এর ফলাফল এবং এর অপারেন্ডের ব্যবহারের মধ্যে শার্ডিং ছড়িয়ে পড়া প্রতিরোধ করে।

• FORWARD মানে হলো শার্ডিং শুধুমাত্র অপারেন্ড থেকে রেজাল্টের দিকেই প্রবাহিত হতে পারে।
• BACKWARD মানে হলো, শার্ডিং শুধুমাত্র ফলাফল থেকে অপারেন্ডের দিকেই প্রবাহিত হতে পারে।
• NONE মানে এই অপারেশনের মাধ্যমে কোনো শার্ডিং ছড়াতে পারবে না।
• BOTH নির্দিষ্ট করা যাবে না, কারণ এই অপারেশনটি অপ্রয়োজনীয় হবে।

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait , SameOperandsAndResultType

ইন্টারফেসসমূহ: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

প্রভাব: MemoryEffects::Effect{}

বৈশিষ্ট্যসমূহ:

Operands:

ফলাফল:

sdy.reduce_scatter (sdy::ReduceScatterOp)

অক্ষ বরাবর বিক্ষিপ্ততা হ্রাস করে যোগাযোগ সম্পাদন করে।

সিনট্যাক্স:

operation ::= `sdy.reduce_scatter` ($reduction_op^)? $reduce_scatter_axes $tensor `out_sharding````=```$out_sharding attr-dict `:` type($result)

Reduces chunks of a tensor along axes specified in reduce_scatter_axes , and then scatters the result along the same axes. This operation is essentially a combination of an sdy.all_reduce followed by an sdy.all_slice along the same reduce_scatter_axes .

সীমাবদ্ধতা:

• Sdy_CollectiveOpInterface এ তালিকাভুক্ত সীমাবদ্ধতাগুলো অবশ্যই পূরণ করতে হবে।
• reduce_scatter_axes এর উপাদানগুলোকে অবশ্যই AxisRefListAttr এ তালিকাভুক্ত সীমাবদ্ধতাগুলো পূরণ করতে হবে।
• অপারেন্ড শার্ডিং-এর উপর reduce_scatter_axes প্রয়োগ করলে out_sharding পাওয়া যায়।

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেসসমূহ: CollectiveOpInterface , InferTypeOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.replicated_to_unreduced (sdy::ReplicatedToUnreducedOp)

অন্তর্নিহিত বা সুস্পষ্টভাবে প্রতিলিপিকৃত অক্ষগুলোকে অসংকুচিত অক্ষগুলোতে স্থানান্তর করুন।

সিনট্যাক্স:

operation ::= `sdy.replicated_to_unreduced` $axes $tensor `out_sharding````=```$out_sharding attr-dict `:` type($result)

অপারেন্ডের মধ্যে axes অন্তর্নিহিতভাবে বা সুস্পষ্টভাবে প্রতিলিপি করা উচিত। এই অপারেশনটি ফলাফলে সেগুলোকে অপরিবর্তিত রাখে। আমাদের নিম্নলিখিত সম্পর্কটি রয়েছে:

all-reduce(replicated-to-unreduced(x, axes), axes) = x

উদাহরণ:

%1 = stablehlo.tanh(%0) {sdy.sharding = #sdy.sharding_per_value<[<@mesh, [{"b"}, {}, {}\], replicated={"c", "d"}, unreduced={"e"}>]>} : tensor<8x8x8xf32>
%2 = sdy.replicated_to_unreduced {"a", "c", "f"} %1 out_sharding=<@mesh, [{"b"}, {}, {}\], replicated={"d"}, unreduced={"a", "c", "e", "f"}> : tensor<8x8x8xf32>

সীমাবদ্ধতা:

• Sdy_CollectiveOpInterface এ তালিকাভুক্ত সীমাবদ্ধতাগুলো অবশ্যই পূরণ করতে হবে।
• axes অবশ্যই AxisRefListAttr এ তালিকাভুক্ত সীমাবদ্ধতাগুলো পূরণ করতে হবে।
• axes মেশের সাপেক্ষে সাজাতে হবে।
• axes are not empty.
• ইনপুট এবং আউটপুট শার্ডিং-এর ডাইমেনশন শার্ডিং অবশ্যই একই হতে হবে।
• অপারেন্ড শার্ডিং-এ axes অন্তর্নিহিতভাবে বা সুস্পষ্টভাবে প্রতিলিপি করতে হবে।
• inUnreducedAxes + axes = outUnreducedAxes.

Traits: SameOperandsAndResultType

ইন্টারফেসসমূহ: InferTypeOpInterface , Sdy_CollectiveOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.reshard (sdy::ReshardOp)

একটি টেনসরকে ভিন্ন শার্ডিং-এ পুনরায় বিভক্ত করে।

সিনট্যাক্স:

operation ::= `sdy.reshard` $input $sharding attr-dict `:` type($result)

নির্দিষ্ট শার্ডিং ব্যবহার করে ইনপুট টেনসরটিকে পুনরায় শার্ডিং করে, যা ইনপুট টেনসরটির বিদ্যমান শার্ডিং থেকে ভিন্ন।

ShardingConstraintOp এবং ReshardOp উভয়ই একটি টেনসরের সাথে শার্ডিং সংযুক্ত করে। এদের জীবনকাল হলো:

1. শার্ডিং প্রসারণের আগে, ব্যবহারকারীরা ShardingConstraintOp যোগ করেন।
2. শার্ডিং প্রোপাগেশন ShardingConstraintOp ব্যবহার করে। শার্ডিং প্রোপাগেশনের ফলাফলে কোনো ShardingConstraintOp থাকে না। এর পরিবর্তে, প্রয়োজনে ReshardOp যোগ করা হতে পারে।
3. একটি পার্টিশনার একটি ReshardOp-কে একটি কালেক্টিভ অপ (বা একটি আইডেন্টিটি অপ)-এ রূপান্তরিত করে। পার্টিশনারের ফলাফলে কোনো ReshardOp থাকা উচিত নয়।

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait , SameOperandsAndResultType

ইন্টারফেসসমূহ: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , SymbolUserOpInterface

প্রভাব: MemoryEffects::Effect{}

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.return (sdy::ReturnOp)

The sdy.return operation terminates the regions attached to sdy region-based ops and any other Shardy region-based ops. It is variadic: it takes as arguments a list of values whose types can be any (but of the same kind, eg AnyTensor ) and therefore can be reused at various levels of the Shardy IR stack.

সিনট্যাক্স:

operation ::= `sdy.return` attr-dict ($results^ `:` type($results))?

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait , ReturnLike , Terminator

ইন্টারফেসসমূহ: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , RegionBranchTerminatorOpInterface

প্রভাব: MemoryEffects::Effect{}

অপারেন্ড:

sdy.sharded_to_unreduced (sdy::ShardedToUnreducedOp)

অপারেন্ডের কিছু শার্ডেড অক্ষকে ফলাফলের আনরিডিউসড অক্ষে স্থানান্তর করুন।

সিনট্যাক্স:

operation ::= `sdy.sharded_to_unreduced` $axes $tensor `out_sharding````=```$out_sharding attr-dict `:` type($result)

অপারেন্ডকে শার্ড করার জন্য axes ব্যবহার করা উচিত। এই অপারেশনটি ফলাফলে সেগুলোকে আনরিডিউসড করে রাখে। আমাদের মধ্যে নিম্নলিখিত সম্পর্কটি রয়েছে:

all-gather(x, axes) = all-reduce(sharded-to-unreduced(x, axes), axes), যেখানে all-gather, sharded-to-unreduced, all-reduce একই axes-এর উপর প্রয়োগ করা হয়।

উদাহরণ:

%1 = stablehlo.tanh(%0) {sdy.sharding = #sdy.sharding_per_value<[<@mesh, [{"a", "b", "c"}, {}, {"d"}\], unreduced={"e"}>]>} : tensor<8x8x8xf32>
%2 = sdy.sharded_to_unreduced [{"b", "c"}, {}, {"d"}\] %1 out_sharding=<@mesh, [{"a"}, {}, {}\], unreduced={"b", "c", "d", "e"}> : tensor<8x8x8xf32>

সীমাবদ্ধতা:

• Sdy_CollectiveOpInterface এ তালিকাভুক্ত সীমাবদ্ধতাগুলো অবশ্যই পূরণ করতে হবে।
• axes উপাদানগুলিকে অবশ্যই AxisRefListAttr এ তালিকাভুক্ত সীমাবদ্ধতাগুলি পূরণ করতে হবে।
• অপারেন্ড শার্ডিং-এ axes প্রয়োগ করলে out_sharding পাওয়া যায়।

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেসসমূহ: InferTypeOpInterface , Sdy_CollectiveOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

Operands:

ফলাফল:

sdy.sharding_constraint (sdy::ShardingConstraintOp)

একটি টেনসরকে নির্দিষ্ট শার্ডিং-এ সীমাবদ্ধ করে।

সিনট্যাক্স:

operation ::= `sdy.sharding_constraint` $input $sharding attr-dict `:` type($result)

কোনো মধ্যবর্তী টেনসরের (যেমন ম্যাটমাল্টিপল অপারেশনের ফলাফল) সাথে একটি শার্ডিং সংযুক্ত করে এটি নির্দেশ করে যে, ঐ টেনসরটি বা এর ব্যবহারের একটি উপসেটকে এইভাবেই শার্ড করা উচিত।

যদি শার্ডিংটির ডাইমেনশনগুলো খোলা এবং অক্ষগুলো বাধাহীন হয়, তার মানে হলো টেনসরটিকে ওই খোলা ডাইমেনশনগুলো বরাবর আরও শার্ড করা যেতে পারে।

এই অপারেশনটি হতে পারে:

• কোনো ব্যবহার নেই (ড্যাংলিং) - যার অর্থ হলো, সংযুক্ত শার্ডিং অনুযায়ী ইনপুট টেনসরটিকেই শার্ড করা উচিত।
• ব্যবহার আছে - যার অর্থ হলো, সংযুক্ত শার্ডিং অনুসারে শার্ডিং কনস্ট্রেইন্ট অপ-এর ব্যবহারগুলো শার্ড করা উচিত, যেখানে ইনপুট টেনসরের অন্যান্য ব্যবহারের শার্ডিং ভিন্ন হতে পারে (যদি ইনপুট টেনসরের অন্য কোনো ব্যবহার না থাকে, তাহলে এর আচরণ ব্যবহার না থাকার ক্ষেত্রের মতোই হবে)।

বৈশিষ্ট্য: SameOperandsAndResultType

ইন্টারফেস: InferTypeOpInterface , SymbolUserOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

sdy.sharding_group (sdy::ShardingGroupOp)

গ্রুপের অন্তর্গত টেনসরগুলোর শার্ডিং একই হতে বাধ্য করে।

সিনট্যাক্স:

operation ::= `sdy.sharding_group` $input `group_id````=```$group_id attr-dict `:` type($input)

এই অপারেশনটি টেনসরগুলোকে শার্ডিং গ্রুপে (টেনসরের এমন গ্রুপ যেখানে একই রকম শার্ডিং বাধ্যতামূলক করা হবে) বরাদ্দ করার জন্য একটি ইন্টারফেস প্রদান করে। প্রোপাগেশনের সময়, গ্রুপের কোনো একটি উপাদান শার্ড হওয়ার সাথে সাথেই, অন্য সব সদস্যও ঠিক একইভাবে শার্ড হয়ে যাবে। এই অপারেশনটি 'group ID' আর্গুমেন্ট হিসেবে গ্রহণ করে এবং কোনো ফলাফল ফেরত দেয় না, বরং এটি অভ্যন্তরীণ শার্ডিং গ্রুপের উপস্থাপনাকে পরিবর্তন করে ইনপুট টেনসরটিকে প্রদত্ত ID-যুক্ত গ্রুপে যুক্ত করে।

ইন্টারফেস: InferTypeOpInterface

বৈশিষ্ট্যসমূহ:

Operands:

বৈশিষ্ট্য

AllToAllParamAttr

All-to-all parameter

সিনট্যাক্স:

#sdy.all_to_all_param<
  ::llvm::ArrayRef<AxisRefAttr>,   # axes
  int64_t,   # src_dim
  int64_t   # tgt_dim
>

একটি টাপল, যাতে অল-টু-অল অপারেশনটি সম্পাদন করার জন্য অক্ষ এবং উৎস/লক্ষ্য মাত্রাগুলো থাকে।

পরামিতি:

AllToAllParamListAttr

সকল-থেকে-সকল প্যারামিটারের তালিকা

সিনট্যাক্স:

#sdy.all_to_all_param_list<
  ::llvm::ArrayRef<AllToAllParamAttr>   # value
>

পরামিতি:

AxisRefAttr

সম্পূর্ণ অক্ষ বা বিভক্ত উপ-অক্ষের উল্লেখ

সিনট্যাক্স:

#sdy.axis_ref<
  ::llvm::StringRef,   # name
  SubAxisInfoAttr   # sub_axis_info
>

সীমাবদ্ধতা:

• আবদ্ধ MeshAttr এ name অবশ্যই উপস্থিত থাকতে হবে।
• যদি sub_axis_info উপস্থিত থাকে, তবে এটিকে অবশ্যই SubAxisInfoAttr এর শর্তাবলী পূরণ করতে হবে।

পরামিতি:

AxisRefListAttr

অক্ষ রেফারেন্সের তালিকা

সিনট্যাক্স:

#sdy.axis_ref_list<
  ::llvm::ArrayRef<AxisRefAttr>   # value
>

সীমাবদ্ধতা:

• value এর উপাদানগুলিকে অবশ্যই AxisRefAttr এর সীমাবদ্ধতাগুলি পূরণ করতে হবে।
• এমন কোনো সদৃশ অক্ষ-নির্দেশ বা উপ-অক্ষ নেই যা একে অপরের সাথে উপরিপাতিত হয়।
• কোনো দুটি সংলগ্ন অক্ষ-নির্দেশ একই পূর্ণ অক্ষের পরপর দুটি উপ-অক্ষ নয়, অর্থাৎ, সেগুলোকে একটি উপ-অক্ষ বা পূর্ণ অক্ষে একীভূত করা যায়।

পরামিতি:

AxisToPropagationDetailsAttr

একটি নির্দিষ্ট অক্ষ এবং উৎসের জন্য প্রসারণ প্রান্ত প্রবাহের বিশদ বিবরণ।

সিনট্যাক্স:

#sdy.axis_to_propagation_details<
  ::mlir::sdy::AxisRefAttr,   # axis_name
  ::mlir::sdy::EdgeValueRefAttr,   # source
  ::llvm::ArrayRef<EdgeValueRefAttr>   # targets
>

একটি নির্দিষ্ট অক্ষ বরাবর উৎস মানের রেফারেন্সকে লক্ষ্য মানের রেফারেন্সের একটি তালিকার সাথে ম্যাপ করে।

পরামিতি:

ডিমম্যাপিংঅ্যাট্র

List of factor indices for a dimension

একটি খালি তালিকা নির্দেশ করে যে এটি একটি নাল ম্যাপিং (এটি * চিহ্ন দিয়ে পার্স বা প্রিন্ট করা হয়), অর্থাৎ ডাইমেনশনটি কোনো ফ্যাক্টরের সাথে ম্যাপ করা হয়নি।

সীমাবদ্ধতা:

• অন্তত একটি ফ্যাক্টর সূচক রয়েছে।
• Factor indices must be in range [0, $factor_sizes ).
• যদি একাধিক উপাদান থাকে, তবে সেগুলোর কোনোটিরই আকার ১ হতে পারে না।
• কোনো সদৃশ ফ্যাক্টর সূচক নেই।

পরামিতি:

ডাইমেনশনশার্ডিংঅ্যাট্র

Dimension sharding

মেজর থেকে মাইনর পর্যন্ত একটি টেনসর ডাইমেনশনকে শার্ড করার জন্য অ্যাক্সিস নামগুলির তালিকা, ডাইমেনশনটিকে আরও শার্ড করা যাবে কিনা তা নির্দেশকারী একটি বুলিয়ান, এবং এই ডাইমেনশন শার্ডিংয়ের অগ্রাধিকার নির্দেশকারী একটি ঐচ্ছিক পূর্ণসংখ্যা, যা শার্ডিং প্রসারণের সময় অনুসরণ করা হবে। অগ্রাধিকারগুলি ব্যবহারকারীর শার্ডিং অ্যানোটেশন থেকে আসে এবং একটি নিম্ন মান উচ্চতর অগ্রাধিকার নির্দেশ করে। অ্যানোটেশনে অগ্রাধিকার উল্লেখ না থাকলে সর্বোচ্চ অগ্রাধিকারটি ধরে নেওয়া হয়।

সীমাবদ্ধতা:

• axes উপাদানগুলিকে অবশ্যই AxisRefListAttr এ তালিকাভুক্ত সীমাবদ্ধতাগুলি পূরণ করতে হবে।
• যদি কোনো ডাইমেনশন শার্ডিং-এর অগ্রাধিকার থাকে:
  • অগ্রাধিকার ০-এর চেয়ে বেশি বা সমান।
  • মাত্রাটি বদ্ধ হলে তার অন্তত একটি অক্ষ থাকে।

পরামিতি:

EdgeValueRefAttr

টাইপ অফ type একটি ভ্যালু এজ-এর কোনো নির্দিষ্ট ইন্ডেক্সের রেফারেন্স।

সিনট্যাক্স:

#sdy.edge_value_ref<
  `operand` | `result`,   # type
  int64_t   # index
>

পরামিতি:

ListOfAxisRefListsAttr

অক্ষ রেফারেন্স তালিকার তালিকা

সিনট্যাক্স:

#sdy.list_of_axis_ref_lists<
  ::llvm::ArrayRef<AxisRefListAttr>   # value
>

পরামিতি:

ManualAxesAttr

সেইসব অক্ষের তালিকা যেগুলিতে একটি ManualComputationOp ম্যানুয়ালি কাজ করে।

সিনট্যাক্স:

#sdy.manual_axes<
  ::llvm::ArrayRef<StringAttr>   # value
>

পরামিতি:

মেশঅ্যাট্র

অক্ষের জাল এবং ডিভাইসগুলির একটি তালিকা

সিনট্যাক্স:

#sdy.mesh<
  ::llvm::ArrayRef<MeshAxisAttr>,   # axes
  ::llvm::ArrayRef<int64_t>   # device_ids
>

একটি মেশ হলো অক্ষগুলোর একটি তালিকা এবং ডিভাইসগুলোর ক্রম নির্দিষ্টকারী ডিভাইস আইডিগুলোর একটি ঐচ্ছিক তালিকা।

If the list of axes is empty

• যদি device_ids প্রদান করা না হয়, তবে এটি একটি খালি মেশ।
• যদি device_ids প্রদান করা হয়, তবে তা অবশ্যই একটি একক অঋণাত্মক পূর্ণসংখ্যা হতে হবে, যাকে আমরা ম্যাক্সিমাল-শার্ডিং মেশ বলি।

যদি অক্ষগুলির তালিকা প্রদান করা হয়

• যদি একটি ডিভাইস আইডি তালিকা নির্দিষ্ট করা থাকে, তবে অক্ষগুলোর মাপের গুণফল ডিভাইসের সংখ্যার সমান হতে হবে।
• যদি কোনো ডিভাইস আইডি তালিকা নির্দিষ্ট করা না থাকে, তাহলে অন্তর্নিহিত ডিভাইস আইডি তালিকাটি হলো iota(product(axes))। সরলতার জন্য, আমরা iota(product(axes))-এর অনুরূপ কোনো ডিভাইস আইডি তালিকা নির্দিষ্ট করার অনুমতিও দিই না; এই ক্ষেত্রে, কোনো ডিভাইস আইডি তালিকা নির্দিষ্ট করা উচিত নয়।
• অক্ষগুলোর মোট আকার ১ হলেও এটি একটি ম্যাক্সিমাল-শার্ডিং মেশ নয়।

এখানে মেশের কিছু উদাহরণ দেওয়া হলো:

• একটি খালি মেশ একটি প্লেসহোল্ডার মেশকে প্রতিনিধিত্ব করে যা প্রসারণের সময় প্রতিস্থাপন করা যেতে পারে: <[]>
• অক্ষ তালিকা ছাড়া একটি মেশ এবং একটি একক অ-ঋণাত্মক ডিভাইস আইডি, যা একটি সর্বাধিক-শার্ডিং মেশ: <[], device_ids=[3]>
• দুটি অক্ষ এবং অন্তর্নিহিত ডিভাইস আইডি iota(6) সহ একটি জাল: <["a"=2, "b"=3]>
• দুটি অক্ষ এবং ডিভাইসের ক্রম নির্দিষ্টকারী সুস্পষ্ট ডিভাইস আইডি সহ একটি মেশ: <["a"=3, "b"=2], device_ids=[0, 2, 4, 1, 3, 5]>

সীমাবদ্ধতা:

• device_ids এর উপাদানগুলো অঋণাত্মক হতে হবে।
• যদি axes খালি থাকে, তাহলে device_ids এর সাইজ 0 (খালি মেশ) বা 1 (সর্বোচ্চ-শার্ডিং মেশ) হতে পারে।
• যদি axes খালি না থাকে,
  • axes উপাদানগুলোর নাম একই হতে পারবে না।
  • যদি device_ids নির্দিষ্ট করা থাকে, তাহলে মূল device_ids iota(product(axis_sizes)) নয় এবং সাজানো device_ids হলো iota(product(axis_sizes)) ।

পরামিতি:

মেশঅ্যাক্সিসঅ্যাট্র

Named axis in a mesh

সিনট্যাক্স:

#sdy.mesh_axis<
  ::llvm::StringRef,   # name
  int64_t   # size
>

পরামিতি:

OpShardingRuleAttr

একটি অপারেশনকে কীভাবে বিভক্ত করা যেতে পারে তা নির্দিষ্ট করে।

সিনট্যাক্স:

#sdy.op_sharding_rule<
  ::llvm::ArrayRef<int64_t>,   # factor_sizes
  ::llvm::ArrayRef<TensorMappingAttr>,   # operand_mappings
  ::llvm::ArrayRef<TensorMappingAttr>,   # result_mappings
  ::llvm::ArrayRef<int64_t>,   # reduction_factors
  ::llvm::ArrayRef<int64_t>,   # need_replication_factors
  ::llvm::ArrayRef<int64_t>,   # permutation_factors
  ::llvm::ArrayRef<int64_t>,   # blocked_propagation_factors
  bool   # is_custom_rule
>

একটি শার্ডিং নিয়ম নির্দিষ্ট করে যে, কোনো অপারেশনকে তার বিভিন্ন বৈশিষ্ট্য—যেমন অ্যাট্রিবিউট, অপারেন্ডের গঠন, ফলাফলের গঠন ইত্যাদি—অনুযায়ী কীভাবে বিভক্ত করা যেতে পারে। উদাহরণস্বরূপ:

%0 = stablehlo.add %arg0, %arg1 {
    sdy.sharding_rule = #sdy.op_sharding_rule<
        ([i, j],[i, j])->([i, j])
        {i=8, j=8}>
} : tensor<8x8xf32>

%1 = stablehlo.dot_general %arg2, %arg3, contracting_dims = [1] x [0] {
  sdy.sharding_rule = #sdy.op_sharding_rule<
      ([i, k],[k, j])->([i, j])
      {i=8, j=16, k=8}>
}: (tensor<8x8xf32>, tensor<8x16xf32>) -> tensor<8x16xf32>

Note that we allow factors with size 1 even though they cannot be sharded, this is mainly for completeness as many ops such as pointwise ops have size one dimensions that correspond across operands and results.

ফ্যাক্টরের প্রকারভেদ:

• reduction_factors সেইসব ফ্যাক্টরের সূচক থাকে যেগুলোর হ্রাস প্রয়োজন, যেমন একটি ডট অপারেশনে সংকুচিতকারী ডাইমেনশন। এই ফ্যাক্টরগুলো অপারেন্ডে থাকতে পারে কিন্তু ফলাফলে নয়।
• need_replication_factors সেইসব ফ্যাক্টরের ইনডেক্স থাকে যেগুলোর সম্পূর্ণ রেপ্লিকেশন প্রয়োজন, যেমন একটি সর্ট অপারেশনের সর্টেড ডাইমেনশন।
• permutation_factors সেইসব ফ্যাক্টরের ইন্ডেক্স থাকে যেগুলোর শার্ড করা থাকলে (যেমন একটি প্যাড অপারেশনের প্যাডিং ডাইমেনশন) কালেক্টিভ-পারমিউটের প্রয়োজন হয়।
• অন্যান্য সমস্ত ফ্যাক্টরকে পাস-থ্রু ফ্যাক্টর হিসেবে বিবেচনা করা হয়, অর্থাৎ, এমন ফ্যাক্টর যেগুলোকে তাদের সাথে ম্যাপ করা সমস্ত টেনসরের মধ্যে একই উপায়ে শার্ড করা হলে কোনো যোগাযোগের প্রয়োজন হয় না।

blocked_propagation_factors সেই ফ্যাক্টরগুলো থাকে যেগুলোর মাধ্যমে শার্ডিংগুলোর বিস্তার ঘটানোর অনুমতি নেই। এটি ফ্যাক্টর টাইপগুলোর সাথে অর্থোগোনাল। অর্থাৎ, একটি ব্লকড-প্রোপাগেশন ফ্যাক্টর যেকোনো ফ্যাক্টর টাইপের হতে পারে।

is_custom_rule বর্ণনা করে যে এটি কোনো ব্যবহারকারী দ্বারা সংজ্ঞায়িত নিয়ম কিনা। ব্যবহারকারীরা তাদের কাস্টম কলের জন্য শার্ডিং নিয়ম সংজ্ঞায়িত করতে পারেন অথবা স্ট্যান্ডার্ড অপারেশনের জন্য পূর্ব-সংজ্ঞায়িত শার্ডিং নিয়মগুলোকে ওভাররাইট করতে পারেন। একটি কাস্টম নিয়ম সর্বদা সংরক্ষিত থাকে/কখনোই সরানো হয় না।

সীমাবদ্ধতা:

• অপারেন্ড/ফলাফল ম্যাপিংয়ের সংখ্যা অবশ্যই অপারেশনের অপারেন্ড/ফলাফলের সংখ্যার সাথে মিলতে হবে।
• অন্তত একটি ম্যাপিং আছে (যে অপারেশনের কোনো অপারেন্ড/ফলাফল নেই, তার জন্য কোনো নিয়ম থাকতে পারে না)।
• প্রতিটি TensorMappingAttr এর র‍্যাঙ্ক সংশ্লিষ্ট টেনসর টাইপের র‍্যাঙ্কের সাথে মিলে যায়।
• প্রতিটি ফ্যাক্টর গ্রুপের জন্য ( reduction_factors , need_replication_factors , permutation_factors ):
  • উপাদানগুলি অবশ্যই [0, $factor_sizes ] সীমার মধ্যে থাকতে হবে।
  • প্রতিটি গ্রুপের মধ্যে এবং গ্রুপগুলোর মধ্যে কোনো সদৃশ ফ্যাক্টর সূচক নেই।

পরামিতি:

PropagationEdgesAttr

সমস্ত প্রসারণ ধাপের জন্য প্রসারণ প্রান্তের মেটাডেটা।

সিনট্যাক্স:

#sdy.propagation_edges<
  ::llvm::ArrayRef<PropagationOneStepAttr>   # value
>

ধাপ সূচক অনুসারে বিন্যস্ত, একটি মানের জন্য প্রতি-অক্ষ প্রসারণের বিশদ বিবরণের তালিকা।

পরামিতি:

PropagationOneStepAttr

Per-step propagation metadata.

সিনট্যাক্স:

#sdy.propagation_one_step<
  int64_t,   # step_index
  ::llvm::ArrayRef<AxisToPropagationDetailsAttr>   # axis_entries
>

একটি একক প্রসারণ ধাপের জন্য সমস্ত অক্ষের প্রসারণের বিবরণ।

পরামিতি:

সাবঅ্যাক্সিসইনফোঅ্যাট্রিবিউট

পূর্ণ অক্ষ থেকে এই উপ-অক্ষটি কীভাবে উদ্ভূত হয় সে সম্পর্কিত তথ্য

সিনট্যাক্স:

#sdy.sub_axis_info<
  int64_t,   # pre_size
  int64_t   # size
>

When splitting a full axis into n sub-axes, the axis is reshaped into [k_1,...,k_n], and the ith sub-axis can be expressed by the product of all axis sizes to its left m=prod(k_1,...,k_(i-1)) (aka pre-size) and size k_i. Therefore, the sub-axis-info attribute holds those two numbers and is denoted as follows: (m)k for pre-size m and size k.

সীমাবদ্ধতা:

• pre-size কমপক্ষে ১।
• size ১-এর চেয়ে বড়।
• pre-size অবশ্যই পূর্ণ অক্ষের আকারকে ভাগ করবে, অর্থাৎ, pre-size এবং size উভয়ই পূর্ণ অক্ষের আকারকে ভাগ করবে এবং সাব-অ্যাক্সিস পূর্ণ অক্ষকে অতিক্রম করবে না।
• উপ-অক্ষের আকার সংশ্লিষ্ট পূর্ণ অক্ষের আকারের সমান না হলে, তার পরিবর্তে পূর্ণ অক্ষটি ব্যবহার করা উচিত।

পরামিতি:

TensorMappingAttr

একটি টেনসরের প্রতিটি ডাইমেনশনের জন্য ফ্যাক্টর ম্যাপিং।

সিনট্যাক্স:

#sdy.tensor_mapping<
  ::llvm::ArrayRef<DimMappingAttr>   # dim_mappings
>

সীমাবদ্ধতা:

• dim_mappings এর উপাদানগুলোকে অবশ্যই DimMappingAttr এ থাকা শর্তগুলো পূরণ করতে হবে।
• No duplicate factors indices across dimensions.

পরামিতি:

TensorShardingAttr

টেনসর শার্ডিং

সিনট্যাক্স:

#sdy.sharding<
  ::mlir::Attribute,   # mesh_or_ref
  ::llvm::ArrayRef<DimensionShardingAttr>,   # dim_shardings
  ::llvm::ArrayRef<AxisRefAttr>,   # replicated_axes
  ::llvm::ArrayRef<AxisRefAttr>,   # unreduced_axes
  `sum` | `max` | `min`   # reduction_op
>

A tensor sharding is bound to a specific mesh, and can only reference axis names from that mesh. The dimension shardings tell us for each dimension of the tensor, along which axes (or sub-axes) it is sharded from major to minor. All other axes that don't shard a dimension are either implicitly or explicitly (if they appear in the list of replicated axes) replicated.

মনে রাখবেন যে, কোনো টেনসরের ওপর কোনো শার্ডিং অ্যাট্রিবিউট না থাকা একটি সম্পূর্ণ উন্মুক্ত টেনসর শার্ডিং-এর সমতুল্য।

এই শার্ডিংটি যে মেশের সাথে আবদ্ধ, তা একটি সংশ্লিষ্ট MeshOp সিম্বলকে উল্লেখ করে একটি সিম্বল নাম দ্বারা, অথবা একটি ইনলাইন করা MeshAttr দ্বারা নির্দিষ্ট করা যেতে পারে।

A sharding can have unreduced axes (specified by unreduced_axes ), meaning the tensor is unreduced along these axes. For example, if the contracting dimension of a matmul is sharded along axis x in both the lhs and rhs, the result is unreduced along x . Applying an all-reduce on the tensor along the unreduced axes will make the tensor replicated along those axes. However, a tensor with unreduced axes doesn't have to be all-reduced immediately, it can remain unreduced when passed to linear operations like stablehlo.add (as long as both lhs and rhs are unreduced) and all-reduced afterwards. We assume the reduction type is sum, other reductions may be supported in the future.

সীমাবদ্ধতা:

• dim_shardings এর উপাদানগুলোকে অবশ্যই DimensionShardingAttr এ তালিকাভুক্ত সীমাবদ্ধতাগুলো পূরণ করতে হবে।
• Elements in replicated_axes must satisfy the constraints listed in AxisRefListAttr .
• Elements in unreduced_axes must satisfy the constraints listed in AxisRefListAttr .
• If the corresponding tensor type isn't a ShapedType , the sharding must have rank 0 and no replicated axes.
• If it is a ShapedType , then:
  • The tensor should have a rank.
  • The number of dimension shardings is equal to the rank of the tensor.
  • Dimensions of size 0 aren't sharded.
• There are no duplicate axis-refs or sub-axes that overlap with one another across dim_shardings , replicated_axes , and unreduced_axes .
• Items in replicated_axes and unreduced_axes are ordered wrt mesh_or_ref (see AxisRefAttr::getMeshComparator ).

পরামিতি:

TensorShardingPerValueAttr

Tensor sharding per operand/result of an op

সিনট্যাক্স:

#sdy.sharding_per_value<
  ::llvm::ArrayRef<TensorShardingAttr>   # shardings
>

A list of TensorShardingAttr s, one for each operand/result of an op.

সীমাবদ্ধতা:

• Elements in shardings must satisfy the constraints of TensorShardingAttr .

পরামিতি:

এনাম

EdgeNodeType

Edge node type enum

মামলা:

PropagationDirection

Propagation direction enum

মামলা:

ReductionOp

Reduction op enum

মামলা: