Nhóm thực thi

Các nhóm thực thi cho phép nhiều nền tảng thực thi trong một mục tiêu duy nhất. Mỗi nhóm thực thi có các phần phụ thuộc chuỗi công cụ riêng và thực hiện giải pháp chuỗi công cụ riêng.

Thông tin khái quát

Các nhóm thực thi cho phép tác giả quy tắc xác định các nhóm hành động, mỗi nhóm có một nền tảng thực thi có thể khác nhau. Nhiều nền tảng thực thi có thể cho phép cần thực thi theo cách khác nhau, chẳng hạn như biên dịch ứng dụng iOS trên một thiết bị điều khiển từ xa (linux) và sau đó liên kết/ký mã trên trình thực thi mac cục bộ.

Việc xác định các nhóm hành động cũng sẽ giúp giảm bớt việc sử dụng hành động ghi nhớ làm proxy để chỉ định hành động. Hệ thống ghi nhớ không được đảm bảo duy nhất và chỉ có thể tham chiếu một hành động. Điều này đặc biệt hữu ích trong phân bổ tài nguyên bổ sung vào bộ nhớ cụ thể và xử lý các thao tác chuyên sâu như liên kết trong các bản dựng C++ mà không phân bổ quá mức cho các tác vụ ít tốn công sức hơn.

Xác định nhóm thực thi

Trong quá trình xác định quy tắc, tác giả quy tắc có thể khai báo một tập hợp nhóm thực thi. Trên mỗi nhóm thực thi, tác giả quy tắc có thể chỉ định mọi thứ cần thiết để chọn một nền tảng thực thi cho nhóm thực thi đó, cụ thể là mọi quy tắc ràng buộc qua exec_compatible_with và các loại chuỗi công cụ qua 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"))
    },
)

Trong đoạn mã trên, bạn có thể thấy rằng các phần phụ thuộc của công cụ cũng có thể chỉ định chuyển đổi cho một nhóm thực thi bằng cách sử dụng cfg và thông số thuộc tính config . Mô-đun này hiển thị một hàm exec lấy một chuỗi duy nhất tham số là tên của nhóm exec cần chứa phần phụ thuộc tạo.

Như trên các quy tắc gốc, nhóm thực thi test hiện diện trên Starlark theo mặc định quy tắc kiểm thử.

Tính kế thừa của nhóm thực thi

Ngoài việc xác định các quy tắc ràng buộc và chuỗi công cụ riêng, một quy trình thực thi mới có thể khai báo rằng nhóm muốn kế thừa từ lần thực thi mặc định của quy tắc bằng cách truyền tham số copy_from_rule = True. Đã xảy ra lỗi khi đặt copy_from_rule thành true và cũng truyền exec_compatible_with hoặc toolchains.

Một nhóm thực thi kế thừa từ các bản sao nhóm thực thi mặc định các quy tắc ràng buộc, chuỗi công cụ và thuộc tính thực thi từ giá trị mặc định. Chiến dịch này bao gồm các điều kiện ràng buộc và thuộc tính thực thi được thiết lập ở cấp mục tiêu, chứ không chỉ các kết quả do chính quy tắc chỉ định. Nói cách khác, dựa trên những điều sau:

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

Nhóm thực thi copied cho mục tiêu demo đã định cấu hình sẽ bao gồm tất cả trong số: – //fool_tools:toolchain_type – @platforms//os:linux – :local_constraint

Truy cập vào nhóm thực thi

Trong khi triển khai quy tắc, bạn có thể khai báo rằng các thao tác sẽ được chạy trên nền tảng thực thi của một nhóm thực thi. Bạn có thể thực hiện việc này bằng cách sử dụng exec_group tham số của các phương thức tạo hành động, cụ thể là ctx.actions.run và ctx.actions.run_shell.

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

Tác giả quy tắc cũng sẽ có thể truy cập vào các chuỗi công cụ đã được phân giải nhóm thực thi, tương tự như cách bạn có thể truy cập chuỗi công cụ đã phân giải của một mục tiêu:

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

Sử dụng nhóm thực thi để thiết lập thuộc tính thực thi

Nhóm thực thi được tích hợp với exec_properties tồn tại trên mọi quy tắc và cho phép tác giả mục tiêu chỉ định một thuộc tính string dict của các thuộc tính sau đó được truyền đến máy thực thi. Cho ví dụ: nếu bạn muốn thiết lập một số thuộc tính, chẳng hạn như bộ nhớ, cho mục tiêu và một số hành động nhất định cần phân bổ bộ nhớ cao hơn, bạn sẽ viết một exec_properties mục nhập có khoá tăng cường nhóm thực thi, chẳng hạn như:

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

Tất cả các hành động với exec_group = "link" sẽ thấy thuộc tính exec từ điển dưới tên {"mem": "16g"}. Như bạn thấy ở đây, cấp nhóm thực thi các chế độ cài đặt sẽ ghi đè chế độ cài đặt cấp mục tiêu.

Nhóm thực thi cho các quy tắc gốc

Bạn có thể sử dụng các nhóm thực thi sau đây cho các hành động được xác định theo quy tắc gốc:

• test: Hành động của trình chạy kiểm thử.
• cpp_link: Các thao tác liên kết C++.

Tạo nhóm thực thi để đặt thuộc tính thực thi

Đôi khi, bạn muốn sử dụng một nhóm thực thi để đưa ra các hành động cụ thể cho những bộ phận thực thi khác nhau nhưng không thực sự muốn có các chuỗi công cụ hoặc quy tắc ràng buộc khác với . Trong những trường hợp như vậy, bạn có thể tạo các nhóm thực thi bằng cách sử dụng copy_from_rule tham số:

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

#

Nhóm thực thi và thuộc tính thực thi của nền tảng

Bạn có thể xác định exec_properties cho các nhóm thực thi tuỳ ý trên các mục tiêu nền tảng (không như exec_properties được đặt trực tiếp trên một mục tiêu, trong đó các thuộc tính cho nhóm thực thi không xác định sẽ bị từ chối). Sau đó, mục tiêu kế thừa exec_properties của nền tảng thực thi ảnh hưởng đến nhóm thực thi mặc định và bất kỳ nhóm thực thi nào khác có liên quan.

Ví dụ: giả sử việc chạy kiểm thử C++ yêu cầu phải có sẵn một số tài nguyên, nhưng không bắt buộc đối với việc biên dịch và liên kết; điều này có thể được mô hình hoá như sau:

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 được xác định trực tiếp trên các mục tiêu sẽ được ưu tiên hơn các mục tiêu được kế thừa từ nền tảng thực thi.