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

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

खास जानकारी

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

कस्टम exec ग्रुप और अपने-आप लागू होने वाले ग्रुप में अंतर

जैसा कि नाम से ही पता चलता है, एईजी हर ग्रुप के लिए अपने-आप बने एक्ज़ेक्यूटिव ग्रुप होते हैं किसी नियम के मुताबिक रजिस्टर किए गए टूलचेन टाइप. इन्हें मैन्युअल तौर पर बताने की ज़रूरत नहीं है, "क्लासिक" से अलग 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 का इस्तेमाल कर रहा है. हालांकि, Basel के वर्शन को Google Play से बाहर माइग्रेट करने की प्रोसेस जारी है. कुछ नियम पहले से ही इस्तेमाल किए जा रहे हैं (उदाहरण के लिए, Java और C++ नियम).

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

बेज़ल 7 पर AEG पूरी तरह से काम करता है.

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

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

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

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

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

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

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

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

AEG में माइग्रेट करते समय गड़बड़ी के मैसेज

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

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

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

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

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

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