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 ke toolchain. Jika Anda menggunakan toolchain, Anda perlu menyetelnya 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 tersebut tidak menggunakan alat atau file yang dapat dieksekusi dari toolchain, dan Blaze tidak mendeteksi hal itu (error muncul), Anda dapat menyetelnya toolchain = None.

Jika Anda perlu menggunakan beberapa toolchain pada satu platform eksekusi (sebuah tindakan menggunakan {i>executable<i} atau {i>tool<i} dari dua atau lebih toolchain), Anda harus tentukan exec_groups (centang Kapan saya harus menggunakan exec_group kustom? ).

Histori

Sebelum AEG, platform eksekusi dipilih pada 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 Resolusi digunakan untuk menemukan platform eksekusi yang mendukung kedua jenis toolchain tersebut. yang dipilih platform eksekusi digunakan untuk setiap tindakan yang terdaftar di dalam aturan, kecuali ditentukan secara berbeda dengan exec_groups. Dengan kata lain, semua tindakan di dalam aturan yang digunakan untuk hanya memiliki satu eksekusi platform ini bahkan jika mereka menggunakan alat dari toolchain yang berbeda (platform eksekusi dipilih untuk setiap target). {i>Mockup <i}ini mengakibatkan kegagalan ketika tidak ada yang mendukung semua toolchain.

Status saat ini

Dengan AEG, platform eksekusi dipilih untuk setiap jenis toolchain. Tujuan fungsi implementasi dari 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 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 pada satu platform eksekusi yang mendukung kedua jenis toolchain tersebut. Dengan AEG, dengan menambahkan parameter toolchain di dalam tindakan, setiap tindakan akan dijalankan di platform eksekusi yang menyediakan toolchain. Tindakan dapat dijalankan di berbagai platform eksekusi.

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

Perbedaan antara grup exec kustom dan grup exec otomatis

Seperti namanya, AEG adalah grup {i>exec<i} yang dibuat secara otomatis untuk jenis toolchain yang terdaftar pada aturan. Tidak perlu menentukannya secara manual, tidak seperti "klasik" grup eksekutif.

Kapan saya harus menggunakan exec_group kustom?

exec_groups kustom hanya diperlukan jika beberapa toolchain perlu dieksekusi pada satu platform eksekusi. Dalam kasus lain, 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 untuk Bazel, 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 dari Bazel 7.

Bagaimana cara mengaktifkan AEG?

Tetapkan --incompatible_auto_exec_groups ke true. Informasi selengkapnya tentang tanda ini tentang 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),
    }
)

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

Bagaimana cara menonaktifkan AEG jika terjadi error?

Setel --incompatible_auto_exec_groups ke false untuk sepenuhnya menonaktifkan AEG di project Anda (menandai masalah GitHub), 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, tetapkan ke 'None'.

  • Dalam hal ini, Anda mendapatkan tumpukan panggilan sebelum kesalahan terjadi dan Anda bisa melihat dengan jelas tindakan pasti mana yang memerlukan parameter toolchain. Periksa toolchain digunakan untuk tindakan dan menyetelnya dengan parameter toolchain. Jika tidak toolchain digunakan dalam aksi untuk alat atau file yang dapat dieksekusi, aturlah ke None.

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

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

Materi tambahan

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