गहराई

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.
समस्या की शिकायत करें स्रोत देखें

डेप्सेट डेटा को खास तौर पर टारगेट करने के लिए बनाया जाता है. यह टारगेट की ट्रांज़िशनल डिपेंडेंसी में डेटा इकट्ठा करता है. ये नियम प्रोसेस करने का एक अहम हिस्सा हैं.

डिसेट की विशेषता, समय और स्पेस की बचत करने वाली यूनियन कार्रवाई है. डिक्सेट कंस्ट्रक्टर, एलिमेंट और अन्य डायरेक्टस ("ट्रांज़िटिव") की सूची के साथ-साथ सभी डायरेक्ट एलिमेंट और सभी ट्रांज़िटिव सेट के यूनियन को दिखाने वाले सेट का एक डिक्रिप्ट लौटाता है. सैद्धान्तिक तौर पर, कंस्ट्रक्टर एक नया ग्राफ़ नोड बनाता है, जिसके डायरेक्टर और ट्रांज़िशनल नोड होते हैं. इस ग्राफ़ के ट्रैवर्सल के आधार पर, लेआउट में क्रम से लगाने वाले सिमैंटिक होते हैं.

लेआउट का इस्तेमाल करने के उदाहरण:

  • किसी प्रोग्राम की लाइब्रेरी के लिए सभी ऑब्जेक्ट फ़ाइलों के पाथ को स्टोर करना, जिन्हें बाद में सेवा देने वाली कंपनी की मदद से किसी लिंकर कार्रवाई में पास किया जा सकता है.

  • समझ में आने वाली भाषा के लिए, ऐसी ट्रांज़िटिव सोर्स फ़ाइलें सेव करना जो एक्ज़ीक्यूटेबल की रन फ़ाइलें में शामिल होती हैं.

ब्यौरा और कार्रवाइयां

सैद्धांतिक तौर पर, डेप्सेट, निर्देश दिया गया असाइकलिक ग्राफ़ (डीएजी) होता है, जो आम तौर पर टारगेट ग्राफ़ की तरह दिखता है. इसे पत्तियों से लेकर रूट तक बनाया गया है. डिपेंडेंसी चेन में मौजूद हर टारगेट, पिछले कॉन्टेंट के ऊपर अपना कॉन्टेंट जोड़ सकता है. इसके लिए, उन्हें पढ़ने या कॉपी करने की ज़रूरत नहीं होती.

डीएजी के हर नोड में डायरेक्ट एलिमेंट की सूची और चाइल्ड नोड की सूची होती है. डिप्सेट की सामग्री ट्रांज़िटीय एलिमेंट हैं, जैसे कि सभी नोड के डायरेक्ट एलिमेंट. depset कंस्ट्रक्टर का इस्तेमाल करके एक नया डिपसेट बनाया जा सकता है: यह डायरेक्ट एलिमेंट की सूची और चाइल्ड नोड की दूसरी सूची स्वीकार करता है.

s = depset(["a", "b", "c"])
t = depset(["d", "e"], transitive = [s])

print(s)    # depset(["a", "b", "c"])
print(t)    # depset(["d", "e", "a", "b", "c"])

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

s = depset(["a", "b", "c"])

print("c" in s.to_list())              # True
print(s.to_list() == ["a", "b", "c"])  # True

जैसे ही डिक्शनरी में तय की गई कुंजियों को प्रतिबंधित किया जाता है, वैसे ही डिसेट में आइटम की अनुमति होती है. खास तौर पर, डिसेट कॉन्टेंट में बदलाव नहीं किया जा सकता.

डेप्सेट रेफ़रंस इक्वलिटी का इस्तेमाल करता है: डिप्सेट खुद के बराबर होता है, लेकिन किसी अन्य डिसेट के बराबर नहीं होता, भले ही उनमें एक जैसा कॉन्टेंट और एक ही इंटरनल स्ट्रक्चर हो.

s = depset(["a", "b", "c"])
t = s
print(s == t)  # True

t = depset(["a", "b", "c"])
print(s == t)  # False

d = {}
d[s] = None
d[t] = None
print(len(d))  # 2

