Grup Eksekusi

7/0.9/2.5. Lihat sumber Nightly {/3/}

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

Latar belakang

Grup eksekusi memungkinkan pembuat aturan menentukan kumpulan tindakan, masing-masing dengan platform eksekusi yang mungkin berbeda. Beberapa platform eksekusi dapat mengizinkan tindakan untuk dieksekusi secara berbeda, misalnya mengompilasi aplikasi iOS pada pekerja jarak jauh (linux), kemudian menautkan/penandatanganan kode pada pekerja mac lokal.

Kemampuan untuk menentukan kelompok tindakan juga membantu mengurangi penggunaan mnemonik tindakan sebagai proxy untuk menentukan tindakan. Mnemonik tidak dijamin akan 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 pengalokasian berlebihan untuk tugas yang tidak terlalu rumit.

Menentukan grup eksekusi

Selama definisi aturan, penulis aturan dapat mendeklarasikan serangkaian grup eksekusi. Pada setiap grup eksekusi, pembuat aturan dapat menentukan semua yang diperlukan untuk memilih platform eksekusi bagi 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 exec menggunakan parameter atribut cfg dan modul config. Modul ini mengekspos fungsi exec yang menggunakan parameter string tunggal yang merupakan nama grup exec tempat dependensi harus dibuat.

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 yang menghasilkan 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 dapat mengakses toolchain yang telah di-resolve untuk grup eksekusi, sama seperti cara Anda dapat mengakses toolchain target yang telah ditetapkan:

# 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 dikte string properti yang kemudian diteruskan ke mesin eksekusi. Misalnya, jika Anda ingin menetapkan beberapa properti, misalnya memori, untuk target dan memberikan alokasi memori yang lebih tinggi untuk tindakan tertentu, Anda perlu 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++.

Grup eksekusi dan properti eksekusi platform

Anda dapat menentukan exec_properties untuk grup eksekusi arbitrer pada target platform (tidak seperti exec_properties yang ditetapkan langsung pada target, ketika properti untuk grup eksekusi yang tidak diketahui ditolak). Target kemudian mewarisi exec_properties platform eksekusi yang memengaruhi grup eksekusi default dan grup eksekusi lainnya yang relevan.

Misalnya, anggaplah menjalankan pengujian C++ memerlukan beberapa resource 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 akan lebih diprioritaskan daripada target yang diwarisi dari platform eksekusi.