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.