कॉन्टेंट में मौजूद कमी की तुलना करने के लिए, उन्हें क्रम से लगाई गई सूचियों में बदलें.

s = depset(["a", "b", "c"])
t = depset(["c", "b", "a"])
print(sorted(s.to_list()) == sorted(t.to_list()))  # True

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

s = depset(["a", "b", "c"])
t = depset(["b", "c"])

# Compute set difference s - t. Precompute t.to_list() so it's not done
# in a loop, and convert it to a dictionary for fast membership tests.
t_items = {e: None for e in t.to_list()}
diff_items = [x for x in s.to_list() if x not in t_items]
# Convert back to depset if it's still going to be used for union operations.
s = depset(diff_items)
print(s)  # depset(["a"])

ऑर्डर

to_list ऑपरेशन, डीएजी पर ट्रैवर्सल करता है. ट्रैवर्सल का टाइप, उस ऑर्डर पर निर्भर करता है जो डिपसेट बनाते समय बताया गया था. बेज़ल के लिए एक से ज़्यादा ऑर्डर पर काम करना मददगार होता है, क्योंकि कभी-कभी टूल अपने इनपुट के क्रम को ध्यान में रखते हैं. उदाहरण के लिए, लिंकर की कार्रवाई को यह पक्का करने की ज़रूरत पड़ सकती है कि अगर B A पर निर्भर हो, तो A.o, लिंकर की कमांड लाइन पर B.o से पहले आता है. हो सकता है कि दूसरे टूल में भी ऐसा हो.

तीन ट्रैवर्सल ऑर्डर काम करते हैं: postorder, preorder, और topological. पहले दो काम ट्री ट्रैवर्सल की तरह काम करते हैं. हालांकि, वे डीएजी पर काम करते हैं और पहले ही विज़िट किए जा चुके नोड पर काम नहीं करते हैं. तीसरा क्रम, रूट से पत्तियों तक टोपोलॉजिकल क्रम के तौर पर काम करता है. यह पहले से तय किए गए क्रम की तरह ही होता है. हालांकि, इसमें शेयर किए गए बच्चों को उनके माता-पिता के बाद ही शामिल किया जाता है. पहले से ऑर्डर करें और पोस्टऑर्डर, बाएं से दाएं ट्रैवर्सल की तरह काम करते हैं, लेकिन ध्यान रखें कि हर नोड डायरेक्ट एलिमेंट में बच्चों से जुड़ा कोई ऑर्डर नहीं होता है. विषय के हिसाब से क्रम की बात करने के लिए, बाईं से दाईं ओर गारंटी नहीं दी जा सकती है. साथ ही, डीएजी के अलग-अलग नोड में डुप्लीकेट एलिमेंट होने पर भी सभी बच्चों की अनुमति और बच्चों की गारंटी लागू नहीं होती है.

# This demonstrates different traversal orders.

def create(order):
  cd = depset(["c", "d"], order = order)
  gh = depset(["g", "h"], order = order)
  return depset(["a", "b", "e", "f"], transitive = [cd, gh], order = order)

print(create("postorder").to_list())  # ["c", "d", "g", "h", "a", "b", "e", "f"]
print(create("preorder").to_list())   # ["a", "b", "e", "f", "c", "d", "g", "h"]
# This demonstrates different orders on a diamond graph.

def create(order):
  a = depset(["a"], order=order)
  b = depset(["b"], transitive = [a], order = order)
  c = depset(["c"], transitive = [a], order = order)
  d = depset(["d"], transitive = [b, c], order = order)
  return d

print(create("postorder").to_list())    # ["a", "b", "c", "d"]
print(create("preorder").to_list())     # ["d", "b", "a", "c"]
print(create("topological").to_list())  # ["d", "b", "c", "a"]

ट्रैवर्सल लागू करने की वजह से, कंस्ट्रक्टर के order कीवर्ड के आर्ग्युमेंट को बनाते समय, क्रम की जानकारी ज़रूर दी जानी चाहिए. अगर इस आर्ग्युमेंट को छोड़ दिया जाता है, तो डिसेट में खास default ऑर्डर होता है. इस मामले में, इसके किसी भी एलिमेंट के क्रम के बारे में कोई गारंटी नहीं होती है. हालांकि, इसके लिए तय करने की ज़रूरत नहीं होती है.

