Grupos de ejecución

Informar un problema Ver fuente

Los grupos de ejecución permiten múltiples plataformas de ejecución dentro de un solo objetivo. 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 uno con una plataforma de ejecución potencialmente diferente. Múltiples plataformas de ejecución pueden permitir que las acciones se ejecuten de manera diferente; por ejemplo, compilar una app para iOS en un trabajador remoto (Linux) y, luego, vincular o firmar el código en un trabajador Mac local.

Poder definir grupos de acciones también ayuda a aliviar el uso de mnemónicos de acción como proxy para especificar acciones. No se garantiza que los mnemónicos sean únicos y solo pueden hacer referencia a una acción. Esto es especialmente útil para asignar recursos adicionales a memoria específica y procesar acciones intensivas, como la vinculación en compilaciones de C++ sin asignar en exceso a tareas menos exigentes.

Define grupos de ejecución

Durante la definición de la regla, los autores de las reglas 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 a fin de seleccionar una plataforma de ejecución para ese grupo, es decir, cualquier restricción mediante exec_compatible_with y tipos de cadenas de herramientas a través de 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 la herramienta también pueden especificar la transición de un grupo de ejecución con el parámetro del atributo cfg y el módulo config. El módulo expone una función exec que toma un solo parámetro de string, que es el nombre del grupo ejecutivo para el que se debe compilar la dependencia.

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

Accede a grupos de ejecución

En la implementación de reglas, puedes declarar que las acciones deben ejecutarse en la plataforma de ejecución de un grupo de ejecución. Puedes hacerlo con el parámetro exec_group de los métodos para generar acciones, en particular 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 reglas también podrán acceder a las cadenas de herramientas resueltas de los grupos de ejecución, de manera similar a como puedes acceder a las cadenas de herramientas resueltas de un objetivo:

# 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 las propiedades de ejecución

Los grupos de ejecución están integrados con el atributo exec_properties que existe en cada regla y permite que el escritor de destino especifique un diccionario de cadenas de propiedades que, luego, se pasa a la maquinaria de ejecución. Por ejemplo, si deseas establecer una propiedad (por ejemplo, la memoria) para el objetivo y asignar a ciertas acciones una asignación de memoria más alta, deberías escribir una entrada 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 el diccionario de propiedades de ejecución como {"mem": "16g"}. Como puedes ver aquí, la configuración a nivel del grupo de ejecución anula la configuración 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: Las acciones del ejecutor de pruebas
  • cpp_link: Acciones de vinculación de C++.

Grupos de ejecución y propiedades de ejecución de la plataforma

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

Por ejemplo, supongamos que ejecutar una prueba de C++ requiere que algunos recursos estén disponibles, pero no es necesario para la compilación y la vinculación. Esto se puede modelar de la siguiente manera:

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

Las exec_properties definidas directamente en los destinos tienen prioridad sobre las heredadas de la plataforma de ejecución.