एक्ज़ीक्यूशन ग्रुप

एक्ज़ीक्यूशन ग्रुप एक ही टारगेट में, एक्ज़ीक्यूशन के लिए कई प्लैटफ़ॉर्म की अनुमति देते हैं. हर एक्ज़ीक्यूशन ग्रुप की अपनी टूलचेन डिपेंडेंसी होती है और यह अपना टूलचेन रिज़ॉल्यूशन पूरा करता है.

बैकग्राउंड

एक्ज़ीक्यूशन ग्रुप से नियम के लेखक को कार्रवाइयों के सेट तय करने की सुविधा मिलती है. हर ग्रुप के लिए एक्ज़ीक्यूशन के अलग-अलग प्लैटफ़ॉर्म की सुविधा होती है. कई एक्ज़ीक्यूशन प्लैटफ़ॉर्म से कार्रवाइयों को अलग-अलग तरीके से एक्ज़ीक्यूशन करने की अनुमति मिल सकती है. उदाहरण के लिए, रिमोट (linux) वर्कर पर iOS ऐप्लिकेशन को कंपाइल करना और फिर स्थानीय MAC वर्कर पर लिंक/कोड साइनिंग करना.

कार्रवाइयों के ग्रुप के बारे में जानकारी देने से, ऐक्शन को बताने के लिए प्रॉक्सी के तौर पर कार्रवाई के इस्तेमाल को कम करने में भी मदद मिलती है. इस बात की कोई गारंटी नहीं है कि याद रखने के लिए वे कारगर हों. साथ ही, वे सिर्फ़ एक ऐक्शन के बारे में बता सकती हैं. इससे, खास मेमोरी के लिए ज़्यादा संसाधन तय करने और सी++ में लिंक करने जैसी मुश्किल कार्रवाइयां प्रोसेस करने में मदद मिलती है. साथ ही, इससे कम टास्क की ज़रूरत भी नहीं पड़ती.

एक्ज़ीक्यूशन ग्रुप तय करना

नियम की परिभाषा के दौरान, नियम बनाने वाले एलान ग्रुप के सेट का एलान कर सकते हैं. लागू करने के हर ग्रुप पर, नियम बनाने वाला व्यक्ति वह सब कुछ बता सकता है जो उस एक्ज़ीक्यूशन ग्रुप के लिए एक्ज़ीक्यूशन प्लैटफ़ॉर्म चुनने के लिए ज़रूरी होता है. उदाहरण के लिए, exec_compatible_with और toolchain के ज़रिए टूलचेन टाइप के ज़रिए कोई भी कंस्ट्रेंट.

# 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"))
    },
)

ऊपर दिए गए कोड स्निपेट में, आप देख सकते हैं कि टूल डिपेंडेंसी मॉड्यूल एक exec फ़ंक्शन को दिखाता है जो एकल स्ट्रिंग पैरामीटर लेता है जो कि exec ग्रुप का नाम होता है जिसके लिए डिपेंडेंसी बनाई जानी चाहिए.

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

एक्ज़ीक्यूशन ग्रुप इनहेरिटेंस

अपने कंस्ट्रेंट और टूलचेन की परिभाषा देने के अलावा, एक नया एक्ज़ीक्यूशन ग्रुप यह एलान कर सकता है कि वह copy_from_rule = True पैरामीटर को पास करके, नियम और #39; के डिफ़ॉल्ट एक्ज़ीक्यूशन ग्रुप से इनहेरिट करना चाहता है. copy_from_rule को 'सही' पर सेट करने और exec_compatible_with या toolchains को भी पास करने में गड़बड़ी हुई.

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

# foo.bzl
my_rule = rule(
    _impl,
    exec_groups = {
        “copied”: exec_group(
            copy_from_rule = True,
            # This will inherit exec_compatible_with and toolchains.
            # Setting them here directly would be an error, however.
        ),
    },
    toolchains = ["//foo_tools:toolchain_type"],
    exec_compatible_with = ["@platforms//os:linux"],
)

# BUILD

my_rule(
    name = "demo",
    exec_compatible_with = [":local_constraint"],
)

कॉन्फ़िगर किए गए टारगेट demo के एक्ज़ीक्यूशन ग्रुप copied में ये सभी चीज़ें शामिल होंगी: - //fool_tools:toolchain_type - @platforms//os:linux - :local_constraint

एक्ज़ीक्यूशन ग्रुप को ऐक्सेस करना

नियम लागू करने में, आप यह एलान कर सकते हैं कि कार्रवाइयां, एक्ज़ीक्यूशन ग्रुप के एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर होनी चाहिए. आप ऐसा करने के लिए, exec_group कार्रवाई जनरेट करने वाले पैरामीटर का पैरामीटर, खास तौर पर ctx.actions.run और ctx.actions.run_shell का इस्तेमाल कर सकते हैं.

# 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" की सभी कार्रवाइयों को {"mem": "16g"} के तौर पर शब्दकोश की प्रॉपर्टी दिखाई देंगी. जैसा कि यहां आप देखते हैं, एक्ज़ीक्यूशन ग्रुप लेवल की सेटिंग टारगेट लेवल की सेटिंग को बदल देती हैं.

नेटिव नियमों के लिए एक्ज़ीक्यूशन ग्रुप

नेटिव नियमों के हिसाब से तय की गई कार्रवाइयों के लिए, ये एक्ज़ीक्यूशन ग्रुप उपलब्ध हैं:

• test: रनर कार्रवाइयों की जांच करें.
• cpp_link: C++ लिंक करने की कार्रवाइयां.

निष्पादन प्रॉपर्टी सेट करने के लिए exec समूह बनाना

कभी-कभी आप खास कार्रवाइयों को अलग-अलग कार्रवाई करने के लिए, एक्ज़ीक्यूट ग्रुप का इस्तेमाल करना चाहते हैं. हालांकि, आप असल में नियम से अलग टूलचेन या कंस्ट्रेंट नहीं चाहते. इन स्थितियों के लिए, आप copy_from_rule पैरामीटर का इस्तेमाल करके कसरत करने के ग्रुप बना सकते हैं:

# foo.bzl

# Creating an exec group with `copy_from_rule=True` is the same as explicitly
# setting the exec group's toolchains and constraints to the same values as the
# rule's respective parameters.
my_rule = rule(
    _impl,
    exec_compatible_with = ["@platforms//os:linux"],
    toolchains = ["//foo:toolchain_type"],
    exec_groups = {
        # The following two groups have the same toolchains and constraints:
        “foo”: exec_group(copy_from_rule = True),
        "bar": exec_group(
            exec_compatible_with = ["@platforms//os:linux"],
            toolchains = ["//foo:toolchain_type"],
        ),
    },
)

#

एक्ज़ीक्यूशन ग्रुप और प्लैटफ़ॉर्म एक्ज़ीक्यूशन प्रॉपर्टी

प्लैटफ़ॉर्म टारगेट पर आर्बिट्रेरी एक्ज़ीक्यूशन ग्रुप के लिए, exec_properties को परिभाषित किया जा सकता है. वहीं, exec_properties सीधे टारगेट पर सेट नहीं होता है, जबकि अज्ञात एक्ज़ीक्यूशन ग्रुप के लिए प्रॉपर्टी अस्वीकार की जाती हैं. इसके बाद, टारगेट एक्ज़ीक्यूशन प्लैटफ़ॉर्म's 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 को, टारगेट किए गए प्लैटफ़ॉर्म से इनहेरिट किए जाने वाले टारगेट की तुलना में ज़्यादा अहमियत दी जाती है.