एक्ज़ीक्यूशन ग्रुप के लिए एक ही टारगेट में, एक्ज़ीक्यूशन प्लैटफ़ॉर्म की सुविधा मिलती है. एक्ज़ीक्यूशन के हर ग्रुप की अपनी टूलचेन डिपेंडेंसी होती है और यह अपने टूलचेन रिज़ॉल्यूशन के मुताबिक काम करती है.
बैकग्राउंड
एक्ज़ीक्यूशन समूह से नियम के लेखक की कार्रवाइयों के सेट तय करने में मदद मिलती है. साथ ही, हर कार्रवाई के लिए अलग-अलग तरीके से एक्ज़ीक्यूशन प्लैटफ़ॉर्म भी बनाया जा सकता है. एक्ज़ीक्यूशन के लिए एक से ज़्यादा प्लैटफ़ॉर्म, कार्रवाई को अलग तरीके से चलाने की अनुमति देते हैं. उदाहरण के लिए, रिमोट (Linux) वर्कर पर iOS ऐप्लिकेशन कंपाइल करना और फिर लोकल MAC वर्कर को लिंक करना/कोड साइन करना.
कार्रवाइयों के समूह के बारे में जानकारी देने से, कार्रवाइयों को तय करने के लिए प्रॉक्सी के तौर पर इस्तेमाल किए जाने वाले कामों को कम किया जा सकता है. इस बात की कोई गारंटी नहीं है कि यादगार तरीके से सिर्फ़ एक कार्रवाई की जा सकती है. यह खास मेमोरी और अतिरिक्त कार्रवाइयों को प्रोसेस करने में मददगार है. जैसे, C++ में लिंक करना, मांग के आधार पर कम टास्क असाइन करता है.
एक्ज़ीक्यूशन ग्रुप के बारे में जानकारी देना
नियम की परिभाषा के दौरान, नियमों के लेखक एक्ज़ीक्यूशन ग्रुप के सेट की एलान कर सकते हैं. हर एक्ज़ीक्यूशन ग्रुप पर, नियम बनाने वाला व्यक्ति उन सभी चीज़ों के बारे में बता सकता है जो उस एक्ज़ीक्यूशन ग्रुप के लिए एक एक्ज़ीक्यूशन प्लैटफ़ॉर्म चुनने के लिए ज़रूरी हैं. जैसे, toolchain की मदद से exec_compatible_with और टूलटिप टाइप के ज़रिए कोई भी कंस्ट्रेंट.
# foo.bzl
my_rule = rule(
_impl,
exec_groups = {
“link”: exec_group(
exec_compatible_with = [ "@platforms//os:linux" ]
toolchains = ["//foo:toolchain_type"],
),
“test”: exec_group(
toolchains = ["//foo_tools:toolchain_type"],
),
},
attrs = {
"_compiler": attr.label(cfg = config.exec("link"))
},
)
ऊपर दिए गए कोड स्निपेट में, देखा जा सकता है कि टूल डिपेंडेंसी, cfg एट्रिब्यूट पैरामीटर और config मॉड्यूल का इस्तेमाल करके, exec ग्रुप के लिए ट्रांज़िशन तय कर सकती है. मॉड्यूल उस exec फ़ंक्शन को दिखाता है जो एक स्ट्रिंग पैरामीटर लेता है, जो उस exec ग्रुप का नाम होता है जिसके लिए डिपेंडेंसी बनाया जाना चाहिए.
स्थानीय नियमों की तरह, test एक्ज़ीक्यूशन ग्रुप, Starlark टेस्ट नियमों पर डिफ़ॉल्ट रूप से मौजूद होता है.
एक्ज़ीक्यूशन ग्रुप को ऐक्सेस करना
नियम लागू करने पर, यह बताया जा सकता है कि एक्ज़ीक्यूशन ग्रुप के एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर कार्रवाइयां करनी चाहिए. ऐसा करने के लिए, आप खास तौर पर ctx.actions.run और ctx.actions.run_shell का इस्तेमाल करने वाले exec_groupकार्रवाई के पैरामीटर का इस्तेमाल करें.
# foo.bzl
def _impl(ctx):
ctx.actions.run(
inputs = [ctx.attr._some_tool, ctx.srcs[0]]
exec_group = "compile",
# ...
)
नियम के लेखक भी एक्ज़ीक्यूशन ग्रुप के समाधान किए गए टूलचेन को ऐक्सेस कर सकते हैं. यह उसी तरह से होगा, जैसे किसी टारगेट के रिज़ॉल्व किए गए टूलचेन को ऐक्सेस किया जाता है:
# foo.bzl
def _impl(ctx):
foo_info = ctx.exec_groups["link"].toolchains["//foo:toolchain_type"].fooinfo
ctx.actions.run(
inputs = [foo_info, ctx.srcs[0]]
exec_group = "link",
# ...
)
एक्ज़ीक्यूशन प्रॉपर्टी सेट करने के लिए, एक्ज़ीक्यूशन ग्रुप का इस्तेमाल करना
एक्ज़ीक्यूशन ग्रुप को exec_properties एट्रिब्यूट के साथ इंटिग्रेट किया गया है. यह एट्रिब्यूट हर नियम में मौजूद होता है. इसकी मदद से, टारगेट लेखक प्रॉपर्टी का एक स्ट्रिंग लिख सकता है. इसके बाद, इसे एक्ज़ीक्यूशन मशीन को भेजा जाता है. उदाहरण के लिए, अगर आपको कुछ प्रॉपर्टी सेट करनी है, तो टारगेट के लिए 'यादें' और कुछ खास कार्रवाइयों को ज़्यादा मेमोरी असाइन करने के लिए, exec_propertiesएक्ज़ीक्यूशन ग्रुप-एग्रीगेट की गई कुंजी
की एंट्री लिखें, जैसे कि:
# BUILD
my_rule(
name = 'my_target',
exec_properties = {
'mem': '12g',
'link.mem': '16g'
}
…
)
exec_group = "link" वाली सभी कार्रवाइयों को exec प्रॉपर्टी
को {"mem": "16g"} के तौर पर डिक्शनरी के तौर पर दिखेगा. जैसा कि आप यहां देखते हैं, एक्ज़ीक्यूशन-ग्रुप-लेवल की सेटिंग, टारगेट-लेवल की सेटिंग को बदल देती हैं.
नेटिव नियमों के लिए एक्ज़ीक्यूशन ग्रुप
नेटिव नियमों के मुताबिक तय की गई कार्रवाइयों के लिए, ये एक्ज़ीक्यूशन ग्रुप उपलब्ध हैं:
test: रनर ऐक्शन की जांच करें.cpp_link: C++ जोड़ने की कार्रवाइयां.
एक्ज़ीक्यूशन ग्रुप और प्लैटफ़ॉर्म एक्ज़ीक्यूशन की प्रॉपर्टी
प्लैटफ़ॉर्म टारगेट पर, आर्बिट्रिक एक्ज़ीक्यूशन ग्रुप के लिए exec_properties तय करना मुमकिन है. वहीं, exec_properties सीधे टारगेट पर सेट नहीं होता. इसी तरह, अनजान एक्ज़ीक्यूशन ग्रुप के लिए प्रॉपर्टी अस्वीकार की जाती हैं. टारगेट पूरा होने के बाद, एक्ज़ीक्यूशन प्लैटफ़ॉर्म exec_properties
उदाहरण के लिए, मान लें कि C++ टेस्ट करने के लिए कुछ रिसॉर्स उपलब्ध होने चाहिए, लेकिन कंपाइल करने और जोड़ने के लिए यह ज़रूरी नहीं है. हालांकि, इसे इस तरह से मॉडल किया जा सकता है:
constraint_setting(name = "resource")
constraint_value(name = "has_resource", constraint_setting = ":resource")
platform(
name = "platform_with_resource",
constraint_values = [":has_resource"],
exec_properties = {
"test.resource": "...",
},
)
cc_test(
name = "my_test",
srcs = ["my_test.cc"],
exec_compatible_with = [":has_resource"],
)
टारगेट पर सीधे तौर पर तय किए गए exec_properties को, एक्ज़ीक्यूशन प्लैटफ़ॉर्म से इनहेरिट किए गए पासवर्ड पर प्राथमिकता दी जाती है.