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

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.
किसी समस्या की शिकायत करें स्रोत देखें

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

बैकग्राउंड

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

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