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

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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, precisará defini-los nas ações afetadas (ações que usam um executável 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 isso (o erro será gerado), você poderá definir toolchain = None.

Se você precisar usar vários conjuntos de ferramentas em uma única plataforma de execução (uma ação usa executáveis ou ferramentas de dois ou mais conjuntos de ferramentas), será necessário definir manualmente exec_groups. Consulte a seção 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 a Resolução do conjunto de ferramentas é usada para encontrar uma plataforma de execução compatível com os dois tipos de conjunto de ferramentas. A plataforma de execução selecionada foi usada para cada ação registrada dentro da regra, a menos que especificada de maneira diferente com exec_groups. Em outras palavras, todas as ações dentro da regra tinham uma única plataforma de execução, mesmo que usassem ferramentas de conjuntos de ferramentas diferentes. A plataforma de execução é selecionada para cada destino. Isso resultava em falhas quando não havia 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: First action, que usa um executável de um //tools:toolchain_type_1, e a Second action, que usa um 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 conjunto de ferramentas. Com os AEGs, ao adicionar o parâmetro toolchain dentro das ações, cada ação é executada na plataforma que fornece o conjunto de ferramentas. As ações podem ser executadas em diferentes plataformas de execução.

O mesmo funciona 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 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 é preciso especificá-los manualmente, ao contrário dos grupos de execução "clássicos". Além disso, o nome da AEG é definido automaticamente para 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 nos casos em que vários conjuntos de ferramentas precisam ser executados 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 (por exemplo, regras de 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 o flag no problema do GitHub (link em inglês).

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 na my_rule e as ações começam a usar a nova lógica ao selecionar a plataforma de execução. Uma sinalização incompatível foi substituída por este atributo.

Como desativar AEGs em caso de erro?

Defina --incompatible_auto_exec_groups como falso para desativar completamente as AEGs no projeto (problema do GitHub da sinalização) 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 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 qual conjunto de ferramentas é usado para a ação e defina-o com o parâmetro do conjunto de ferramentas. Se nenhum conjunto de ferramentas for usado dentro da ação para ferramentas ou executáveis, 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 o registrou 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.