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 estreitamente conectados aos conjuntos de ferramentas. Se você estiver usando
conjuntos de ferramentas, você precisa configurá-los nas ações afetadas (ações que usam uma
ou uma ferramenta de um conjunto de ferramentas) 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 um conjunto de ferramentas e o Blaze
não detectar que (o erro aparecer), será possível
toolchain = None
Se você precisar usar vários conjuntos de ferramentas em uma única plataforma de execução (uma ação use executáveis ou ferramentas de dois ou mais conjuntos de ferramentas), será necessário definir exec_groups (verificar Quando devo usar um "exec_group" personalizado? ).
Histórico
Antes dos 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 o Conjunto de ferramentas
resolução usada
para encontrar uma plataforma de execução que ofereça suporte aos dois tipos de conjunto de ferramentas. A seleção
plataforma de execução for usada para cada ação registrada dentro da regra, a menos que
especificados de maneira diferente com exec_groups.
Em outras palavras, todas as ações dentro da regra costumavam ter uma única execução
plataforma, mesmo que usassem ferramentas de conjuntos de ferramentas diferentes (plataforma de execução
é selecionada para cada destino). Isso resultava em falhas quando não havia
uma plataforma de execução compatível com todos os conjuntos de ferramentas.
Estado atual
Com os 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, a First action
, que usa arquivos executáveis
O //tools:toolchain_type_1
e o Second action
, que usa um executável de um
//tools:toolchain_type_2
. Antes dos AEGs, essas duas ações seriam executadas
em uma única plataforma de execução compatível com os dois tipos de conjunto de ferramentas. Com os AEGs,
adicionando o parâmetro toolchain
dentro das ações, cada ação será executada
a plataforma de execução que fornece o conjunto de ferramentas. As ações podem ser executadas
em diferentes plataformas de execução.
O mesmo é eficaz com ctx.actions.run_shell, em que toolchain
parâmetro precisa ser adicionado quando tools
são de um conjunto de ferramentas.
Diferença entre grupos de execução personalizados e grupos de execução automática
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 especificá-los manualmente, ao contrário do "clássico" exec.
Quando devo usar um "exec_group" personalizado?
Os exec_groups personalizados são necessários apenas nos casos em que vários conjuntos de ferramentas precisam em uma única plataforma de execução. Em todos os outros casos, não há necessidade 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á usa 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 são compatíveis com essa migração?
Os AEGs têm suporte total do Bazel 7.
Como ativar os AEGs?
--incompatible_auto_exec_groups
: definido como verdadeiro Mais informações sobre a sinalização
no problema do GitHub.
Como ativar AEGs dentro de 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 os AEGs apenas no my_rule
, e as ações começam a usar a nova lógica
ao selecionar a plataforma de execução. A sinalização incompatível foi substituída por este
.
Como desativar AEGs em caso de erro?
Defina --incompatible_auto_exec_groups
como falso para desativar completamente os AEGs em
seu projeto (sinalizar problema no GitHub) ou desativar uma regra específica
definindo o atributo _use_auto_exec_groups
como False
(mais detalhes sobre o atributo).
Mensagens de erro ao migrar para 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 um conjunto de ferramentas, defina-o como "Nenhum".
- Nesse caso, você recebe uma pilha de chamadas antes do erro ocorrer e pode
ver claramente qual ação exata precisa do parâmetro do conjunto de ferramentas. Verifique quais
conjunto de ferramentas é usado para a ação e defini-lo com o parâmetro do conjunto de ferramentas. Em caso negativo
conjunto de ferramentas for usado dentro da ação para ferramentas ou executável, defina-o como
None
:
Ação declarada para o conjunto de ferramentas '[Dataset_type]' inexistente.
- Isso significa que você definiu o parâmetro do conjunto de ferramentas na ação, mas não
registrá-la na regra. Registre o conjunto de ferramentas ou defina
None
dentro da ação.
Material adicional
Para mais informações, consulte o documento de design: Grupos de execução automática para conjuntos de ferramentas.