Grup Eksekusi

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.
Laporkan masalah Lihat sumber

Grup eksekusi memungkinkan beberapa platform eksekusi dalam satu target. Setiap grup eksekusi memiliki dependensi Toolchain sendiri dan melakukan resolusi toolchain sendiri.

Latar belakang

Grup eksekusi memungkinkan penulis aturan menentukan kumpulan tindakan, masing-masing dengan platform eksekusi yang berpotensi berbeda. Beberapa platform eksekusi dapat memungkinkan tindakan untuk dijalankan secara berbeda, misalnya mengompilasi aplikasi iOS pada pekerja jarak jauh (linux), lalu menautkan/menandatangani kode pada pekerja mac lokal.

Kemampuan untuk menentukan grup tindakan juga membantu mengurangi penggunaan mnemonik tindakan sebagai proxy untuk menentukan tindakan. Mnemonik tidak dijamin unik dan hanya dapat mereferensikan satu tindakan. Hal ini sangat membantu dalam mengalokasikan resource tambahan ke memori tertentu dan memproses tindakan intensif seperti menautkan dalam build C++ tanpa mengalokasikan berlebihan ke tugas yang tidak terlalu sulit.

Menentukan grup eksekusi

Selama definisi aturan, penulis aturan dapat mendeklarasikan sekumpulan grup eksekusi. Pada 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 eksekutif menggunakan parameter atribut cfg dan modul config. Modul ini menampilkan fungsi exec yang menggunakan parameter string tunggal yang merupakan nama grup eksekutif yang dependensinya harus dibuat.

Seperti pada aturan native, grup eksekusi test ada secara default di aturan pengujian Starlark.

Pewarisan grup eksekusi

Selain menentukan batasan dan toolchain-nya sendiri, grup eksekusi baru dapat mendeklarasikan bahwa grup tersebut ingin mewarisi dari grup eksekusi default aturan, dengan meneruskan parameter copy_from_rule = True. Menyetel copy_from_rule ke true dan juga meneruskan exec_compatible_with atau toolchains adalah error.

Grup eksekusi yang diwarisi dari grup eksekusi default akan menyalin batasan, toolchain, dan properti eksekusi dari default. Ini mencakup batasan dan properti eksekusi yang ditetapkan di level target, bukan hanya yang ditentukan oleh aturan itu sendiri. Dengan kata lain, mengingat hal berikut:

# foo.bzl
my_rule = rule(
    _impl,
    exec_groups = {
        “copied”: exec_group(
            copy_from_rule = True,
            # This will inherit exec_compatible_with and toolchains.
            # Setting them here directly would be an error, however.
        ),
    },
    toolchains = ["//foo_tools:toolchain_type"],
    exec_compatible_with = ["@platforms//os:linux"],
)

# BUILD

my_rule(
    name = "demo",
    exec_compatible_with = [":local_constraint"],
)

Grup eksekusi copied untuk target demo yang dikonfigurasi akan mencakup semua: - //fool_tools:toolchain_type - @platforms//os:linux - :local_constraint

Mengakses grup eksekusi

Dalam implementasi aturan, Anda dapat mendeklarasikan bahwa tindakan harus dijalankan di platform eksekusi grup eksekusi. Anda dapat melakukannya dengan menggunakan parameter exec_group 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",
     # ...
  )

Pembuat aturan juga dapat mengakses Toolchain yang terselesaikan pada grup eksekusi, sama seperti cara mengakses toolchain target yang telah diselesaikan:

# 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",
     # ...
  )

Menggunakan grup eksekusi untuk menetapkan properti eksekusi

Grup eksekusi terintegrasi dengan atribut exec_properties yang ada di setiap aturan dan memungkinkan penulis target menentukan dek string dari properti yang kemudian diteruskan ke mesin eksekusi. Misalnya, jika Anda ingin menetapkan beberapa properti, misalnya memori, untuk target dan memberikan tindakan memori yang lebih tinggi, Anda harus menulis entri exec_properties dengan kunci yang ditambah 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 akan menggantikan setelan tingkat target.

Grup eksekusi untuk aturan native

Grup eksekusi berikut tersedia untuk tindakan yang ditentukan oleh aturan native:

  • test: Menguji tindakan runner.
  • cpp_link: Tindakan penautan C++.

Membuat grup exec untuk menetapkan properti exec

Terkadang, Anda ingin menggunakan grup exec untuk memberikan tindakan tertentu yang berbeda pada properti exec, tetapi sebenarnya tidak menginginkan toolchain atau batasan yang berbeda dari aturan. Untuk situasi ini, Anda dapat membuat grup eksekutif menggunakan parameter copy_from_rule:

# foo.bzl

# Creating an exec group with `copy_from_rule=True` is the same as explicitly
# setting the exec group's toolchains and constraints to the same values as the
# rule's respective parameters.
my_rule = rule(
    _impl,
    exec_compatible_with = ["@platforms//os:linux"],
    toolchains = ["//foo:toolchain_type"],
    exec_groups = {
        # The following two groups have the same toolchains and constraints:
        “foo”: exec_group(copy_from_rule = True),
        "bar": exec_group(
            exec_compatible_with = ["@platforms//os:linux"],
            toolchains = ["//foo:toolchain_type"],
        ),
    },
)

#

Grup eksekusi dan properti eksekusi platform

exec_properties dapat ditetapkan untuk grup eksekusi arbitrer di target platform (tidak seperti exec_properties yang ditetapkan secara langsung pada target, tempat properti untuk grup eksekusi yang tidak diketahui ditolak). Kemudian, target mewarisi exec_properties platform eksekusi yang memengaruhi grup eksekusi default dan grup eksekusi relevan lainnya.

Misalnya, menjalankan pengujian C++ memerlukan beberapa resource yang tersedia, tetapi tidak diperlukan untuk mengompilasi dan menautkan; hal ini dapat dimodelkan sebagai berikut:

constraint_setting(name = "resource")
constraint_value(name = "has_resource", constraint_setting = ":resource")

platform(
    name = "platform_with_resource",
    constraint_values = [":has_resource"],
    exec_properties = {
        "test.resource": "...",
    },
)

cc_test(
    name = "my_test",
    srcs = ["my_test.cc"],
    exec_compatible_with = [":has_resource"],
)

exec_properties yang ditentukan langsung pada target lebih diutamakan daripada target yang diwarisi dari platform eksekusi.