กลุ่มการดำเนินการ

รายงานปัญหา ดูแหล่งที่มา /3} /4} {3/4} {3/4} {3/4} {3/4} /4.

กลุ่มการดำเนินการทำให้มีแพลตฟอร์มการดำเนินการที่หลากหลายภายในเป้าหมายเดียว กลุ่มการดำเนินการแต่ละกลุ่มมีทรัพยากร Dependency ของ toolchain ของตนเองและมีการแปลงเครื่องมือเชนของตนเอง

ที่มา

กลุ่มการดำเนินการช่วยให้ผู้เขียนกฎกำหนดชุดการดำเนินการได้ โดยแต่ละชุดอาจมีแพลตฟอร์มการดำเนินการที่แตกต่างกัน แพลตฟอร์มการเรียกใช้หลายแพลตฟอร์มอาจทำให้การดำเนินการแตกต่างกันได้ เช่น การคอมไพล์แอป iOS บนผู้ปฏิบัติงานระยะไกล (linux) จากนั้นจึงลิงก์/การรับรองโค้ดกับผู้ปฏิบัติงาน Mac ในเครื่อง

การกำหนดกลุ่มการดำเนินการยังช่วยลดการใช้บันทึกการดำเนินการเป็นพร็อกซีในการระบุการทำงาน เราไม่รับประกันว่าการจำจะไม่ซ้ำกันและอ้างอิงการดำเนินการได้เพียงรายการเดียวเท่านั้น ซึ่งจะเป็นประโยชน์อย่างยิ่งในการจัดสรรทรัพยากรเพิ่มเติมให้กับหน่วยความจำที่เจาะจงและการประมวลผลการดำเนินการที่หนักหน่วง เช่น การลิงก์ในบิลด์ C++ โดยไม่จัดสรรงานมากเกินไปให้กับงานที่มีความต้องการน้อยกว่า

การกำหนดกลุ่มการดำเนินการ

ในระหว่างการกำหนดกฎ ผู้เขียนกฎจะประกาศชุดกลุ่มการดำเนินการได้ ในกลุ่มการดำเนินการแต่ละกลุ่ม ผู้สร้างกฎสามารถระบุทุกอย่างที่จำเป็นต่อการเลือกแพลตฟอร์มการดำเนินการสำหรับกลุ่มการดำเนินการนั้น เช่น ข้อจำกัดผ่านประเภท exec_compatible_with และประเภท Toolchain ผ่าน 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"))
    },
)

ในข้อมูลโค้ดด้านบน คุณจะเห็นว่าทรัพยากร Dependency ของเครื่องมือยังระบุการเปลี่ยนสำหรับกลุ่มปฏิบัติการโดยใช้พารามิเตอร์แอตทริบิวต์ cfg และโมดูล config ได้ด้วย โมดูลจะแสดงฟังก์ชัน exec ซึ่งใช้พารามิเตอร์สตริงเดียวซึ่งเป็นชื่อกลุ่มปฏิบัติการที่ควรสร้างทรัพยากร Dependency

ตามกฎแบบเนทีฟ กลุ่มการดำเนินการ test จะปรากฏโดยค่าเริ่มต้นในกฎการทดสอบของ Starlark

การเข้าถึงกลุ่มการดำเนินการ

เมื่อใช้กฎ คุณสามารถประกาศได้ว่าการดำเนินการควรเรียกใช้ในแพลตฟอร์มการดำเนินการของกลุ่มการดำเนินการ ซึ่งทำได้โดยใช้พารามิเตอร์ exec_group ของเมธอดการสร้างการดำเนินการ โดยเฉพาะ ctx.actions.run และ ctx.actions.run_shell

# foo.bzl
def _impl(ctx):
  ctx.actions.run(
     inputs = [ctx.attr._some_tool, ctx.srcs[0]]
     exec_group = "compile",
     # ...
  )

