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

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

खास जानकारी

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

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

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

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

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

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

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

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

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

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

अतिरिक्त कॉन्टेंट

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