अपने-आप एक्ज़ीक्यूशन ग्रुप (एईजी)

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

खास जानकारी

अपने-आप काम करने वाले ग्रुप, टूलचेन के साथ काफ़ी हद तक जुड़े होते हैं. अगर टूलचेन का इस्तेमाल किया जा रहा है, तो आपको toolchain पैरामीटर जोड़कर उन्हें उन कार्रवाइयों पर सेट करना होगा जिन पर असर पड़ा है. ये वे कार्रवाइयां होती हैं जो एक्ज़ीक्यूटेबल कार्रवाइयों या टूलचेन के टूल का इस्तेमाल करती हैं. उदाहरण के लिए:

ctx.actions.run(
    ...,
    executable = ctx.toolchain['@bazel_tools//tools/jdk:toolchain_type'].tool,
    ...,
    toolchain = '@bazel_tools//tools/jdk:toolchain_type',
)

अगर कार्रवाई में किसी टूलचेन के टूल या एक्ज़ीक्यूटेबल का इस्तेमाल नहीं किया जाता है और Blaze को यह पता नहीं चलता कि (गड़बड़ी हुई है), तो आप toolchain = None को सेट कर सकते हैं.

अगर आपको एक्ज़ीक्यूशन प्लैटफ़ॉर्म (एक कार्रवाई में दो या उससे ज़्यादा टूलचेन के टूल का इस्तेमाल किया जाता है) पर एक से ज़्यादा टूलचेन का इस्तेमाल करना हो, तो आपको मैन्युअल रूप से exec_groups तय करना होगा. (यह देखें किमुझे कस्टम exec_group कब इस्तेमाल करना चाहिए? सेक्शन).

इतिहास

एईजी से पहले, प्लान लागू करने के प्लैटफ़ॉर्म को नियम के लेवल पर चुना जाता था. उदाहरण के लिए:

my_rule = rule(
    _impl,
    toolchains = ['//tools:toolchain_type_1', '//tools:toolchain_type_2'],
)

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

मौजूदा स्थिति

एईजी की मदद से, हर तरह के टूलचेन के लिए, प्रोग्राम चलाने का प्लैटफ़ॉर्म चुना जाता है. पहले दिए गए उदाहरण my_rule का लागू करने वाला फ़ंक्शन ऐसा दिखेगा:

def _impl(ctx):
    ctx.actions.run(
      mnemonic = "First action",
      executable = ctx.toolchain['//tools:toolchain_type_1'].tool,
      toolchain = '//tools:toolchain_type_1',
    )

    ctx.actions.run(
      mnemonic = "Second action",
      executable = ctx.toolchain['//tools:toolchain_type_2'].tool,
      toolchain = '//tools:toolchain_type_2',
    )

इस नियम के तहत दो कार्रवाइयां बनाई जाती हैं. First action में //tools:toolchain_type_1 की मदद से एक्ज़ीक्यूटेबल का इस्तेमाल किया जाता है और Second action के लिए //tools:toolchain_type_2 की मदद से एक्ज़ीक्यूट किया जा सकता है. एईजी से पहले, इन दोनों कार्रवाइयों को एक ही जगह लागू करने वाले प्लैटफ़ॉर्म पर अंजाम दिया जाता था. यह प्लैटफ़ॉर्म, दोनों टूलचेन टाइप के साथ काम करता था. एईजी की मदद से, कार्रवाइयों में toolchain पैरामीटर जोड़ने पर, हर कार्रवाई टूलचेन उपलब्ध कराने वाले एक्ज़ीक्यूशन प्लैटफ़ॉर्म पर पूरी होती है. कार्रवाइयां, अलग-अलग जगह पर इस्तेमाल की जा सकती हैं.

यह तरीका ctx.actions.run_shell के साथ भी लागू होता है, जहां tools टूलचेन से होने पर toolchain पैरामीटर जोड़ा जाना चाहिए.

कस्टम एक्सपोर्ट ग्रुप और अपने-आप काम करने वाले एक्सपोर्ट ग्रुप के बीच अंतर

जैसा कि नाम से ही पता चलता है कि एईजी, नियम पर रजिस्टर किए गए हर टूलचेन टाइप के लिए अपने-आप बनाए गए एग्ज़िट ग्रुप हैं. इन्हें मैन्युअल तौर पर बताने की कोई ज़रूरत नहीं होती, जैसे कि "क्लासिक" exec ग्रुप.

