กลุ่มการเรียกใช้อัตโนมัติ (AEG)

กลุ่มการดำเนินการอัตโนมัติจะเลือกแพลตฟอร์มการดำเนินการ สำหรับ Toolchain แต่ละประเภท กล่าวอีกนัยหนึ่งคือ เป้าหมายหนึ่งๆ มีแพลตฟอร์มการดำเนินการได้หลายแพลตฟอร์มโดยไม่ต้องกำหนดกลุ่มการดำเนินการ

ข้อมูลสรุปสั้นๆ

กลุ่มการดำเนินการอัตโนมัติเชื่อมโยงกับ Toolchain อย่างใกล้ชิด หากคุณใช้ Toolchain คุณต้องตั้งค่า Toolchain ในการดำเนินการที่ได้รับผลกระทบ (การดำเนินการที่ใช้ไฟล์ปฏิบัติการหรือเครื่องมือจาก Toolchain) โดยเพิ่มพารามิเตอร์ toolchain เช่น

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

หากการดำเนินการไม่ได้ใช้เครื่องมือหรือไฟล์ปฏิบัติการจาก Toolchain และ Blaze ตรวจไม่พบ (ระบบแสดงข้อผิดพลาด) คุณสามารถตั้งค่า toolchain = None ได้

หากคุณต้องใช้ Toolchain หลายรายการในแพลตฟอร์มการดำเนินการเดียว (การดำเนินการ ใช้ไฟล์ปฏิบัติการหรือเครื่องมือจาก Toolchain 2 รายการขึ้นไป) คุณต้อง กำหนด exec_groups ด้วยตนเอง (ดู ส่วนฉันควรใช้ exec_group ที่กำหนดเองเมื่อใด )

ประวัติ

ก่อนที่จะมีกลุ่มการดำเนินการอัตโนมัติ ระบบจะเลือกแพลตฟอร์มการดำเนินการที่ระดับกฎ เช่น

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

กฎ my_rule ลงทะเบียน Toolchain 2 ประเภท ซึ่งหมายความว่าการแก้ปัญหา Toolchain Resolution ใช้ เพื่อค้นหาแพลตฟอร์มการดำเนินการที่รองรับ Toolchain ทั้ง 2 ประเภท ระบบจะใช้แพลตฟอร์มการดำเนินการที่เลือก สำหรับการดำเนินการที่ลงทะเบียนแต่ละรายการภายในกฎ เว้นแต่ จะระบุไว้เป็นอย่างอื่นด้วย exec_groups กล่าวอีกนัยหนึ่งคือ การดำเนินการทั้งหมดภายในกฎเคยมีแพลตฟอร์มการดำเนินการเดียว แม้ว่าจะใช้เครื่องมือจาก Toolchain ที่แตกต่างกัน (ระบบจะเลือกแพลตฟอร์มการดำเนินการสำหรับเป้าหมายแต่ละรายการ) ซึ่งส่งผลให้เกิดข้อผิดพลาดเมื่อไม่มีแพลตฟอร์มการดำเนินการที่รองรับ Toolchain ทั้งหมด

สถานะปัจจุบัน

เมื่อใช้กลุ่มการดำเนินการอัตโนมัติ ระบบจะเลือกแพลตฟอร์มการดำเนินการสำหรับ Toolchain แต่ละประเภท ฟังก์ชันการใช้งานของตัวอย่างก่อนหน้านี้ my_rule จะมีลักษณะดังนี้

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',
    )

กฎนี้สร้างการดำเนินการ 2 รายการ ได้แก่ First action ซึ่งใช้ไฟล์ปฏิบัติการจาก //tools:toolchain_type_1 และ Second action ซึ่งใช้ไฟล์ปฏิบัติการจาก //tools:toolchain_type_2 ก่อนที่จะมีกลุ่มการดำเนินการอัตโนมัติ การดำเนินการทั้ง 2 รายการนี้จะดำเนินการบนแพลตฟอร์มการดำเนินการเดียวที่รองรับ Toolchain ทั้ง 2 ประเภท เมื่อใช้กลุ่มการดำเนินการอัตโนมัติ การดำเนินการแต่ละรายการจะดำเนินการบนแพลตฟอร์มการดำเนินการที่ให้ Toolchain โดยการเพิ่มพารามิเตอร์ toolchain ภายใน Actions การดำเนินการอาจดำเนินการบนแพลตฟอร์มการดำเนินการที่แตกต่างกัน

การดำเนินการเดียวกันจะมีผลกับ ctx.actions.run_shell โดยคุณควรเพิ่ม toolchain พารามิเตอร์เมื่อ tools มาจาก Toolchain

ความแตกต่างระหว่าง exec_groups ที่กำหนดเองกับ exec_groups อัตโนมัติ

