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 de ejecución 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.
Herencia del grupo de ejecución
Además de definir sus propias restricciones y cadenas de herramientas, se puede ejecutar una nueva
el grupo puede declarar que quiere heredar de la ejecución predeterminada de la regla
grupo pasando el parámetro copy_from_rule = True. Es un error establecer
copy_from_rule como verdadero y para pasar también exec_compatible_with o
toolchains
Un grupo de ejecución que hereda de las copias predeterminadas del grupo de ejecución las cadenas de herramientas y las propiedades de ejecución del valor predeterminado. Esta incluye restricciones y propiedades de ejecución establecidas en el nivel objetivo, no solo aquellos especificados por la regla misma. En otras palabras, teniendo en cuenta lo siguiente:
# 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"],
)
El grupo de ejecución copied para el destino configurado demo incluirá todo
de:
- //fool_tools:toolchain_type
- @platforms//os:linux
- :local_constraint
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++
Crea grupos de ejecución para configurar propiedades de ejecución
Es posible que quieras usar un grupo de ejecución para asignar acciones específicas a diferentes
propiedades, pero que, en realidad, no quieren cadenas de herramientas ni restricciones diferentes a las
. En estos casos, puedes crear grupos de ejecución con el copy_from_rule.
parámetro:
# 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"],
),
},
)
#
Grupos de ejecución y propiedades de ejecución de plataformas
Es posible definir exec_properties para grupos de ejecución arbitrarios en
plataformas objetivo (a diferencia de exec_properties, establecida directamente en un objetivo, donde
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.