मुझे कस्टम exec_group का इस्तेमाल कब करना चाहिए?

कस्टम exec_groups की ज़रूरत सिर्फ़ तब होती है, जब एक ही प्लैटफ़ॉर्म पर कई टूलचेन को एक्ज़ीक्यूशन के लिए एक ही प्लैटफ़ॉर्म पर चलाया जाता हो. अन्य सभी मामलों में, कस्टम exec_groups तय करने की ज़रूरत नहीं होती. उदाहरण के लिए:

def _impl(ctx):
    ctx.actions.run(
      ...,
      executable = ctx.toolchain['//tools:toolchain_type_1'].tool,
      tools = [ctx.toolchain['//tools:toolchain_type_2'].tool],
      exec_group = 'two_toolchains',
    )

my_rule = rule(
    _impl,
    exec_groups = {
        "two_toolchains": exec_group(
            toolchains = ['//tools:toolchain_type_1', '//tools:toolchain_type_2'],
        ),
    }
)

एईजी का माइग्रेशन

आंतरिक रूप से google3 में, Blaze पहले से ही AEG का इस्तेमाल कर रहा है. बाहरी तौर पर, Bazel के लिए माइग्रेशन की प्रोसेस जारी है. कुछ नियम पहले से ही इस सुविधा का इस्तेमाल कर रहे हैं (उदाहरण के लिए, Java और C++ नियम).

Bazel के कौनसे वर्शन इस माइग्रेशन के साथ काम करते हैं?

एईजी, Bazel 7 के साथ पूरी तरह से काम करते हैं.

एईजी कैसे चालू करें?

--incompatible_auto_exec_groups को 'सही' पर सेट करें. GitHub की समस्या पर फ़्लैग के बारे में ज़्यादा जानकारी.

किसी खास नियम में एईजी कैसे चालू करें?

किसी नियम पर _use_auto_exec_groups एट्रिब्यूट सेट करें.

my_rule = rule(
    _impl,
    attrs = {
      "_use_auto_exec_groups": attr.bool(default = True),
    }
)

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

कोई गड़बड़ी होने पर, एईजी की सुविधा बंद कैसे करें?

अपने प्रोजेक्ट में एईजी को पूरी तरह से बंद करने के लिए, --incompatible_auto_exec_groups को 'गलत' पर सेट करें (फ़्लैग की GitHub से जुड़ी समस्या) या किसी खास नियम को बंद करने के लिए, _use_auto_exec_groups एट्रिब्यूट को False पर सेट करें (एट्रिब्यूट के बारे में ज़्यादा जानकारी).

एईजी पर माइग्रेट करते समय दिखने वाले गड़बड़ी के मैसेज

यह पता नहीं चल सका कि टूल, इंप्लिसिट डिपेंडेंसी से जुड़े हैं या किसी टूलचेन से. कृपया टूलचेन पैरामीटर सेट करें. अगर टूलचेन का इस्तेमाल नहीं किया जा रहा है, तो इसे 'कोई नहीं' पर सेट करें.

• इस मामले में, गड़बड़ी होने से पहले आपको कई कॉल मिलते हैं. इससे यह साफ़ तौर पर पता चल जाता है कि किस कार्रवाई के लिए टूलचेन पैरामीटर की ज़रूरत है. देखें कि कार्रवाई के लिए किस टूलचेन का इस्तेमाल किया गया है और उसे टूलचेन पैरामीटर के साथ सेट करें. अगर टूल या एक्ज़ीक्यूटेबल की कार्रवाई में किसी टूलचेन का इस्तेमाल नहीं किया गया है, तो इसे None पर सेट करें.

ऐसे टूलचेन '[toolchain_type]' के लिए कार्रवाई का एलान किया गया जो मौजूद नहीं है.

• इसका मतलब है कि आपने कार्रवाई पर टूलचेन पैरामीटर सेट किया है, लेकिन उसे नियम पर रजिस्टर नहीं किया है. टूलचेन को रजिस्टर करें या None को कार्रवाई में सेट करें.

अतिरिक्त सामग्री

ज़्यादा जानकारी के लिए, डिज़ाइन से जुड़ा दस्तावेज़ देखें: टूलचेन के लिए अपने-आप काम करने वाले एक्सपोर्ट ग्रुप.