Os grupos de execução automática selecionam uma plataforma de execução para cada tipo de conjunto de ferramentas. Em outras palavras, um destino pode ter várias plataformas de execução sem definir grupos de execução.
Resumo
Os grupos de execução automática estão intimamente conectados aos conjuntos de ferramentas. Se você estiver usando
toolchains, é necessário defini-las nas ações afetadas (ações que usam um
executável ou uma ferramenta de uma toolchain) adicionando o parâmetro toolchain. Por
exemplo:
ctx.actions.run(
...,
executable = ctx.toolchain['@bazel_tools//tools/jdk:toolchain_type'].tool,
...,
toolchain = '@bazel_tools//tools/jdk:toolchain_type',
)
Se a ação não usar uma ferramenta ou um executável de uma cadeia de ferramentas e o Blaze
não detectar isso (o erro é gerado), você poderá definir
toolchain = None.
Se você precisar usar várias toolchains em uma única plataforma de execução (uma ação usa executáveis ou ferramentas de duas ou mais toolchains), será necessário definir manualmente exec_groups (consulte a seção Quando devo usar um exec_group personalizado?).
Histórico
Antes das AEGs, a plataforma de execução era selecionada no nível da regra. Exemplo:
my_rule = rule(
_impl,
toolchains = ['//tools:toolchain_type_1', '//tools:toolchain_type_2'],
)
A regra my_rule registra dois tipos de conjunto de ferramentas. Isso significa que a resolução de
toolchain usada
para encontrar uma plataforma de execução compatível com os dois tipos de toolchain. A plataforma de execução
selecionada foi usada para cada ação registrada na regra, a menos que
seja especificada de forma diferente com exec_groups.
Em outras palavras, todas as ações dentro da regra costumavam ter uma única plataforma de execução, mesmo que usassem ferramentas de toolchains diferentes (a plataforma de execução é selecionada para cada destino). Isso resultou em falhas quando não havia uma
plataforma de execução compatível com todas as cadeias de ferramentas.
Estado atual
Com as AEGs, a plataforma de execução é selecionada para cada tipo de conjunto de ferramentas. A
função de implementação do exemplo anterior, my_rule, ficaria assim:
def _impl(ctx):
ctx.actions.run(
mnemonic = "First action",
executable = ctx.toolchain['//tools:toolchain_type_1'].tool,
toolchain = '//tools:toolchain_type_1',
)
ctx.actions.run(
mnemonic = "Second action",
executable = ctx.toolchain['//tools:toolchain_type_2'].tool,
toolchain = '//tools:toolchain_type_2',
)
Essa regra cria duas ações: First action, que usa o executável de um
//tools:toolchain_type_1, e Second action, que usa o executável de um
//tools:toolchain_type_2. Antes dos AEGs, essas duas ações eram executadas
em uma única plataforma de execução compatível com os dois tipos de cadeia de ferramentas. Com as AEGs,
adicione o parâmetro toolchain dentro das ações para que cada ação seja executada na
plataforma de execução que fornece a cadeia de ferramentas. As ações podem ser executadas
em diferentes plataformas de execução.
O mesmo acontece com ctx.actions.run_shell, em que o parâmetro toolchain
precisa ser adicionado quando tools são de um conjunto de ferramentas.
Diferença entre grupos de execução personalizados e automáticos
Como o nome sugere, os AEGs são grupos de execução criados automaticamente para cada tipo de conjunto de ferramentas registrado em uma regra. Não é necessário especificar manualmente, ao contrário dos grupos de execução "clássicos".
Quando devo usar um exec_group personalizado?
Os exec_groups personalizados são necessários apenas quando várias cadeias de ferramentas precisam ser executadas em uma única plataforma de execução. Em todos os outros casos, não é necessário definir exec_groups personalizados. Exemplo:
def _impl(ctx):
ctx.actions.run(
...,
executable = ctx.toolchain['//tools:toolchain_type_1'].tool,
tools = [ctx.toolchain['//tools:toolchain_type_2'].tool],
exec_group = 'two_toolchains',
)
my_rule = rule(
_impl,
exec_groups = {
"two_toolchains": exec_group(
toolchains = ['//tools:toolchain_type_1', '//tools:toolchain_type_2'],
),
}
)
Migração de AEGs
Internamente, no Google3, o Blaze já está usando AEGs. Externamente para o Bazel, a migração está em andamento. Algumas regras já estão usando esse recurso (por exemplo, regras Java e C++).
Quais versões do Bazel oferecem suporte a essa migração?
As AEGs têm suporte total no Bazel 7.
Como ativar as AEGs?
--incompatible_auto_exec_groups: definido como verdadeiro Mais informações sobre a flag
no problema do GitHub.
Como ativar as AEGs em uma regra específica?
Defina o atributo _use_auto_exec_groups em uma regra.
my_rule = rule(
_impl,
attrs = {
"_use_auto_exec_groups": attr.bool(default = True),
}
)
Isso ativa as AEGs apenas em my_rule, e as ações começam a usar a nova lógica
ao selecionar a plataforma de execução. A flag incompatível é substituída por esse
atributo.
Como desativar as AEGs em caso de erro?
Defina --incompatible_auto_exec_groups como "false" para desativar completamente as AEGs no
seu projeto (flag's GitHub issue) ou desative uma regra específica
definindo o atributo _use_auto_exec_groups como False
(mais detalhes sobre o atributo).
Mensagens de erro ao migrar para as AEGs
Não foi possível identificar se as ferramentas são de dependências implícitas ou de um conjunto de ferramentas. Defina o parâmetro do conjunto de ferramentas. Se você não estiver usando uma toolchain, defina como "None".
- Nesse caso, você recebe uma pilha de chamadas antes que o erro ocorra e pode
verificar exatamente qual ação precisa do parâmetro do conjunto de ferramentas. Verifique qual
toolchain é usado para a ação e defina-o com o parâmetro de toolchain. Se nenhuma
toolchain for usada na ação para ferramentas ou executáveis, defina como
None.
Ação declarada para a cadeia de ferramentas "[toolchain_type]" inexistente.
- Isso significa que você definiu o parâmetro da cadeia de ferramentas na ação, mas não o
registrou na regra. Registre a cadeia de ferramentas ou defina
Nonedentro da ação.
Material adicional
Para mais informações, consulte o documento de design: Grupos de execução automática para toolchains.