Basel के अलग-अलग हार्डवेयर, ऑपरेटिंग सिस्टम, और जिसमें बिल्ड टूल के कई अलग-अलग वर्शन इस्तेमाल किए जाते हैं, जैसे कि लिंकर और कंपाइलर का इस्तेमाल किया जाता है. इस जटिलता को मैनेज करने के लिए, Basel का एक कॉन्सेप्ट है पाबंदियां और प्लैटफ़ॉर्म के हिसाब से होना चाहिए. कंस्ट्रेंट ऐसा डाइमेंशन होता है जिसमें बिल्ड या प्रोडक्शन एनवायरमेंट में अंतर हो सकता है. जैसे, सीपीयू का आर्किटेक्चर, मौजूदगी या जीपीयू का न होना या सिस्टम पर इंस्टॉल किए गए कंपाइलर के वर्शन का होना ज़रूरी है. प्लैटफ़ॉर्म, इन कंस्ट्रेंट के लिए, नाम वाले विकल्पों का कलेक्शन होता है, जो जो कुछ एनवायरमेंट में उपलब्ध हैं.
पर्यावरण को एक प्लैटफ़ॉर्म के तौर पर मॉडल करने से, Ba ज़रिए को अपने-आप उचित टूलचेन का इस्तेमाल करें. प्लैटफ़ॉर्म का इस्तेमाल इन चीज़ों के साथ भी किया जा सकता है: config_setting कॉन्फ़िगर करने लायक एट्रिब्यूट लिखने के लिए, नियम का इस्तेमाल किया जा सकता है.
बेज़ल इन तीन भूमिकाओं को समझते हैं जो एक प्लैटफ़ॉर्म पूरा कर सकता है:
- होस्ट - वह प्लैटफ़ॉर्म जिस पर बेज़ल खुद चलता है.
- समय लागू करना - एक ऐसा प्लैटफ़ॉर्म जिस पर टूल, बिल्ड ऐक्शन को अंजाम देते हैं इंटरमीडिएट और फ़ाइनल आउटपुट नहीं दे सकते.
- टारगेट - वह प्लैटफ़ॉर्म जिस पर फ़ाइनल आउटपुट सेव होता है और लागू होता है.
प्लैटफ़ॉर्म के मामले में, Basel के बिल्ड की इन स्थितियों को सपोर्ट किया जा सकता है:
सिंगल-प्लैटफ़ॉर्म बिल्ड (डिफ़ॉल्ट) - होस्ट, एक्ज़ीक्यूशन, और टारगेट प्लैटफ़ॉर्म एक जैसे हैं. उदाहरण के लिए, Ubuntu पर चलने वाले Linux को एक्ज़ीक्यूटेबल बनाना Intel x64 सीपीयू होना चाहिए.
क्रॉस-कंपाइलेशन बिल्ड - होस्ट और एक्ज़ीक्यूशन प्लैटफ़ॉर्म एक जैसे होते हैं, लेकिन टारगेट प्लैटफ़ॉर्म अलग है. उदाहरण के लिए, macOS पर iOS ऐप्लिकेशन बनाना MacBook Pro पर चल रहे हैं.
मल्टी-प्लैटफ़ॉर्म बिल्ड - होस्ट, एक्ज़ीक्यूशन, और टारगेट प्लैटफ़ॉर्म अलग हैं.
कंस्ट्रेंट और प्लैटफ़ॉर्म को तय करना
प्लैटफ़ॉर्म के लिए संभावित विकल्पों की जगह,
constraint_setting और
BUILD फ़ाइलों में constraint_value नियम.
constraint_setting एक नया डाइमेंशन बनाता है, जबकि
constraint_value किसी दिए गए डाइमेंशन के लिए एक नई वैल्यू बनाता है; वे साथ में
enum और इसके संभावित मानों को प्रभावी ढंग से परिभाषित कर सकते हैं. उदाहरण के लिए, निम्न
BUILD फ़ाइल का स्निपेट, सिस्टम के glibc वर्शन के लिए एक कंस्ट्रेंट पेश करता है
दो संभावित वैल्यू के साथ किया जाता है.
constraint_setting(name = "glibc_version")
constraint_value(
name = "glibc_2_25",
constraint_setting = ":glibc_version",
)
constraint_value(
name = "glibc_2_26",
constraint_setting = ":glibc_version",
)
कंस्ट्रेंट और उनकी वैल्यू को name@yourcompany.com जैसा कोई प्रोफ़ेशनल ईमेल पता बनाएं. इससे आपका कारोबार ज़्यादा भरोसेमंद बनेगा. इन पर लेबल की मदद से जानकारी भेजी जाती है और ये सामान्य तौर पर दिखते हैं नियंत्रण. अगर विज़िबिलिटी अनुमति देती है, तो मौजूदा कंस्ट्रेंट सेटिंग को इसके लिए वैल्यू तय करें.
platform नियम एक ऐसा नया प्लैटफ़ॉर्म लॉन्च करता है जिसमें
कंस्ट्रेंट वैल्यू के कुछ विकल्प. कॉन्टेंट बनाने
अनुसरण, linux_x86 नाम का एक प्लैटफ़ॉर्म बनाता है और कहता है कि यह
ऐसा वातावरण जो Linux ऑपरेटिंग सिस्टम को x86_64 आर्किटेक्चर पर चलाता है.
glibc वर्शन 2.25 है. (Basel के बिल्ट-इन कंस्ट्रेंट के बारे में ज़्यादा जानकारी के लिए यहां देखें.)
platform(
name = "linux_x86",
constraint_values = [
"@platforms//os:linux",
"@platforms//cpu:x86_64",
":glibc_2_25",
],
)
आम तौर पर, काम के कंस्ट्रेंट और प्लैटफ़ॉर्म
नेटवर्क को एक जैसा बनाए रखने के लिए, Basel की टीम ने सबसे लोकप्रिय सीपीयू आर्किटेक्चर और ऑपरेटिंग के लिए कंस्ट्रेंट डेफ़िनिशन सिस्टम. ये सभी इस इलाके में मौजूद हैं https://github.com/bazelbuild/platforms.
बेज़ल, इस खास प्लैटफ़ॉर्म की परिभाषा के हिसाब से शिप किए जाते हैं:
@platforms//host (@bazel_tools//tools:host_platform के रूप में जोड़ा गया). यह है
अपने-आप पहचानी गई होस्ट प्लैटफ़ॉर्म वैल्यू -
उस सिस्टम के लिए अपने-आप पता लगाए गए प्लैटफ़ॉर्म का प्रतिनिधित्व करता है जिस पर Basel चल रहा है.
बिल्ड के लिए प्लैटफ़ॉर्म तय करना
बिल्ड के लिए होस्ट और टारगेट प्लैटफ़ॉर्म तय करने के लिए, इनका इस्तेमाल किया जा सकता है कमांड लाइन फ़्लैग:
--host_platform- डिफ़ॉल्ट रूप से@bazel_tools//tools:host_platformहोती है- इस टारगेट को
@platforms//hostपर एलियास किया गया है, जो रेपो की मदद से काम करता है ऐसा नियम जो होस्ट ओएस और सीपीयू का पता लगाता है और प्लैटफ़ॉर्म के टारगेट को लिखता है. - वहां
@platforms//host:constraints.bzlभी है, जिससे पता चलता है किHOST_CONSTRAINTSनाम का एक कलेक्शन है, जिसका इस्तेमाल अन्य BUILD में किया जा सकता है और Starlark फ़ाइलें.
- इस टारगेट को
--platforms- होस्ट प्लैटफ़ॉर्म को डिफ़ॉल्ट रूप से सेट करता है- इसका मतलब है कि जब कोई और फ़्लैग सेट नहीं किया जाता है,
@platforms//hostटारगेट किया गया प्लैटफ़ॉर्म है. - यदि
--host_platformसेट है और--platformsनहीं, तो--host_platform, होस्ट और टारगेट प्लैटफ़ॉर्म, दोनों है.
- इसका मतलब है कि जब कोई और फ़्लैग सेट नहीं किया जाता है,
काम न करने वाले टारगेट को स्किप किया जा रहा है
किसी खास टारगेट प्लैटफ़ॉर्म का इस्तेमाल करते समय, अक्सर
टारगेट कर रहे हैं जो उस प्लैटफ़ॉर्म पर कभी काम नहीं करेंगे. उदाहरण के लिए, आपका Windows डिवाइस
ड्राइवर की ओर से
//... वाली Linux मशीन. इसका इस्तेमाल करें
target_compatible_with
एट्रिब्यूट का इस्तेमाल करें.
इस एट्रिब्यूट का सबसे आसान इस्तेमाल, टारगेट को किसी एक प्लैटफ़ॉर्म तक सीमित कर देता है.
टारगेट को ऐसे किसी भी प्लैटफ़ॉर्म के लिए नहीं बनाया जाएगा जो सभी ज़रूरी शर्तें पूरी न करता हो
करना है. नीचे दिए गए उदाहरण में, win_driver_lib.cc को 64-बिट पर सेट किया गया है
Windows.
cc_library(
name = "win_driver_lib",
srcs = ["win_driver_lib.cc"],
target_compatible_with = [
"@platforms//cpu:x86_64",
"@platforms//os:windows",
],
)
:win_driver_lib, सिर्फ़ 64-बिट Windows और Windows डिवाइसों पर चलने वाले डिवाइस के साथ काम करती है
अन्य सभी के साथ असंगत है. साथ काम नहीं करने की वजह से, लंबे समय के लिए काम नहीं किया जा सकता. कोई भी लक्ष्य
जो अस्थायी रूप से किसी असंगत टारगेट पर निर्भर होते हैं, उन्हें खुद माना जाता है
असंगत.
टारगेट कब स्किप किए जाते हैं?
अगर टारगेट को काम का न माना जाता है और वे को टारगेट पैटर्न एक्सपैंशन के हिस्से के तौर पर बनाया जा सकता है. उदाहरण के लिए, नीचे दिए गए दो शुरू करने की प्रक्रिया, टारगेट पैटर्न एक्सपैंशन में मिले काम न करने वाले टारगेट को छोड़ देती है.
$ bazel build --platforms=//:myplatform //...
$ bazel build --platforms=//:myplatform //:all
test_suite में असंगत टेस्ट के बारे में
इसी तरह से छोड़ दिया जाता है अगर test_suite को इसके साथ कमांड लाइन पर तय किया जाता है
--expand_test_suites.
दूसरे शब्दों में, कमांड लाइन पर मौजूद test_suite टारगेट, :all की तरह काम करते हैं और
.... --noexpand_test_suites का इस्तेमाल करने से, प्रॉपर्टी का विस्तार नहीं होता और इसकी वजहें होती हैं
काम न करने वाले टेस्ट वाले test_suite टारगेट भी काम के नहीं हैं.
कमांड लाइन पर असंगत टारगेट को साफ़ तौर पर बताने से ऐसा होता है और बिल्ड में गड़बड़ी हुई है.
$ bazel build --platforms=//:myplatform //:target_incompatible_with_myplatform
...
ERROR: Target //:target_incompatible_with_myplatform is incompatible and cannot be built, but was explicitly requested.
...
FAILED: Build did NOT complete successfully
काम न करने वाले अश्लील टारगेट को चुपचाप छोड़ दिया जाता है, अगर
--skip_incompatible_explicit_targets चालू है.
ज़्यादा एक्सप्रेसिव कंस्ट्रेंट
शर्तों को ज़्यादा आसानी से ज़ाहिर करने के लिए,
@platforms//:incompatible अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
constraint_value
जिस पर कोई भी प्लैटफ़ॉर्म काम नहीं करता.
select() को इनके साथ इस्तेमाल करें
@platforms//:incompatible का इस्तेमाल करें. इसके लिए
उदाहरण के लिए, बेसिक OR लॉजिक को लागू करने के लिए इसका इस्तेमाल करें. यह लाइब्रेरी,
macOS और Linux के साथ काम करता है, लेकिन किसी अन्य प्लैटफ़ॉर्म पर नहीं.
cc_library(
name = "unixish_lib",
srcs = ["unixish_lib.cc"],
target_compatible_with = select({
"@platforms//os:osx": [],
"@platforms//os:linux": [],
"//conditions:default": ["@platforms//:incompatible"],
}),
)
ऊपर दिए गए शब्दों का मतलब इस तरह समझा जा सकता है:
- macOS को टारगेट करते समय, टारगेट पर कोई पाबंदी नहीं होती.
- Linux को टारगेट करते समय, टारगेट में कोई रुकावट नहीं होती.
- ऐसा नहीं होने पर, टारगेट में
@platforms//:incompatibleकंस्ट्रेंट है. क्योंकि@platforms//:incompatibleकिसी भी प्लैटफ़ॉर्म का हिस्सा नहीं है, टारगेट असंगत माना जाता है.
अपने कंस्ट्रेंट को पढ़ने में आसान बनाने के लिए,
skylib की
selects.with_or().
इसी तरह, अलग-अलग डिवाइसों के साथ काम करने की सुविधा के बारे में भी बताया जा सकता है. यह उदाहरण इसमें ऐसी लाइब्रेरी के बारे में बताया गया है जो ARM के अलावा सभी चीज़ों के साथ काम करती है.
cc_library(
name = "non_arm_lib",
srcs = ["non_arm_lib.cc"],
target_compatible_with = select({
"@platforms//cpu:arm": ["@platforms//:incompatible"],
"//conditions:default": [],
}),
)
bazel cquery का इस्तेमाल करके, काम न करने वाले टारगेट का पता लगाना
Google आपके यूआरएल पैरामीटर को कैसे इस्तेमाल करेगा, यह तय करने के लिए
IncompatiblePlatformProvider
bazel cquery के Starlark आउटपुट में
फ़ॉर्मैट का इस्तेमाल अलग-अलग करने के लिए करें
संगत लक्ष्यों से असंगत लक्ष्य.
इसका इस्तेमाल करके, ऐसे टारगेट को फ़िल्टर किया जा सकता है जो काम नहीं करते. नीचे दिए गए उदाहरण में केवल संगत लक्ष्यों के लेबल प्रिंट करें. असंगत लक्ष्य हैं प्रिंट नहीं किया गया.
$ cat example.cquery
def format(target):
if "IncompatiblePlatformProvider" not in providers(target):
return target.label
return ""
$ bazel cquery //... --output=starlark --starlark:file=example.cquery
आम समस्याएं
काम न करने वाले टारगेट किसको दिखे, इसे अनदेखा करें पाबंदियां तय की गई हैं.