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

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

ข้อมูลเบื้องต้น

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

ความสามารถในการกําหนดกลุ่มการดําเนินการยังช่วยลดการใช้คําช่วยจําการดําเนินการ (Mnemonic) เป็นตัวแทนในการระบุการดําเนินการด้วย ระบบไม่รับประกันว่าคําช่วยจําจะซ้ำกันหรือไม่ และสามารถอ้างอิงการดําเนินการได้เพียงรายการเดียวเท่านั้น ซึ่งจะเป็นประโยชน์อย่างยิ่งในการกำหนดทรัพยากรเพิ่มเติมให้กับหน่วยความจำที่เฉพาะเจาะจงและการดำเนินการที่ต้องใช้การประมวลผลอย่างหนัก เช่น การลิงก์ในบิลด์ 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"))
    },
)

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

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

การสืบทอดกลุ่มการดําเนินการ

นอกเหนือจากการกำหนดข้อจำกัดและเครื่องมือทางเทคนิคของตนเองแล้ว กลุ่มการดําเนินการใหม่ยังประกาศได้ว่าต้องการรับค่าจากกลุ่มการดําเนินการเริ่มต้นของกฎด้วยการส่งพารามิเตอร์ copy_from_rule = True นี่เป็นข้อผิดพลาดในการตั้งค่า copy_from_rule เป็น true และส่ง exec_compatible_with หรือ toolchains

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

# foo.bzl
my_rule = rule(
    _impl,
    exec_groups = {
        “copied”: exec_group(
            copy_from_rule = True,
            # This will inherit exec_compatible_with and toolchains.
            # Setting them here directly would be an error, however.
        ),
    },
    toolchains = ["//foo_tools:toolchain_type"],
    exec_compatible_with = ["@platforms//os:linux"],
)

# BUILD

my_rule(
    name = "demo",
    exec_compatible_with = [":local_constraint"],
)

กลุ่มการเรียกใช้ copied สําหรับเป้าหมายที่กําหนดค่า demo จะรวมข้อมูลต่อไปนี้ทั้งหมด - //fool_tools:toolchain_type - @platforms//os:linux - :local_constraint

การเข้าถึงกลุ่มการเรียกใช้

ในการใช้งานกฎ คุณประกาศได้ว่าการดำเนินการควรเรียกใช้ในแพลตฟอร์มการดำเนินการของกลุ่มการดำเนินการ ซึ่งทำได้โดยใช้ 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 เพื่อกำหนดการดำเนินการบางอย่างให้มีพร็อพเพอร์ตี้ exec ที่แตกต่างกัน แต่จริงๆ แล้วไม่ต้องการเครื่องมือและข้อจำกัดที่แตกต่างจากกฎ สำหรับสถานการณ์เหล่านี้ คุณสามารถสร้างกลุ่ม exec โดยใช้พารามิเตอร์ copy_from_rule ดังนี้

# foo.bzl

# Creating an exec group with `copy_from_rule=True` is the same as explicitly
# setting the exec group's toolchains and constraints to the same values as the
# rule's respective parameters.
my_rule = rule(
    _impl,
    exec_compatible_with = ["@platforms//os:linux"],
    toolchains = ["//foo:toolchain_type"],
    exec_groups = {
        # The following two groups have the same toolchains and constraints:
        “foo”: exec_group(copy_from_rule = True),
        "bar": exec_group(
            exec_compatible_with = ["@platforms//os:linux"],
            toolchains = ["//foo:toolchain_type"],
        ),
    },
)

#

กลุ่มการเรียกใช้และพร็อพเพอร์ตี้การเรียกใช้แพลตฟอร์ม

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