Grupos de execução automática (AEGs, na sigla em inglês)

Os grupos de execução automática selecionam uma plataforma de execução para cada tipo de cadeia 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 ligados aos conjuntos de ferramentas. Se você estiver usando toolchains, defina-as 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), defina 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 da cadeia de ferramentas usada para encontrar uma plataforma de execução que ofereça suporte aos dois tipos de cadeia de ferramentas. A plataforma de execução selecionada foi usada para cada ação registrada na regra, a menos que especificado de outra forma 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 diferentes cadeias de ferramentas (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 toolchains.

Estado atual

Com os AEGs, a plataforma de execução é selecionada para cada tipo de cadeia de ferramentas. A função de implementação do exemplo anterior, my_rule, seria 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 que oferecia suporte aos dois tipos de cadeia de ferramentas. Com os AEGs, ao adicionar o parâmetro toolchain às ações, cada uma delas é 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 é válido para ctx.actions.run_shell, em que o parâmetro toolchain precisa ser adicionado quando tools são de uma cadeia de ferramentas.

Diferença entre grupos de execução personalizados e automáticos

Como o nome sugere, os AEGs são grupos executivos criados automaticamente para cada tipo de cadeia de ferramentas registrado em uma regra. Não é necessário especificá-los manualmente, ao contrário dos grupos executivos "clássicos". Além disso, o nome do AEG é definido automaticamente como o tipo de cadeia de ferramentas (por exemplo, //tools:toolchain_type_1).

Quando devo usar um exec_group personalizado?

Os exec_groups personalizados são necessários apenas quando várias toolchains 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á usa AEGs. Externamente para o Bazel, a migração está em andamento. Algumas regras já usam esse recurso, como as de Java e C++.

Quais versões do Bazel são compatíveis com essa migração?

As AEGs são totalmente compatíveis com o Bazel 7.

Como ativar as AEGs?

--incompatible_auto_exec_groups: definido como verdadeiro Mais informações sobre a flag no problema do GitHub (em inglês).

Como ativar 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 os AEGs apenas no my_rule, e as ações dele 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 AEGs em caso de erro?

Defina --incompatible_auto_exec_groups como "false" para desativar completamente os AEGs no projeto (problema da flag no GitHub) ou desative uma regra específica definindo o atributo _use_auto_exec_groups como False (mais detalhes sobre o atributo).

Mensagens de erro durante a migração para AEGs

Não foi possível identificar se as ferramentas são de dependências implícitas ou de uma cadeia de ferramentas. Defina o parâmetro do conjunto de ferramentas. Se você não estiver usando uma cadeia de ferramentas, defina como "Nenhuma".

• Nesse caso, você recebe uma pilha de chamadas antes do erro e pode ver claramente qual ação exata precisa do parâmetro da cadeia de ferramentas. Verifique qual cadeia de ferramentas é usada para a ação e defina-a com o parâmetro "toolchain". Se nenhuma cadeia de ferramentas for usada na ação para ferramentas ou executáveis, defina como None.

Ação declarada para a cadeia de ferramentas inexistente "[toolchain_type]".

• 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 None dentro da ação.

Material adicional

Para mais informações, consulte o documento de design: Grupos de execução automática para toolchains.