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

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

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

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