Grupos de execução

Relatar um problema Conferir código-fonte Por noite · 7,3 · 7,2 · 7,1 · 7,0 · 6,5

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

Contexto

Os grupos de execução permitem que o autor da regra defina conjuntos de ações, cada um com um plataforma de execução potencialmente diferente. Várias plataformas de execução podem permitir para que as ações sejam executadas de forma diferente, por exemplo, compilar um aplicativo iOS em um (linux) e, em seguida, vincular/assinar de código em um worker Mac local.

Ser capaz de definir grupos de ações também ajuda a aliviar o uso de ação mnemônicas como um proxy para especificar ações. Não há garantia de que os mnemônicos sejam exclusivos e só podem fazer referência a uma única ação. Isso é especialmente útil em alocação de recursos extras para memórias específicas e ações intensivas de processamento como vincular em builds C++ sem alocação excessiva para tarefas menos exigentes.

Como definir grupos de execução

Durante a definição de uma regra, os criadores 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 era necessário para selecionar uma plataforma de execução para aquele grupo de execução, Ou seja, as restrições 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 ver que as dependências da ferramenta também podem especificar transição para um grupo executivo usando o cfg o parâmetro de atributo config mais tarde neste módulo. O módulo expõe uma função exec que usa uma única string parâmetro que é o nome do grupo exec para o qual a dependência deve ser construído.

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

Como acessar grupos de execução

Na implementação da regra, é possível declarar que as ações devem ser executadas no plataforma de execução de um grupo de execução. Para isso, use o método exec_group parâmetro de métodos que geram ações, 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 você podem 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 exec_properties atributo que existe em todas as regras e permite que o gravador desejado especifique uma dict de string das propriedades que são transmitidas para o mecanismo de execução. Para Por exemplo, se você quiser definir uma propriedade, como memória, para o destino e dar para certas ações, uma alocação de memória maior, você escreveria um exec_properties entrada com uma chave aumentada por 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 as propriedades "exec" dicionário como {"mem": "16g"}. Como mostrado aqui, a arquitetura 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: ações do executor de teste.
cpp_link: ações de vinculação C++.

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

É possível definir exec_properties para grupos de execução arbitrários na plataformas de destino, ao contrário de exec_properties definido diretamente em um destino, em que propriedades de grupos de execução desconhecidos são rejeitadas). Os destinos herdam a os 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 é necessário para compilar e vincular. isso pode ser modelado como da seguinte forma:

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.