Depset 是一種專門的資料結構,可以提高效率 從目標的遞移依附元件收集資料。這類技術 規則處理的各個環節
depset 的定義功能為它兼具時間和空間的聯集作業。 depset 建構函式接受元素清單 (「direct」) 和其他 「轉換」鍵,並傳回代表集合,其代表包含所有 直接元素和所有遞移集合的聯集。概念上 建構函式會建立新的圖形節點,並具有直接和遞移節點 和科技的續作定義具有明確定義的排序語意,根據 這張圖表的周遊
解碼器的使用範例包括:
儲存程式程式庫的所有物件檔案路徑, ,然後再透過供應商傳遞至連接器動作。
若是解譯語言,儲存 包含在執行檔的執行檔案中。
說明與作業
概念上,去點是有向非循環圖 (DAG),通常看起來 和目標圖表它從根部延伸至根層級。 依附元件鏈結中的每個目標皆可在 而不需要讀取或複製這些內容
DAG 中的每個節點都含有直接元素清單和子節點清單。 depset 的內容是遞移元素,例如直接元素 所有節點的資料您可以使用 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() 方法。傳回所有遞移性的清單 元素,但不包括重複項目。您無法直接檢查 精確的 DAG 結構,不過這個結構確實會影響 這裡顯示了相應的元素
s = depset(["a", "b", "c"])
print("c" in s.to_list()) # True
print(s.to_list() == ["a", "b", "c"]) # True
解碼器中允許的項目會受到限制,如同 字典會受到限制。特別是,解碼器內容可能無法變動。
Depset 使用參照相等:依附元件等於本身,但不等於任何 其他 Depset,即使兩者的內容和內部結構相同
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
如要依內容內容比較 Depset,請將其轉換為已排序的清單。
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
運算會對 DAG 執行週遊。週遊的種類
取決於 depset 先前指定的 order
訓練方式數量這對於 Bazel 能支援多筆訂單,因為有時
這些工具在乎輸入順序舉例來說,連接器動作可能會
必須確保如果 B
依附 A
,那麼 A.o
會在 B.o
之前
連結器的指令列其他工具則可能有相反需求。
系統支援以下三筆遍歷訂單:postorder
、preorder
和
topological
。前兩項工作的運作方式與樹木
週遊
但在 DAG 上作業,並略過已瀏覽的節點。第三筆訂單
運作方式為從根到葉的拓撲排序,基本上與
預購,除非共用兒童位於所有上層。
預購和預購作業的運作方式為從左到右週遊,但請注意
每個節點直接元素都沒有相對於子項的順序。拓撲適用
我們沒有從左到右的保證,
在以下情況下,
在 DAG 的不同節點中重複元素
# 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"]
基於週遊的執行方式,必須在時指定訂單
Dpset 會使用建構函式的 order
關鍵字引數建立。如果這是
引數遭到省略,則解碼集必須具有特殊的 default
順序,這時
我們無法保證其任何元素的順序 (除非是
具確定性)。
完整範例
這個範例位於 https://github.com/bazelbuild/examples/tree/main/rules/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
的遞移來源是*.foo
a
、b
、c
和 d
的 srcs
欄位。支付 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()
是二次行為時
會發生什麼事
如要進一步瞭解如何有效使用解碼器,請參閱效能頁面。
API 參考資料
詳情請參閱這裡。