กลุ่มการดำเนินการช่วยให้มีแพลตฟอร์มการดำเนินการหลายแพลตฟอร์มภายในเป้าหมายเดียวได้ กลุ่มการดำเนินการแต่ละกลุ่มมีการพึ่งพาToolchainของตัวเองและ ดำเนินการแก้ไขToolchain ของตัวเอง
ฉากหลัง
กลุ่มการดำเนินการช่วยให้ผู้เขียนกฎกำหนดชุดการดำเนินการแต่ละชุดด้วยแพลตฟอร์มการดำเนินการที่อาจแตกต่างกันได้ แพลตฟอร์มการดำเนินการหลายแพลตฟอร์มช่วยให้การดำเนินการทำงานแตกต่างกันได้ เช่น การคอมไพล์แอป iOS ใน Worker ระยะไกล (Linux) แล้วลิงก์/ลงนามโค้ดใน Worker 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"))
},
)
ในข้อมูลโค้ดด้านบน คุณจะเห็นว่าการพึ่งพาเครื่องมือยังระบุ
การเปลี่ยนผ่านสำหรับกลุ่มการดำเนินการได้ด้วยการใช้
cfg
พารามิเตอร์แอตทริบิวต์ และโมดูล
config
โมดูลจะแสดงฟังก์ชัน exec ซึ่งใช้พารามิเตอร์สตริงเดียวที่เป็นชื่อของกลุ่มการดำเนินการที่ควรสร้างทรัพยากร Dependency
เช่นเดียวกับกฎเนทีฟ กลุ่มการดำเนินการ test จะปรากฏในกฎการทดสอบ Starlark โดยค่าเริ่มต้น
การสืบทอดกลุ่มการดำเนินการ
นอกเหนือจากการกำหนดข้อจำกัดและเครื่องมือของตัวเองแล้ว กลุ่มการดำเนินการใหม่ยังประกาศได้ว่าต้องการสืบทอดจากกลุ่มการดำเนินการเริ่มต้นของกฎโดยส่งพารามิเตอร์ copy_from_rule = True การตั้งค่า copy_from_rule เป็น "จริง" และส่ง 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
พารามิเตอร์ของเมธอดการสร้างการดำเนินการ ซึ่งได้แก่ 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" จะเห็นพจนานุกรมพร็อพเพอร์ตี้การดำเนินการ
เป็น {"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 ที่กำหนดโดยตรงในเป้าหมายจะมีความสำคัญมากกว่า exec_properties ที่สืบทอดมาจากแพลตฟอร์มการดำเนินการ