Grup eksekusi memungkinkan beberapa platform eksekusi dalam satu target. Setiap grup eksekusi memiliki dependensi toolchain sendiri dan melakukan resolusi toolchain-nya sendiri.
Latar belakang
Grup eksekusi memungkinkan penulis aturan menentukan kumpulan tindakan, masing-masing dengan platform eksekusi yang berpotensi berbeda. Beberapa platform eksekusi dapat mengizinkan tindakan untuk dieksekusi secara berbeda, misalnya mengompilasi aplikasi iOS di pekerja (linux) jarak jauh, lalu menautkan/menandatangani kode di pekerja mac lokal.
Kemampuan untuk menentukan grup tindakan juga membantu mengurangi penggunaan mnemoni tindakan sebagai proxy untuk menentukan tindakan. Mnemonik tidak dijamin unik dan hanya dapat mereferensikan satu tindakan. Hal ini sangat membantu dalam mengallokasikan resource tambahan ke memori tertentu dan memproses tindakan intensif seperti penautan dalam build C++ tanpa mengalokasikan terlalu banyak ke tugas yang tidak terlalu menuntut.
Menentukan grup eksekusi
Selama definisi aturan, penulis aturan dapat
mendeklarasikan
serangkaian grup eksekusi. Di setiap grup eksekusi, penulis aturan dapat menentukan
semua yang diperlukan untuk memilih platform eksekusi untuk grup eksekusi tersebut,
yaitu batasan apa pun melalui exec_compatible_with dan jenis toolchain melalui
toolchain.
# foo.bzl
my_rule = rule(
_impl,
exec_groups = {
“link”: exec_group(
exec_compatible_with = [ "@platforms//os:linux" ]
toolchains = ["//foo:toolchain_type"],
),
“test”: exec_group(
toolchains = ["//foo_tools:toolchain_type"],
),
},
attrs = {
"_compiler": attr.label(cfg = config.exec("link"))
},
)
Dalam cuplikan kode di atas, Anda dapat melihat bahwa dependensi alat juga dapat menentukan
transisi untuk grup eksekusi menggunakan
param atribut
cfg dan modul
config. Modul ini mengekspos fungsi exec yang menggunakan satu parameter string
yang merupakan nama grup eksekusi yang dependensinya harus
di-build.
Seperti pada aturan native, grup eksekusi test ada secara default pada aturan
pengujian Starlark.
Mengakses grup eksekusi
Dalam penerapan aturan, Anda dapat mendeklarasikan bahwa tindakan harus dijalankan di
platform eksekusi grup eksekusi. Anda dapat melakukannya dengan menggunakan parameter exec_group dari metode pembuatan tindakan, khususnya ctx.actions.run dan ctx.actions.run_shell.
# foo.bzl
def _impl(ctx):
ctx.actions.run(
inputs = [ctx.attr._some_tool, ctx.srcs[0]]
exec_group = "compile",
# ...
)
Penulis aturan juga akan dapat mengakses toolchain yang di-resolve dari grup eksekusi, mirip dengan cara Anda dapat mengakses toolchain yang di-resolve dari target:
# foo.bzl
def _impl(ctx):
foo_info = ctx.exec_groups["link"].toolchains["//foo:toolchain_type"].fooinfo
ctx.actions.run(
inputs = [foo_info, ctx.srcs[0]]
exec_group = "link",
# ...
)
Grup eksekusi default
Grup eksekusi berikut telah ditetapkan sebelumnya:
test: Tindakan runner pengujian, tersedia di semua aturan pengujian.cpp_link: Tindakan penautan C++.
Menggunakan grup eksekusi untuk menetapkan properti eksekusi
Grup eksekusi terintegrasi dengan atribut exec_properties yang ada di setiap aturan dan memungkinkan penulis target menentukan dict string properti yang kemudian diteruskan ke mesin eksekusi. Misalnya, jika ingin menetapkan beberapa properti, misalnya memori, untuk target dan memberikan
alokasi memori yang lebih tinggi untuk tindakan tertentu, Anda akan menulis entri exec_properties
dengan kunci yang ditambahkan grup eksekusi, seperti:
# BUILD
my_rule(
name = 'my_target',
exec_properties = {
'mem': '12g',
'link.mem': '16g'
}
…
)
Semua tindakan dengan exec_group = "link" akan melihat kamus properti
exec sebagai {"mem": "16g"}. Seperti yang Anda lihat di sini, setelan tingkat grup eksekusi menggantikan setelan tingkat target.
Menggunakan grup eksekusi untuk menetapkan batasan platform
Grup eksekusi juga terintegrasi dengan atribut
exec_compatible_with dan
exec_group_compatible_with
yang ada di setiap aturan dan memungkinkan penulis target menentukan
batasan tambahan yang harus dipenuhi oleh platform eksekusi
yang dipilih untuk tindakan target.
Misalnya, jika aturan my_test menentukan grup eksekusi link selain
grup eksekusi default dan test, penggunaan atribut ini
berikut akan menjalankan tindakan dalam grup eksekusi default di
platform dengan jumlah CPU yang tinggi, tindakan pengujian di Linux, dan tindakan
link di platform eksekusi default:
# BUILD
constraint_setting(name = "cpu")
constraint_value(name = "high_cpu", constraint_setting = ":cpu")
platform(
name = "high_cpu_platform",
constraint_values = [":high_cpu"],
exec_properties = {
"cpu": "256",
},
)
my_test(
name = "my_test",
exec_compatible_with = ["//constraints:high_cpu"],
exec_group_compatible_with = {
"test": ["@platforms//os:linux"],
},
...
)
Grup eksekusi dan properti eksekusi platform
Anda dapat menentukan exec_properties untuk grup eksekusi arbitrer di
target platform (tidak seperti exec_properties yang ditetapkan langsung pada target, tempat
properti untuk grup eksekusi yang tidak diketahui ditolak). Target kemudian mewarisi
exec_properties platform eksekusi yang memengaruhi grup eksekusi default
dan grup eksekusi relevan lainnya.
Misalnya, menjalankan pengujian di platform exec memerlukan beberapa resource agar tersedia, tetapi tidak diperlukan untuk mengompilasi dan menautkan; hal ini dapat dibuat modelnya sebagai berikut:
# BUILD
platform(
name = "exec_platform",
exec_properties = {
"test.resource": "...",
},
)
cc_test(
name = "my_test",
srcs = ["my_test.cc"],
)
exec_properties yang ditentukan langsung pada target lebih diutamakan daripada yang
diwarisi dari platform eksekusi.