Grupos de execução

Informar um problema Acessar a origem

Os grupos de execução permitem várias plataformas de execução em um único destino. Cada grupo de execução tem as próprias dependências de conjunto de ferramentas e executa a própria resolução de conjunto de ferramentas.

Contexto

Os grupos de execução permitem que o autor da regra defina conjuntos de ações, cada um com uma plataforma de execução potencialmente diferente. Várias plataformas de execução podem permitir que as ações sejam executadas de maneira diferente, por exemplo, a compilação de um app iOS em um worker remoto (Linux) e a vinculação/assinatura de código em um worker local do Mac.

Ser capaz de definir grupos de ações também ajuda a aliviar o uso de mneumônicos como um proxy para especificar ações. Não há garantia de que as mnemônicas sejam exclusivas e só possam referenciar uma única ação. Isso é especialmente útil para alocar recursos extras à memória específica e processar ações intensivas, como a vinculação em builds C++, sem alocação excessiva para tarefas menos exigentes.

Como definir grupos de execução

Durante a definição da regra, os autores dela podem declarar um conjunto de grupos de execução. Em cada grupo de execução, o autor da regra pode especificar tudo o que é necessário para selecionar uma plataforma de execução para esse grupo, ou seja, qualquer restrição via exec_compatible_with e tipos de conjunto de ferramentas via toolchain.

# foo.bzl
my_rule = rule(
    _impl,
    exec_groups = {
        “link”: exec_group(
            exec_compatible_with = [ "@platforms//os:linux" ]
            toolchains = ["//foo:toolchain_type"],
        ),
        “test”: exec_group(
            toolchains = ["//foo_tools:toolchain_type"],
        ),
    },
    attrs = {
        "_compiler": attr.label(cfg = config.exec("link"))
    },
)

No snippet de código acima, é possível notar que as dependências da ferramenta também podem especificar a transição para um grupo de execução usando o parâmetro de atributo cfg e o módulo config. O módulo expõe uma função exec que usa um único parâmetro de string, que é o nome do grupo exec para o qual a dependência será criada.

Como nas regras nativas, o grupo de execução test está presente por padrão nas regras de teste do Starlark.

Como acessar grupos de execução

Na implementação da regra, você pode declarar que as ações precisam ser executadas na plataforma de um grupo de execução. Para fazer isso, use o parâmetro exec_group dos métodos de geração de ação, especificamente ctx.actions.run e ctx.actions.run_shell.

# foo.bzl
def _impl(ctx):
  ctx.actions.run(
     inputs = [ctx.attr._some_tool, ctx.srcs[0]]
     exec_group = "compile",
     # ...
  )

Os autores de regras também poderão acessar os conjuntos de ferramentas resolvidos de grupos de execução, da mesma forma que é possível acessar o conjunto de ferramentas resolvido de um destino:

# foo.bzl
def _impl(ctx):
  foo_info = ctx.exec_groups["link"].toolchains["//foo:toolchain_type"].fooinfo
  ctx.actions.run(
     inputs = [foo_info, ctx.srcs[0]]
     exec_group = "link",
     # ...
  )

Como usar grupos de execução para definir propriedades de execução

Os grupos de execução são integrados ao atributo exec_properties, que existe em todas as regras, e permite que o gravador de destino especifique um dicionário de string de propriedades que é transmitido para as máquinas de execução. Por exemplo, se você quiser definir uma propriedade, como memória, para o destino e dar a determinadas ações uma alocação de memória maior, grave uma entrada exec_properties com uma chave aumentada pelo grupo de execução, como:

# BUILD
my_rule(
    name = 'my_target',
    exec_properties = {
        'mem': '12g',
        'link.mem': '16g'
    }
    …
)

Todas as ações com exec_group = "link" veriam o dicionário de propriedades exec como {"mem": "16g"}. As configurações no nível do grupo de execução substituem as configurações no nível da meta.

Grupos de execução para regras nativas

Os seguintes grupos de execução estão disponíveis para ações definidas por regras nativas:

  • test: teste as ações do executor.
  • cpp_link: ações de vinculação de C++.

Grupos de execução e propriedades de execução da plataforma

É possível definir exec_properties para grupos de execução arbitrários em destinos de plataforma, ao contrário de exec_properties definido diretamente em um destino, em que as propriedades de grupos de execução desconhecidos são rejeitadas. Os destinos herdam o exec_properties da plataforma de execução que afetam o grupo de execução padrão e quaisquer outros grupos de execução relevantes.

Por exemplo, suponha que a execução de um teste em C++ exija que algum recurso esteja disponível, mas não seja necessário para compilação e vinculação. Isso pode ser modelado da seguinte maneira:

constraint_setting(name = "resource")
constraint_value(name = "has_resource", constraint_setting = ":resource")

platform(
    name = "platform_with_resource",
    constraint_values = [":has_resource"],
    exec_properties = {
        "test.resource": "...",
    },
)

cc_test(
    name = "my_test",
    srcs = ["my_test.cc"],
    exec_compatible_with = [":has_resource"],
)

exec_properties definidos diretamente nos destinos têm precedência sobre aqueles que são herdados da plataforma de execução.