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

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

खास जानकारी

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

इतिहास

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

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

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

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

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

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

कस्टम exec ग्रुप और ऑटोमैटिक exec ग्रुप के बीच अंतर

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

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

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

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'],
        ),
    }
)

AEG का माइग्रेशन

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

Bazel के किन वर्शन पर यह माइग्रेशन काम करता है?

AEG, Bazel 7 से पूरी तरह काम करते हैं.

AEG को कैसे चालू करें?

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

किसी खास नियम के लिए, AEG को कैसे चालू करें?

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

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

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

गड़बड़ी होने पर, AEG को कैसे बंद करें?

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

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

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

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

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

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

अतिरिक्त जानकारी

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