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

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

ฉากหลัง

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

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

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

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

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

เช่นเดียวกับกฎดั้งเดิม test กลุ่มการดำเนินการจะอยู่ในกฎการทดสอบ Starlark โดยค่าเริ่มต้น

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

ในการติดตั้งใช้งานกฎ คุณสามารถประกาศว่าควรเรียกใช้การดำเนินการบน แพลตฟอร์มการดำเนินการของกลุ่มการดำเนินการ คุณทำได้โดยใช้ exec_group param ของวิธีการสร้างการกระทํา ซึ่งก็คือ 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",
     # ...
  )

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

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

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

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

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

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