ตามชื่อที่ระบุไว้ กลุ่มการดำเนินการอัตโนมัติคือ exec_groups ที่สร้างขึ้นโดยอัตโนมัติสำหรับแต่ละ ประเภท Toolchain ที่ลงทะเบียนในกฎ คุณไม่จำเป็นต้องระบุกลุ่มเหล่านี้ด้วยตนเอง ซึ่งแตกต่างจาก exec_groups "แบบคลาสสิก"

ฉันควรใช้ exec_group ที่กำหนดเองเมื่อใด

คุณต้องใช้ exec_groups ที่กำหนดเองในกรณีที่ Toolchain หลายรายการต้องดำเนินการบนแพลตฟอร์มการดำเนินการเดียวเท่านั้น ในกรณีอื่นๆ ทั้งหมด คุณไม่จำเป็นต้องกำหนด exec_groups ที่กำหนดเอง เช่น

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'],
        ),
    }
)

การย้ายข้อมูลของกลุ่มการดำเนินการอัตโนมัติ

ภายใน google3 นั้น Blaze ใช้กลุ่มการดำเนินการอัตโนมัติอยู่แล้ว สำหรับ Bazel ภายนอก การย้ายข้อมูลอยู่ในระหว่างดำเนินการ กฎบางข้อใช้ฟีเจอร์นี้อยู่แล้ว (เช่น กฎ Java และ C++)

Bazel เวอร์ชันใดบ้างที่รองรับการย้ายข้อมูลนี้

Bazel 7 ขึ้นไปรองรับกลุ่มการดำเนินการอัตโนมัติอย่างเต็มรูปแบบ

วิธีเปิดใช้กลุ่มการดำเนินการอัตโนมัติ

ตั้งค่า --incompatible_auto_exec_groups เป็น "จริง" ดูข้อมูลเพิ่มเติมเกี่ยวกับแฟล็ก ได้ใน ปัญหา GitHub

วิธีเปิดใช้กลุ่มการดำเนินการอัตโนมัติภายในกฎเฉพาะ

ตั้งค่าแอตทริบิวต์ _use_auto_exec_groups ในกฎ

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

การดำเนินการนี้จะเปิดใช้กลุ่มการดำเนินการอัตโนมัติใน my_rule เท่านั้น และการดำเนินการของกฎจะเริ่มใช้ตรรกะใหม่เมื่อเลือกแพลตฟอร์มการดำเนินการ แอตทริบิวต์นี้จะลบล้างแฟล็กที่ไม่เข้ากัน

วิธีปิดใช้กลุ่มการดำเนินการอัตโนมัติในกรณีที่เกิดข้อผิดพลาด

ตั้งค่า --incompatible_auto_exec_groups เป็น "เท็จ" เพื่อปิดใช้กลุ่มการดำเนินการอัตโนมัติใน โปรเจ็กต์ของคุณ (ปัญหา GitHub ของแฟล็ก) หรือปิดใช้กฎเฉพาะ โดยตั้งค่าแอตทริบิวต์ _use_auto_exec_groups เป็น False (ดูรายละเอียดเพิ่มเติมเกี่ยวกับแอตทริบิวต์)

ข้อความแสดงข้อผิดพลาดขณะย้ายข้อมูลไปยังกลุ่มการดำเนินการอัตโนมัติ

ระบุไม่ได้ว่าเครื่องมือมาจากทรัพยากร Dependency โดยนัยหรือ Toolchain โปรดตั้งค่าพารามิเตอร์ Toolchain หากไม่ได้ใช้ Toolchain ให้ตั้งค่าเป็น "None"

• ในกรณีนี้ คุณจะเห็นสแต็กของการเรียกก่อนที่จะเกิดข้อผิดพลาด และจะเห็นได้อย่างชัดเจนว่าการดำเนินการใดที่ต้องใช้พารามิเตอร์ Toolchain ตรวจสอบว่ามีการใช้ Toolchain ใดสำหรับการดำเนินการ และตั้งค่าด้วยพารามิเตอร์ Toolchain หากไม่มีการใช้ Toolchain ภายใน Actions สำหรับเครื่องมือหรือไฟล์ปฏิบัติการ ให้ตั้งค่าเป็น None

มีการประกาศการดำเนินการสำหรับ Toolchain "[toolchain_type]" ที่ไม่มีอยู่

• ซึ่งหมายความว่าคุณได้ตั้งค่าพารามิเตอร์ Toolchain ในการดำเนินการ แต่ไม่ได้ลงทะเบียนพารามิเตอร์ในกฎ ลงทะเบียน Toolchain หรือตั้งค่า None ภายใน Actions

สื่อเพิ่มเติม

ดูข้อมูลเพิ่มเติมได้ที่เอกสารการออกแบบ: กลุ่มการดำเนินการอัตโนมัติสำหรับ Toolchain