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

समस्या की शिकायत करें सोर्स देखें

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

बैकग्राउंड

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

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

एक्ज़ीक्यूशन ग्रुप तय किए जा रहे हैं

नियम की परिभाषा के दौरान, नियम बनाने वाले लोग, लागू होने वाले ग्रुप के सेट का एलान कर सकते हैं. एक्ज़ीक्यूशन के हर ग्रुप पर, नियम बनाने वाला व्यक्ति यह तय कर सकता है कि एक्ज़ीक्यूशन ग्रुप के लिए एक्ज़ीक्यूशन प्लैटफ़ॉर्म चुनने के लिए ज़रूरी है या नहीं. जैसे, 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"))
    },
)

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

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

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

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

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

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