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

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

बैकग्राउंड

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

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