प्लैटफ़ॉर्म पर माइग्रेट करना

समस्या की शिकायत करें सोर्स देखें

Bazel के पास, कई प्लैटफ़ॉर्म और टूलचेन की मॉडलिंग के लिए, बेहतर सहायता है.

इस पेज पर, सहायता की स्थिति के बारे में खास जानकारी दी गई है.

यह भी देखें:

स्थिति

C++

--incompatible_enable_cc_toolchain_resolution के सेट होने पर, C++ नियम टूलचेन चुनने के लिए प्लैटफ़ॉर्म का इस्तेमाल करते हैं.

इसका मतलब है कि C++ प्रोजेक्ट को इनके साथ कॉन्फ़िगर किया जा सकता है:

bazel build //:my_cpp_project --platforms=//:myplatform

न कर पा रहे हैं:

bazel build //:my_cpp_project` --cpu=... --crosstool_top=...  --compiler=...

यह Bazel 7.0 (#7260) में डिफ़ॉल्ट रूप से चालू होगी.

प्लैटफ़ॉर्म पर अपने C++ प्रोजेक्ट की जांच करने के लिए, अपने प्रोजेक्ट को माइग्रेट करना और C++ टूलचेन कॉन्फ़िगर करना देखें.

Java

Java नियम, टूलचेन चुनने के लिए प्लैटफ़ॉर्म का इस्तेमाल करते हैं.

यह --java_toolchain, --host_java_toolchain, --javabase, और --host_javabase लेगसी फ़्लैग की जगह ले लेगा.

ज़्यादा जानकारी के लिए, Java और Bazel देखें.

Android

--incompatible_enable_android_toolchain_resolution के सेट होने पर, Android के नियम, टूलचेन चुनने के लिए प्लैटफ़ॉर्म का इस्तेमाल करते हैं.

इसका मतलब है कि किसी Android प्रोजेक्ट को इनके साथ कॉन्फ़िगर किया जा सकता है:

bazel build //:my_android_project --android_platforms=//:my_android_platform

के बजाय --android_crosstool_top, --android_cpu, और --fat_apk_cpu जैसे लेगसी फ़्लैग के साथ इस्तेमाल किया जा सकता है.

यह Bazel 7.0 (#16285) में डिफ़ॉल्ट रूप से चालू होगी.

प्लैटफ़ॉर्म के साथ अपने Android प्रोजेक्ट की जांच करने के लिए, अपना प्रोजेक्ट माइग्रेट करना देखें.

सेब

Apple के नियम, प्लैटफ़ॉर्म पर काम नहीं करते. साथ ही, उन्हें अभी तक सहायता के लिए शेड्यूल नहीं किया गया है.

आप अब भी Apple के बिल्ड के साथ प्लैटफ़ॉर्म एपीआई का इस्तेमाल कर सकते हैं. उदाहरण के लिए, प्लैटफ़ॉर्म मैपिंग के साथ, Apple के नियमों और शुद्ध C++ का इस्तेमाल करते समय.

अन्य भाषाएं

अगर आपके पास भाषा के नियम का सेट है, तो मदद जोड़ने के लिए अपने नियम सेट को माइग्रेट करना देखें.

बैकग्राउंड

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

इसे प्रेरणा से पता चला कि भाषा का रखरखाव करने वाले लोग, पहले से ही इसे खास तरीकों से कर रहे थे. उदाहरण के लिए, C++ नियमों ने टारगेट सीपीयू और टूलचेन का एलान करने के लिए, --cpu और --crosstool_top का इस्तेमाल किया. इनमें से कोई भी, "प्लैटफ़ॉर्म" के मॉडल को सही नहीं बना रहा. इससे कॉन्टेंट को अजीब और गलत तरीके से डिज़ाइन किया गया था.

Java, Android, और दूसरी भाषाओं ने इसी तरह के कामों के लिए, अपने-अपने फ़्लैग तैयार किए. इनमें से कोई भी एक-दूसरे के साथ काम नहीं करता. इससे दूसरी भाषाओं के कॉन्टेंट को समझना मुश्किल और मुश्किल हो गया.

Bazel को बड़े, कई भाषाओं वाले, और कई प्लैटफ़ॉर्म वाले प्रोजेक्ट के लिए बनाया गया है. इससे इन सिद्धांतों को लागू करने के साथ-साथ, साफ़ तौर पर बताए गए स्टैंडर्ड एपीआई की भी ज़रूरत पड़ती है.

माइग्रेट करने की ज़रूरत है

नए एपीआई में अपग्रेड करने के लिए दो तरीकों की ज़रूरत होती है: एपीआई रिलीज़ करना और उसे इस्तेमाल करने के लिए नियम लॉजिक को अपग्रेड करना.

पहला खत्म हो गया है, लेकिन दूसरा चल रहा है. इसमें यह पक्का करना शामिल है कि भाषा के हिसाब से प्लैटफ़ॉर्म और टूलचेन तय किए गए हों, भाषा लॉजिक --crosstool_top जैसे पुराने फ़्लैग के बजाय टूलचेन को नए एपीआई की मदद से पढ़ता हो. साथ ही, config_setting पुराने फ़्लैग के बजाय नए एपीआई को चुनता है.

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

इसलिए, डेटा को दूसरी जगह भेजने का यह काम लगातार किया जा रहा है.

लक्ष्य

यह माइग्रेशन तब पूरा होता है, जब सभी प्रोजेक्ट इस फ़ॉर्म के साथ बने होते हैं:

bazel build //:myproject --platforms=//:myplatform

इसका मतलब है कि:

  1. आपके प्रोजेक्ट के नियम, //:myplatform के लिए सही टूलचेन चुनते हैं.
  2. आपके प्रोजेक्ट की डिपेंडेंसी, //:myplatform के लिए सही टूलचेन चुनती हैं.
  3. //:myplatform CPU, OS, और अन्य सामान्य और भाषा-इंडिपेंडेंट प्रॉपर्टी के सामान्य एलानों का रेफ़रंस देता है
  4. सभी काम के select(), //:myplatform से ठीक से मेल खाते हैं.
  5. //:myplatform के बारे में साफ़ और आसानी से समझ में आने वाली जगह पर बताया गया है: आपके प्रोजेक्ट के स्टोर में, अगर प्लैटफ़ॉर्म आपके प्रोजेक्ट के लिए खास है या कोई ऐसी सामान्य जगह है जहां इस्तेमाल करने वाले सभी प्रोजेक्ट,

--cpu, --crosstool_top, और --fat_apk_cpu जैसे पुराने फ़्लैग हटा दिए जाएंगे और ज़रूरत पड़ने पर इन्हें हटा दिया जाएगा.

आखिरकार, आर्किटेक्चर को कॉन्फ़िगर करने का एक ही तरीका यही होगा.

आपका प्रोजेक्ट माइग्रेट किया जा रहा है

अगर आपने प्लैटफ़ॉर्म पर काम करने वाली भाषाओं को जोड़ा है, तो आपका बिल्ड पहले से ही किसी इनोवेशन कोड के साथ काम करना चाहिए, जैसे:

bazel build //:myproject --platforms=//:myplatform

सटीक जानकारी के लिए स्थिति और अपनी भाषा के दस्तावेज़ देखें.

अगर किसी भाषा में प्लैटफ़ॉर्म पर काम करने की सुविधा चालू करने के लिए फ़्लैग की ज़रूरत है, तो आपको वह फ़्लैग भी सेट करना होगा. ज़्यादा जानकारी के लिए स्थिति देखें.

अपना प्रोजेक्ट बनाने के लिए, आपको इन चीज़ों की जांच करनी होगी:

  1. //:myplatform मौजूद होना चाहिए. प्लैटफ़ॉर्म तय करना आम तौर पर प्रोजेक्ट के मालिक की ज़िम्मेदारी होती है, क्योंकि अलग-अलग प्रोजेक्ट, अलग-अलग मशीनों को टारगेट करते हैं. डिफ़ॉल्ट प्लैटफ़ॉर्म देखें.

  2. आपको जिन टूलचेन का इस्तेमाल करना है वे मौजूद होने चाहिए. अगर स्टॉक टूलचेन का इस्तेमाल किया जा रहा है, तो भाषा के मालिकों को उन्हें रजिस्टर करने के निर्देश शामिल करने चाहिए. अगर अपनी पसंद के मुताबिक टूलचेन बनाते हैं, तो आपको उन्हें अपनी MODULE.bazel फ़ाइल में या --extra_toolchains के साथ register होगा.

  3. select() और कॉन्फ़िगरेशन ट्रांज़िशन को ठीक ठीक किया जाना चाहिए. select() और ट्रांज़िशन देखें.

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

अगर आपको अब भी समस्याएं आ रही हैं, तो सहायता के लिए संपर्क करें.

डिफ़ॉल्ट प्लैटफ़ॉर्म

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

अगर --platforms को सेट नहीं किया जाता है, तो Bazel डिफ़ॉल्ट रूप से platform दिखाता है. यह लोकल बिल्ड मशीन को दिखाता है. यह @local_config_platform//:host पर अपने-आप जनरेट होता है, इसलिए इसे साफ़ तौर पर बताने की ज़रूरत नहीं होती. यह लोकल मशीन के OS और CPU को @platforms में बताए गए constraint_value के साथ मैप करता है.

select()

प्रोजेक्ट, constraint_value टारगेट पर select() किए जा सकते हैं, लेकिन ये प्लैटफ़ॉर्म पर पूरे नहीं हो सकते. ऐसा जान-बूझकर किया गया है, ताकि select() ज़्यादा से ज़्यादा तरह की मशीनों पर काम कर सके. अगर लाइब्रेरी में ARM के सोर्स से जुड़े डेटा के बारे में साफ़ तौर पर बताया गया है, तो ज़रूरी है कि उस लाइब्रेरी में ARM के साथ चलने वाली सभी मशीनों के साथ काम किया जा सके.

एक या उससे ज़्यादा constraint_value चुनने के लिए, इनका इस्तेमाल करें:

config_setting(
    name = "is_arm",
    constraint_values = [
        "@platforms//cpu:arm",
    ],
)

यह --cpu पर पारंपरिक रूप से चुने जाने के समान है:

config_setting(
    name = "is_arm",
    values = {
        "cpu": "arm",
    },
)

ज़्यादा जानकारी के लिए यहां जाएं.

--cpu, --crosstool_top वगैरह पर मौजूद selects, --platforms को नहीं समझते. अपने प्रोजेक्ट को प्लैटफ़ॉर्म पर माइग्रेट करते समय, आपको उन्हें constraint_values में बदलना होगा. इसके अलावा, माइग्रेशन के दौरान दोनों स्टाइल के साथ काम करने के लिए, प्लैटफ़ॉर्म मैपिंग का इस्तेमाल करना होगा.

ट्रांज़िशन

Starlark ट्रांज़िशन, आपके बिल्ड ग्राफ़ के कुछ हिस्सों को फ़्लैग करता है. अगर आपका प्रोजेक्ट किसी ऐसे ट्रांज़िशन का इस्तेमाल करता है जो --cpu, --crossstool_top या अन्य लेगसी फ़्लैग सेट करता है, तो --platforms पढ़ने वाले नियमों में ये बदलाव नहीं दिखेंगे.

अपने प्रोजेक्ट को प्लैटफ़ॉर्म पर माइग्रेट करते समय, आपको return { "//command_line_option:cpu": "arm" } जैसे बदलावों को return { "//command_line_option:platforms": "//:my_arm_platform" } में बदलना होगा या माइग्रेशन के दौरान दोनों स्टाइल के साथ काम करने के लिए, प्लैटफ़ॉर्म मैपिंग का इस्तेमाल करना होगा. विंडो.

आपके नियम सेट को माइग्रेट किया जा रहा है

अगर आपके पास किसी नियम का सेट है और आपको प्लैटफ़ॉर्म का इस्तेमाल करना है, तो आपको:

  1. टूलचेन एपीआई की मदद से, नियम लॉजिक को टूलचेन में ठीक करें. toolchain API (ctx.toolchains) देखें.

  2. ज़रूरी नहीं: --incompatible_enable_platforms_for_my_language फ़्लैग तय करें, ताकि नियम लॉजिक, माइग्रेशन टेस्टिंग के दौरान नए एपीआई या --crosstool_top जैसे पुराने फ़्लैग की मदद से, टूलचेन से जुड़ी समस्याओं को हल कर सके.

  3. प्लैटफ़ॉर्म कॉम्पोनेंट बनाने वाली काम की प्रॉपर्टी तय करें. सामान्य प्लैटफ़ॉर्म प्रॉपर्टी देखें

  4. स्टैंडर्ड टूलचेन तय करें और उन्हें अपने नियम में दिए गए रजिस्ट्रेशन के निर्देशों की मदद से उपयोगकर्ताओं के लिए ऐक्सेस करें (जानकारी)

  5. पक्का करें कि select() और कॉन्फ़िगरेशन ट्रांज़िशन सपोर्ट प्लैटफ़ॉर्म पर काम करता हो. यह सबसे बड़ी चुनौती है. यह कई भाषाओं वाले प्रोजेक्ट के लिए, खास तौर पर मुश्किल काम करता है (अगर सभी भाषाएं --platforms नहीं पढ़ सकतीं, तो यह समस्या काम नहीं करती).

अगर आपको ऐसे नियमों के साथ मिलकर काम करना है जो प्लैटफ़ॉर्म के साथ काम नहीं करते, तो इस अंतर को कम करने के लिए आपको प्लैटफ़ॉर्म मैपिंग की ज़रूरत हो सकती है.

कॉमन प्लैटफ़ॉर्म प्रॉपर्टी

OS और CPU जैसी आम और दूसरी भाषाओं वाले प्लैटफ़ॉर्म प्रॉपर्टी के बारे में @platforms में बताया जाना चाहिए. इससे कॉन्टेंट को शेयर करने, उसके लिए स्टैंडर्ड तय करने, और दूसरी भाषाओं में वीडियो के साथ काम करने के लिए बढ़ावा मिलता है.

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

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

प्लैटफ़ॉर्म मैपिंग

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

प्लैटफ़ॉर्म मैपिंग, platform() का मैप होता है. यह पुराने फ़्लैग के एक जैसे सेट या पिछले फ़्लैग का मैप होता है. उदाहरण के लिए:

platforms:
  # Maps "--platforms=//platforms:ios" to "--ios_multi_cpus=x86_64 --apple_platform_type=ios".
  //platforms:ios
    --ios_multi_cpus=x86_64
    --apple_platform_type=ios

flags:
  # Maps "--ios_multi_cpus=x86_64 --apple_platform_type=ios" to "--platforms=//platforms:ios".
  --ios_multi_cpus=x86_64
  --apple_platform_type=ios
    //platforms:ios

  # Maps "--cpu=darwin_x86_64 --apple_platform_type=macos" to "//platform:macos".
  --cpu=darwin_x86_64
  --apple_platform_type=macos
    //platforms:macos

Bazel इसका इस्तेमाल, यह पक्का करने के लिए करता है कि प्लैटफ़ॉर्म पर आधारित और लेगसी, दोनों सेटिंग पूरी बिल्ड में एक जैसी रहेंगी. इनमें ट्रांज़िशन भी शामिल हैं.

डिफ़ॉल्ट रूप से, Bazel आपके फ़ाइल फ़ोल्डर के रूट में मौजूद platform_mappings फ़ाइल की मैपिंग को पढ़ता है. --platform_mappings=//:my_custom_mapping को भी सेट किया जा सकता है.

ज़्यादा जानकारी के लिए प्लैटफ़ॉर्म मैपिंग डिज़ाइन देखें.

एपीआई की समीक्षा

platform, constraint_value टारगेट का एक कलेक्शन है:

platform(
    name = "myplatform",
    constraint_values = [
        "@platforms//os:linux",
        "@platforms//cpu:arm",
    ],
)

constraint_value एक मशीन प्रॉपर्टी है. एक ही "तरह" की वैल्यू को एक कॉमन constraint_setting के तौर पर ग्रुप किया गया है:

constraint_setting(name = "os")
constraint_value(
    name = "linux",
    constraint_setting = ":os",
)
constraint_value(
    name = "mac",
    constraint_setting = ":os",
)

toolchain, स्टारलार्क का नियम होता है. इसकी एट्रिब्यूट, भाषा के टूल (जैसे कि compiler = "//mytoolchain:custom_gcc") के बारे में बताती हैं. इसके provider, इस जानकारी को इन टूल के साथ बनाए जाने वाले नियमों को देते हैं.

टूलचेन सिस्टम, उन constraint_value मशीनों का एलान करती हैं जिन्हें वे टारगेट (target_compatible_with = ["@platforms//os:linux"]) कर सकते हैं और उन मशीनों पर चल सकते हैं (exec_compatible_with = ["@platforms//os:mac"]).

$ bazel build //:myproject --platforms=//:myplatform बनाते समय, Bazel अपने-आप एक टूलचेन चुनता है, जो बिल्ड मशीन पर चल सकता है और //:myplatform के लिए बाइनरी बना सकता है. इसे टूलचेन रिज़ॉल्यूशन कहा जाता है.

उपलब्ध टूलचेन का सेट, MODULE.bazel फ़ाइल में register_toolchains के साथ या --extra_toolchains के साथ कमांड लाइन पर रजिस्टर किया जा सकता है.

ज़्यादा जानकारी के लिए यहां देखें.

सवाल

माइग्रेशन की टाइमलाइन के बारे में सामान्य सहायता और सवालों के जवाब पाने के लिए, bazel-discuss या ज़रूरी नियमों के मालिकों से संपर्क करें.

प्लैटफ़ॉर्म/टूलचेन एपीआई के डिज़ाइन और डेवलपमेंट के बारे में जानने के लिए, bazel-dev से संपर्क करें.

इन्हें भी देखें