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

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

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

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

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

กลุ่มการดำเนินการที่รับช่วงมาจากสำเนากลุ่มการดำเนินการเริ่มต้น ข้อจำกัด, 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 พารามิเตอร์ของเมธอดสร้างการดำเนินการ โดยเฉพาะ 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",
     # ...
  )

ผู้เขียนกฎยังมีสิทธิ์เข้าถึง Toolchains ที่แก้ไขแล้วได้ด้วย กลุ่มการดำเนินการ ซึ่งคล้ายกับวิธีที่คุณ เข้าถึง 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",
     # ...
  )

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

กลุ่มการดำเนินการจะผสานรวมกับ 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++

กำลังสร้างกลุ่มผู้บริหารเพื่อตั้งค่าพร็อพเพอร์ตี้ผู้ดำเนินการ

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