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 conectados às cadeias de ferramentas. Se você estiver usando conjuntos de ferramentas, adicione o parâmetro toolchain às ações afetadas (ações que usam um executável ou uma ferramenta de um conjunto de ferramentas). 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 executável de um conjunto de ferramentas e o Blaze não detectar isso (o erro será gerado), defina toolchain = None.

Se você precisar usar várias cadeias de ferramentas em uma única plataforma de execução (uma ação usa executáveis ou ferramentas de duas ou mais cadeias de ferramentas), defina manualmente exec_groups (confira Quando devo usar um exec_group personalizado? a seção).

Histórico

Antes dos AEGs, a plataforma de execução era selecionada no nível da regra. Por exemplo:

my_rule = rule(
    _impl,
    toolchains = ['//tools:toolchain_type_1', '//tools:toolchain_type_2'],
)

A regra my_rule registra dois tipos de cadeia 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 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 cadeias de ferramentas diferentes (a plataforma de execução é selecionada para cada destino). Isso resultou em falhas quando não havia uma plataforma de execução que oferecesse suporte a todas as cadeias de ferramentas.

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: a First action, que usa executáveis de //tools:toolchain_type_1, e a Second action, que usa executáveis de //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 ação é executada na plataforma de execução que fornece a cadeia de ferramentas. As ações podem ser executadas em plataformas de execução diferentes.

O mesmo é eficaz com ctx.actions.run_shell, em que o 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á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 especificá-los manualmente, ao contrário dos grupos de execução "clássicos". Além disso, o nome do AEG é definido automaticamente como o tipo de conjunto 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 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. Por 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 processo. 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?

Os AEGs têm suporte total no Bazel 7 e versões mais recentes.

Como ativar os AEGs?

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

Como ativar os 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 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 os AEGs em caso de erro?

Defina --incompatible_auto_exec_groups como falso para desativar completamente os AEGs em seu projeto (problema do GitHub da flag) 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 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 da cadeia 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 e pode ver claramente qual ação exata precisa do parâmetro da cadeia de ferramentas. Verifique qual conjunto de ferramentas é usado para a ação e defina-o com o parâmetro do conjunto de ferramentas. Se nenhuma cadeia de ferramentas for usada na ação para ferramentas ou executáveis, defina-a como None.

Ação declarada para o conjunto 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 na ação.

Material adicional

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