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 Anda menggunakan toolchain, Anda harus menyetelnya pada tindakan yang terpengaruh (tindakan yang menggunakan 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 tidak menggunakan alat atau file yang dapat dieksekusi dari toolchain, dan Blaze tidak mendeteksinya (error muncul), Anda dapat menyetel toolchain = None.

Jika Anda perlu menggunakan beberapa toolchain pada satu platform eksekusi (tindakan menggunakan file yang dapat dieksekusi atau alat dari dua toolchain atau lebih), Anda harus menentukan exec_groups secara manual (lihat 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, Penyelesaian Toolchain yang digunakan untuk menemukan platform eksekusi yang mendukung kedua jenis toolchain. Platform eksekusi yang dipilih digunakan untuk setiap tindakan yang terdaftar dalam aturan, kecuali jika ditentukan berbeda dengan exec_groups. Dengan kata lain, semua tindakan di dalam aturan sebelumnya menggunakan satu platform eksekusi meskipun menggunakan alat dari toolchain yang berbeda (platform eksekusi dipilih untuk setiap target). Hal ini menyebabkan kegagalan jika tidak ada platform eksekusi yang mendukung semua toolchain.

Status saat ini

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

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 executable dari //tools:toolchain_type_1 dan Second action yang menggunakan executable dari //tools:toolchain_type_2. Sebelum AEG, kedua tindakan ini akan dieksekusi di satu platform eksekusi yang mendukung kedua jenis toolchain. Dengan AEG, dengan menambahkan parameter toolchain di dalam tindakan, setiap tindakan dieksekusi di platform eksekusi yang menyediakan toolchain. Tindakan dapat dieksekusi di platform eksekusi yang berbeda.

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

Perbedaan antara grup eksekusi kustom dan grup eksekusi otomatis

Seperti namanya, AEG adalah grup eksekusi yang dibuat secara otomatis untuk setiap jenis toolchain yang terdaftar pada aturan. Anda tidak perlu menentukannya secara manual, tidak seperti grup eksekusi "klasik". Selain itu, nama AEG otomatis ditetapkan ke jenis toolchain-nya (misalnya, //tools:toolchain_type_1).

Kapan saya harus menggunakan exec_group kustom?

Grup exec kustom hanya diperlukan jika beberapa toolchain perlu dieksekusi pada satu platform eksekusi. Dalam kasus lain, Anda tidak perlu menentukan exec_group 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. Untuk Bazel secara eksternal, migrasi sedang dalam proses. Beberapa aturan sudah menggunakan fitur ini (misalnya, aturan Java dan C++).

Versi Bazel mana yang mendukung migrasi ini?

AEG didukung sepenuhnya mulai dari Bazel 7.

Bagaimana cara mengaktifkan AEG?

Tetapkan --incompatible_auto_exec_groups ke true. Informasi selengkapnya tentang tanda ini ada di masalah GitHub.

Bagaimana cara mengaktifkan AEG 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 memungkinkan AEG hanya di my_rule dan tindakannya mulai menggunakan logika baru saat memilih platform eksekusi. Flag yang tidak kompatibel diganti dengan atribut ini.

Bagaimana cara menonaktifkan AEG jika terjadi error?

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

Pesan error saat bermigrasi ke AEG

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

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

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

• Artinya, Anda telah menyetel parameter toolchain pada tindakan, tetapi tidak mendaftarkannya pada aturan. Daftarkan toolchain atau tetapkan None di dalam tindakan.

Materi tambahan

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