Grup Eksekusi Otomatis (AEG)

Grup eksekusi otomatis memilih platform eksekusi untuk setiap jenis toolchain. Dengan kata lain, satu target dapat memiliki beberapa platform eksekusi tanpa menentukan grup eksekusi.

Ringkasan singkat

Grup eksekusi otomatis terhubung erat dengan toolchain. Jika menggunakan toolchain, Anda perlu menetapkannya pada tindakan yang terpengaruh (tindakan yang menggunakan file yang dapat dieksekusi atau alat dari toolchain) dengan menambahkan parameter toolchain. Contoh:

ctx.actions.run(
    ...,
    executable = ctx.toolchain['@bazel_tools//tools/jdk:toolchain_type'].tool,
    ...,
    toolchain = '@bazel_tools//tools/jdk:toolchain_type',
)

Jika tindakan ini tidak menggunakan alat atau file yang dapat dieksekusi dari toolchain, dan Blaze tidak mendeteksinya (error muncul), Anda dapat menetapkan toolchain = None.

Jika perlu menggunakan beberapa toolchain pada satu platform eksekusi (tindakan menggunakan file yang dapat dieksekusi atau alat dari dua toolchain atau lebih), Anda perlu menetapkan exec_groups secara manual (centang bagian Kapan saya harus menggunakan exec_group kustom?).

Histori

Sebelum AEG, platform eksekusi dipilih di tingkat aturan. Contoh:

my_rule = rule(
    _impl,
    toolchains = ['//tools:toolchain_type_1', '//tools:toolchain_type_2'],
)

Aturan my_rule mendaftarkan dua jenis toolchain. Artinya, Toolchain Resolution yang digunakan untuk menemukan platform eksekusi yang mendukung kedua jenis toolchain. Platform eksekusi yang dipilih digunakan untuk setiap tindakan yang terdaftar di dalam aturan, kecuali jika ditentukan secara berbeda dengan exec_groups. Dengan kata lain, semua tindakan di dalam aturan sebelumnya memiliki satu platform eksekusi meskipun tindakan tersebut menggunakan alat dari toolchain yang berbeda (platform eksekusi dipilih untuk setiap target). Hal ini mengakibatkan kegagalan saat tidak ada platform eksekusi yang mendukung semua toolchain.

Status saat ini

Dengan AEG, platform eksekusi dipilih untuk setiap jenis toolchain. Fungsi implementasi dari contoh sebelumnya, my_rule, akan terlihat seperti ini:

def _impl(ctx):
    ctx.actions.run(
      mnemonic = "First action",
      executable = ctx.toolchain['//tools:toolchain_type_1'].tool,
      toolchain = '//tools:toolchain_type_1',
    )

    ctx.actions.run(
      mnemonic = "Second action",
      executable = ctx.toolchain['//tools:toolchain_type_2'].tool,
      toolchain = '//tools:toolchain_type_2',
    )

Aturan ini membuat dua tindakan, First action yang menggunakan file yang dapat dieksekusi dari //tools:toolchain_type_1 dan Second action yang menggunakan file yang dapat dieksekusi dari //tools:toolchain_type_2. Sebelum AEG, kedua tindakan ini akan dijalankan di platform eksekusi tunggal yang mendukung kedua jenis toolchain. Dengan AEG, dengan menambahkan parameter toolchain di dalam tindakan, setiap tindakan akan dijalankan di platform eksekusi yang menyediakan toolchain. Tindakan tersebut dapat dijalankan di berbagai platform eksekusi.

Hal yang sama berlaku dengan ctx.actions.run_shell dengan parameter toolchain yang harus ditambahkan saat tools berasal dari toolchain.

Perbedaan antara grup eksekutif kustom dan grup eksekutif otomatis

Seperti namanya, AEG adalah grup eksekutif yang dibuat secara otomatis untuk setiap jenis toolchain yang terdaftar pada aturan. Tidak perlu menentukannya secara manual, tidak seperti grup eksekutif "klasik".

Kapan saya harus menggunakan exec_group kustom?

exec_groups kustom hanya diperlukan jika beberapa toolchain perlu dijalankan pada satu platform eksekusi. Dalam semua kasus lain, Anda tidak perlu menentukan exec_groups kustom. Contoh:

def _impl(ctx):
    ctx.actions.run(
      ...,
      executable = ctx.toolchain['//tools:toolchain_type_1'].tool,
      tools = [ctx.toolchain['//tools:toolchain_type_2'].tool],
      exec_group = 'two_toolchains',
    )

my_rule = rule(
    _impl,
    exec_groups = {
        "two_toolchains": exec_group(
            toolchains = ['//tools:toolchain_type_1', '//tools:toolchain_type_2'],
        ),
    }
)

Migrasi AEG

Secara internal di google3, Blaze sudah menggunakan AEG. Secara eksternal, migrasi sedang dalam proses untuk Bazel. Beberapa aturan sudah menggunakan fitur ini (misalnya aturan Java dan C++).

Versi Bazel mana yang mendukung migrasi ini?

AEG didukung sepenuhnya dari Bazel 7.

Bagaimana cara mengaktifkan AEG?

Tetapkan --incompatible_auto_exec_groups ke true. Informasi selengkapnya tentang flag di masalah GitHub.

Bagaimana cara mengaktifkan AEG di dalam aturan tertentu?

Tetapkan atribut _use_auto_exec_groups pada aturan.

my_rule = rule(
    _impl,
    attrs = {
      "_use_auto_exec_groups": attr.bool(default = True),
    }
)

Hal ini hanya mengaktifkan AEG dalam my_rule dan tindakannya mulai menggunakan logika baru saat memilih platform eksekusi. Tanda yang tidak kompatibel akan diganti dengan atribut ini.

Bagaimana cara menonaktifkan AEG jika terjadi error?

Setel --incompatible_auto_exec_groups ke salah (false) untuk sepenuhnya menonaktifkan AEG dalam project Anda (masalah GitHub tanda), atau nonaktifkan aturan tertentu dengan menetapkan atribut _use_auto_exec_groups ke False (detail selengkapnya tentang atribut).

Pesan error saat bermigrasi ke AEG

Tidak dapat mengidentifikasi apakah alat berasal dari dependensi implisit atau toolchain. Setel parameter toolchain. Jika Anda tidak menggunakan toolchain, setel ke 'None'.

• Dalam kasus ini, Anda akan mendapatkan tumpukan panggilan sebelum error terjadi dan dapat melihat dengan jelas tindakan mana yang memerlukan parameter toolchain. Periksa toolchain yang digunakan untuk tindakan tersebut dan tetapkan dengan parameter toolchain. Jika tidak ada toolchain yang digunakan dalam tindakan untuk alat atau file yang dapat dieksekusi, tetapkan ke None.

Tindakan dideklarasikan untuk toolchain '[ toolchain_type]' yang tidak ada.

• Ini berarti Anda telah menetapkan parameter toolchain pada tindakan, tetapi tidak mendaftarkannya pada aturan. Daftarkan toolchain atau setel None di dalam tindakan.

Materi tambahan

Untuk informasi selengkapnya, periksa dokumen desain: Grup eksekusi otomatis untuk toolchain.