पूरा उदाहरण

यह उदाहरण https://github.com/bazelbuild/examples/tree/main/rule/depsets पर उपलब्ध है.

मान लीजिए कि किसी काल्पनिक भाषा Foo का इस्तेमाल होता है. हर foo_binary बनाने के लिए, आपको उन सभी *.foo फ़ाइलों के बारे में जानना चाहिए जो सीधे तौर पर या किसी दूसरे तरीके से निर्भर करती हैं.

# //depsets:BUILD

load(":foo.bzl", "foo_library", "foo_binary")

# Our hypothetical Foo compiler.
py_binary(
    name = "foocc",
    srcs = ["foocc.py"],
)

foo_library(
    name = "a",
    srcs = ["a.foo", "a_impl.foo"],
)

foo_library(
    name = "b",
    srcs = ["b.foo", "b_impl.foo"],
    deps = [":a"],
)

foo_library(
    name = "c",
    srcs = ["c.foo", "c_impl.foo"],
    deps = [":a"],
)

foo_binary(
    name = "d",
    srcs = ["d.foo"],
    deps = [":b", ":c"],
)
# //depsets:foocc.py

# "Foo compiler" that just concatenates its inputs to form its output.
import sys

if __name__ == "__main__":
  assert len(sys.argv) >= 1
  output = open(sys.argv[1], "wt")
  for path in sys.argv[2:]:
    input = open(path, "rt")
    output.write(input.read())

यहां, बाइनरी d के ट्रांज़िटिव स्रोत a, b, c, और d के srcs फ़ील्ड में मौजूद सभी *.foo फ़ाइलें हैं. foo_binary टारगेट के बारे में जानने के लिए, d.foo के अलावा, foo_library टारगेट को सेवा देने वाली किसी कंपनी के पास भेजना होगा. हर लाइब्रेरी को अपनी खुद की डिपेंडेंसी के साथ, सेवा देने वाली कंपनियों से मिलती है. साथ ही, ऑगमेंटेड कॉन्टेंट के साथ नई कंपनी को पास करती है. foo_binary नियम वैसा ही काम करता है. इसके अलावा, सेवा देने वाली कंपनी लौटाने के बजाय, यह सोर्स की पूरी सूची का इस्तेमाल करके, किसी कार्रवाई के लिए कमांड लाइन बनाता है.

यहां foo_library और foo_binary के नियमों को पूरी तरह से लागू किया गया है.

# //depsets/foo.bzl

# A provider with one field, transitive_sources.
FooFiles = provider(fields = ["transitive_sources"])

def get_transitive_srcs(srcs, deps):
  """Obtain the source files for a target and its transitive dependencies.

  Args:
    srcs: a list of source files
    deps: a list of targets that are direct dependencies
  Returns:
    a collection of the transitive sources
  """
  return depset(
        srcs,
        transitive = [dep[FooFiles].transitive_sources for dep in deps])

def _foo_library_impl(ctx):
  trans_srcs = get_transitive_srcs(ctx.files.srcs, ctx.attr.deps)
  return [FooFiles(transitive_sources=trans_srcs)]

foo_library = rule(
    implementation = _foo_library_impl,
    attrs = {
        "srcs": attr.label_list(allow_files=True),
        "deps": attr.label_list(),
    },
)

def _foo_binary_impl(ctx):
  foocc = ctx.executable._foocc
  out = ctx.outputs.out
  trans_srcs = get_transitive_srcs(ctx.files.srcs, ctx.attr.deps)
  srcs_list = trans_srcs.to_list()
  ctx.actions.run(executable = foocc,
                  arguments = [out.path] + [src.path for src in srcs_list],
                  inputs = srcs_list + [foocc],
                  outputs = [out])

foo_binary = rule(
    implementation = _foo_binary_impl,
    attrs = {
        "srcs": attr.label_list(allow_files=True),
        "deps": attr.label_list(),
        "_foocc": attr.label(default=Label("//depsets:foocc"),
                             allow_files=True, executable=True, cfg="host")
    },
    outputs = {"out": "%{name}.out"},
)

