Grupos de ejecución

Informar un problema Ver fuente . Por la noche · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

Los grupos de ejecución permiten múltiples plataformas de ejecución dentro de un solo destino. Cada grupo de ejecución tiene sus propias dependencias de la cadena de herramientas y realiza su propia resolución de la cadena de herramientas.

Información general

Los grupos de ejecución permiten que el autor de la regla defina conjuntos de acciones, cada una con un una plataforma de ejecución potencialmente diferente. Múltiples plataformas de ejecución pueden permitir acciones a la ejecución de manera diferente; por ejemplo, compilar una app para iOS en un dispositivo (linux) y, luego, vinculación o firma de código en un trabajador MAC local.

Poder definir grupos de acciones también ayuda a disminuir el uso de las acciones mnemotécnicas como proxy para especificar acciones. No se garantiza que los mnemotécnicos es único y solo puede hacer referencia a una única acción. Esto es especialmente útil en Asignación de recursos adicionales a memoria específica y procesamiento de acciones de uso intensivo como vincular en compilaciones de C++ sin sobreasignar a tareas menos exigentes.

Define grupos de ejecución

Durante la definición de una regla, sus autores pueden declarar un conjunto de grupos de ejecución. En cada grupo de ejecución, el autor de la regla puede especificar todo lo necesario para seleccionar una plataforma de ejecución para ese grupo de ejecución es decir, cualquier restricción a través de exec_compatible_with y tipos de cadenas de herramientas con 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"))
    },
)

En el fragmento de código anterior, puedes ver que las dependencias de las herramientas también pueden especificar de transición para un grupo de ejecutivos con cfg el parámetro de atributo config módulo. El módulo expone una función exec que toma una sola cadena parámetro que es el nombre del grupo ejecutivo para el que se debe ejecutar la dependencia construyen.

Al igual que en las reglas nativas, el grupo de ejecución test está presente de forma predeterminada en Starlark. reglas de prueba.

Accede a grupos de ejecución

En la implementación de reglas, puedes declarar que se deben ejecutar acciones en el de ejecución de un grupo de ejecución. Para ello, usa el comando exec_group parámetro de métodos que generan acciones, específicamente ctx.actions.run y ctx.actions.run_shell

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

Los autores de las reglas también podrán acceder a las cadenas de herramientas resueltas. de grupos de ejecución, de manera similar a como puede acceder a la cadena de herramientas resuelta de un destino:

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

Usa grupos de ejecución para establecer propiedades de ejecución

Los grupos de ejecución se integran exec_properties que existe en cada regla y permite que el escritor del destino especifique una dict de cadena de propiedades que luego se pasa a la maquinaria de ejecución. Para Por ejemplo, si quieres configurar una propiedad, como la memoria, para el objetivo y otorgarle determinadas acciones una asignación de memoria más alta, escribirías un exec_properties con una clave aumentada por el grupo de ejecución, como la siguiente:

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

Todas las acciones con exec_group = "link" verían las propiedades exec. diccionario como {"mem": "16g"}. Como puedes ver aquí, el nivel de grupo de ejecución anulan los a nivel del objetivo.

Grupos de ejecución para reglas nativas

Los siguientes grupos de ejecución están disponibles para acciones definidas por reglas nativas:

  • test: Prueba las acciones del ejecutor.
  • cpp_link: Acciones de vinculación de C++

Grupos de ejecución y propiedades de ejecución de plataformas

Es posible definir exec_properties para grupos de ejecución arbitrarios en plataformas de destino (a diferencia de exec_properties, que se establece directamente en un objetivo, en la que se rechazan las propiedades de los grupos de ejecución desconocidos). Luego, los destinos heredan el exec_properties de la plataforma de ejecución que afectan el grupo de ejecución predeterminado y cualquier otro grupo de ejecución relevante.

Por ejemplo, supongamos que ejecutar una prueba de C++ requiere que haya algún recurso disponible, pero no es necesario para la compilación y la vinculación. esto se puede modelar como sigue:

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

Los exec_properties definidos directamente en los destinos tienen prioridad sobre los que se heredan de la plataforma de ejecución.