นอกจากนี้ ผู้เขียนกฎยังสามารถเข้าถึงโซ่เครื่องมือที่แก้ไขแล้วของกลุ่มการดำเนินการได้ ในลักษณะเดียวกับวิธีที่คุณเข้าถึง Toolchain ของเป้าหมายซึ่งได้รับการแก้ไขแล้วได้มีดังนี้

# 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",
     # ...
  )

หมายเหตุ: หากการดำเนินการใช้ Toolchain จากกลุ่มการดำเนินการ แต่ไม่ได้ระบุกลุ่มการดำเนินการนั้นในการประกาศการดำเนินการ การดำเนินการนั้นอาจทำให้เกิดปัญหาได้ ข้อมูลที่ไม่ตรงกันดังกล่าวอาจไม่ได้ทำให้การทำงานล้มเหลวในทันที แต่เป็นปัญหาที่ซ่อนอยู่

การใช้กลุ่มการดำเนินการเพื่อตั้งค่าพร็อพเพอร์ตี้การดำเนินการ

กลุ่มการดำเนินการจะผสานรวมกับแอตทริบิวต์ exec_properties ที่มีอยู่ในกฎทั้งหมด และช่วยให้ผู้เขียนเป้าหมายระบุคำสั่งสตริงของพร็อพเพอร์ตี้ที่ส่งไปยังเครื่องจักรการดำเนินการได้ ตัวอย่างเช่น หากต้องการตั้งค่าพร็อพเพอร์ตี้บางรายการ เช่น หน่วยความจำสำหรับเป้าหมาย และทำให้การดำเนินการบางอย่างมีการจัดสรรหน่วยความจำที่สูงขึ้น คุณจะต้องเขียนรายการ exec_properties ด้วยคีย์ที่ผนวกกับกลุ่มการดำเนินการ เช่น

# BUILD
my_rule(
    name = 'my_target',
    exec_properties = {
        'mem': '12g',
        'link.mem': '16g'
    }
    …
)

การดำเนินการทั้งหมดที่มี exec_group = "link" จะเห็นพจนานุกรมพร็อพเพอร์ตี้ของผู้บริหารเป็น {"mem": "16g"} ตามที่คุณเห็นที่นี่ การตั้งค่าระดับกลุ่มการดำเนินการจะลบล้างการตั้งค่าระดับเป้าหมาย

กลุ่มการดำเนินการสำหรับกฎแบบเนทีฟ

กลุ่มการดำเนินการต่อไปนี้ใช้ได้กับการดำเนินการที่กำหนดโดยกฎของระบบ

• test: ทดสอบการดำเนินการของตัวเรียกใช้
• cpp_link: การดำเนินการลิงก์ C++

กลุ่มการดำเนินการและพร็อพเพอร์ตี้การดำเนินการของแพลตฟอร์ม

คุณกำหนด exec_properties สำหรับกลุ่มการดำเนินการที่กำหนดเองในเป้าหมายแพลตฟอร์มได้ (ต่างจาก exec_properties ที่ตั้งค่าไว้ในเป้าหมายโดยตรง ซึ่งพร็อพเพอร์ตี้สำหรับกลุ่มการดำเนินการที่ไม่รู้จักจะถูกปฏิเสธ) จากนั้นเป้าหมายจะรับ exec_properties ของแพลตฟอร์มการดำเนินการที่ส่งผลต่อกลุ่มการดำเนินการเริ่มต้นและกลุ่มการดำเนินการอื่นๆ ที่เกี่ยวข้อง

ตัวอย่างเช่น สมมติว่าการทดสอบ C++ จำเป็นต้องมีทรัพยากรบางอย่างพร้อมใช้งาน แต่ไม่จำเป็นสำหรับการคอมไพล์และการลิงก์ ซึ่งจะสร้างรูปแบบได้ดังนี้

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 ที่กำหนดไว้โดยตรงในเป้าหมายจะมีลำดับความสำคัญเหนือกว่าเป้าหมายที่สืบทอดมาจากแพลตฟอร์มการดำเนินการ