आप इन फ़ाइलों को नए पैकेज में कॉपी करके, लेबल का नाम ठीक से बदलकर, डमी कॉन्टेंट वाली *.foo फ़ाइलें बनाकर, और d टारगेट बनाकर इसकी जांच कर सकते हैं.

परफ़ॉर्मेंस

गिरावट का इस्तेमाल करने की प्रेरणा पाने के लिए, देखें कि अगर get_transitive_srcs() अपने स्रोतों को एक सूची में इकट्ठा कर लेते हैं, तो क्या होगा.

def get_transitive_srcs(srcs, deps):
  trans_srcs = []
  for dep in deps:
    trans_srcs += dep[FooFiles].transitive_sources
  trans_srcs += srcs
  return trans_srcs

इसमें डुप्लीकेट कॉपी शामिल नहीं किए जाते. इसलिए, a के लिए सोर्स फ़ाइलें कमांड लाइन पर दो बार और आउटपुट फ़ाइल के कॉन्टेंट में दो बार दिखेंगी.

दूसरा विकल्प है सामान्य सेट का इस्तेमाल करना, जिसे एक ऐसे डिक्शनरी में सिम्युलेट किया जा सकता है जिसमें कुंजियां, एलिमेंट हो और सभी कुंजियों को True से मैप किया जाता हो.

def get_transitive_srcs(srcs, deps):
  trans_srcs = {}
  for dep in deps:
    for file in dep[FooFiles].transitive_sources:
      trans_srcs[file] = True
  for file in srcs:
    trans_srcs[file] = True
  return trans_srcs

ऐसा करने से डुप्लीकेट फ़ाइलों से छुटकारा मिल जाता है, लेकिन यह कमांड लाइन के आर्ग्युमेंट और फ़ाइलों का कॉन्टेंट नहीं होने के क्रम की जानकारी नहीं देता है. हालांकि, अब भी इसे तय करने में कोई समस्या नहीं आती है.

इतना ही नहीं, दोनों ही सिस्टम, समस्याओं के ऐसे समस्याओं से सबसे ज़्यादा खराब होते हैं जो डेप्सेट पर आधारित होते हैं. उस मामले पर विचार करें जहां 'फ़ू' लाइब्रेरी' पर डिपेंडेंसी की एक लंबी चेन है. हर नियम को प्रोसेस करने के लिए, हमारे पास पहले से मौजूद सभी ट्रांज़िटिव सोर्स को डेटा स्ट्रक्चर में कॉपी करना ज़रूरी होता है. इसका मतलब है कि किसी एक लाइब्रेरी या बाइनरी टारगेट का विश्लेषण करने के लिए लगने वाला समय और जगह की लागत, चेन में उसकी खुद की ऊंचाई के अनुपात में होती है. लंबाई n की चेन के लिए, foolib_1 ← foolib_2 ← ... foolib_n, जिसकी कुल लागत प्रभावी रूप से O(n^2) है.

आम तौर पर, जब भी आप अपनी ट्रांज़िटिव डिपेंडेंसी के ज़रिए जानकारी इकट्ठा करते हैं, तब पैसे पाने वाले लोगों की जानकारी का इस्तेमाल किया जाना चाहिए. इससे यह पक्का करने में मदद मिलती है कि आपका बिल्ड उतना ही अच्छा बने जितना आपके टारगेट ग्राफ़ में बढ़ोतरी हो रही है.

आखिर में, यह ज़रूरी है कि नियमों को लागू करते समय, डिपसेट के कॉन्टेंट को ग़ैर-ज़रूरी तौर पर वापस न लाया जाए. बाइनरी नियम के आखिर में, to_list() को एक कॉल करना ठीक है, क्योंकि कुल लागत सिर्फ़ O(n) है. ऐसा तब होता है, जब कई गैर-टर्मिनल टारगेट to_list() को कॉल करने की कोशिश करते हैं.

गहराई से काम करने के बारे में ज़्यादा जानकारी के लिए, परफ़ॉर्मेंस पेज देखें.

एपीआई का संदर्भ

ज़्यादा जानने के लिए, कृपया यहां जाएं.