makepp_sandboxes - On-line na nuvem

PROGRAMA:

NOME

makepp_sandboxes -- Como particionar uma compilação makepp

DESCRIÇÃO

D: --do-construir,
--não-construir,
- não ler,
--fazer-ler, I: --na caixa de areia,
--dentro da caixa de areia, O: - fora da sandbox, S: --caixa de areia,
--sandbox-aviso,
--sandbox-aviso, V: --caixa de areia virtual

Existem alguns motivos pelos quais você pode querer particionar a árvore de arquivos para um makepp
Construir:

1. Se você sabe que a maior parte da árvore não é afetada por nenhuma alteração feita
arquivos de origem desde a compilação anterior, então você pode dizer ao makepp para assumir que os arquivos
nessas partes da árvore já estão atualizadas, o que significa que nem mesmo implicitamente
carregando seus makefiles, muito menos computando e verificando suas dependências. (Observação
entretanto, os makefiles carregados explicitamente ainda serão carregados.)

2. Se você tiver vários processos makepp acessando a mesma árvore, então você deseja aumentar
um erro se você detectar que dois processos simultâneos estão escrevendo a mesma parte do
árvore, ou que um processo está lendo uma parte da árvore que um processo concorrente está
escrita. De qualquer forma, você tem uma condição de corrida na qual a ordem relativa dos eventos
em dois processos simultâneos (que não podem ser garantidos) pode afetar o resultado.

Makepp possui recursos de sandbox que atendem a ambas as preocupações.

Sandboxing Opções
As seguintes opções makepp podem ser usadas para definir as propriedades de sandbox da subárvore
dado por caminho e todos os seus arquivos e arquivos potenciais:

--não-construa caminho
--do-construir caminho
Defina ou redefina a propriedade "dont-build". Qualquer arquivo com este conjunto de propriedades é assumido como
já esteja atualizado e nenhuma verificação de compilação será realizada. O padrão é redefinido
(ou seja, "do-build"), exceto se você tiver um "RootMakeppfile", nesse caso tudo
fora de seu ID de subárvore "dont-build".

--caixa de areia caminho
--na caixa de areia caminho
--dentro da caixa de areia caminho
--fora da caixa de areia caminho
Defina ou redefina a propriedade "in-sandbox". Um erro é gerado se makepp faria de outra forma
escreva um arquivo com esta propriedade redefinida. As verificações de compilação ainda são executadas, a menos que o
A propriedade "dont-build" também está definida. O padrão é definido (ou seja, "in-sandbox"), a menos que
há algum --caixa de areia opções, nesse caso o padrão para todos os outros arquivos é
redefinir (ou seja, "fora da sandbox").

--sandbox-avisar
--sandbox-warning
Faça o downgrade das violações de "in-sandbox" e "dont-read" para avisos em vez de erros.
Isto é útil quando há centenas de violações, para que você possa coletar todas
em uma única execução e tome as medidas corretivas apropriadas. Caso contrário, você verá apenas
uma violação por invocação do makepp, e você não sabe quantas restam até
eles estão todos consertados.

--não leia caminho
--do-ler caminho
Defina ou redefina a propriedade "não ler". Um erro é gerado se makepp faria de outra forma
leia um arquivo com esta propriedade definida. O padrão é redefinido (ou seja, "fazer leitura").

--caixa de areia virtual
Não reescreva informações de compilação de arquivos que não foram criados por este processo makepp. Esse
é útil ao executar processos makepp simultâneos com sandboxes sobrepostos, e você
temos certeza de que dois processos não tentarão construir o mesmo alvo. Makepp irá
evite armazenar em cache informações adicionais sobre os arquivos que ele lê, porque
pode haver outros leitores simultâneos.

Cada uma dessas três propriedades se aplica a toda a subárvore, inclusive a arquivos que não
ainda existem. Caminhos mais específicos substituem caminhos menos específicos. Um caminho especificado pode ser um
arquivo individual, mesmo que o arquivo ainda não exista.

Se uma propriedade for definida e redefinida exatamente no mesmo caminho, a opção exibida
mais à direita na linha de comando tem precedência.

Sandboxing para Aceleração
Se você quiser evitar que o makepp perca tempo processando arquivos que você sabe que já estão
atualizado (em particular, arquivos gerados por uma ferramenta de construção diferente do makepp),
então --não-construa é a opção para você.

De longe, o caso mais comum para tal otimização é que você sabe que tudo que não
no diretório inicial ou abaixo dele já está atualizado. Isto pode ser comunicado a
makepp usando "--não-construa /. --do-construir .".

Sandboxing para Concorrente Processos
Uma técnica que pode reduzir a latência de construção é ter vários processos makepp funcionando
na mesma árvore. Isso é um pouco mais difícil de gerenciar do que usar o -j opção,
mas também pode ser substancialmente mais eficaz porque:

· Com o sandbox, os processos podem ser executados em vários hosts, por exemplo, por meio de um trabalho
sistema de filas. Aumentando o -j limite eventualmente esgota os recursos da CPU de um
host único e pode até mesmo retardar a construção devido à bifurcação excessiva do processo.

· -j atualmente não paraleliza algumas das tarefas demoradas do makepp, como carregar
makefiles, verificação, construção de dependências implícitas durante a verificação e verificação
dependências.

O maior risco com esta abordagem é que a construção pode se tornar não determinística se
processos que podem ser simultâneos interagem entre si. Isso leva à construção de sistemas
que produzem resultados incorretos esporadicamente e sem nenhum mecanismo simples para determinar por que
acontece.

Para resolver este risco, é aconselhável particionar a árvore entre processos simultâneos
de tal forma que, se algum processo acessar o sistema de arquivos incorretamente, um erro será
levantado deterministicamente imediatamente. Normalmente, isso é feito atribuindo-se a cada
processo simultâneo uma "sandbox" na qual é permitido escrever, onde as sandboxes de não
dois processos simultâneos podem se sobrepor.

Além disso, cada processo marca as sandboxes de quaisquer outros processos possivelmente simultâneos
como "não leia". Se um processo lê um arquivo, outro processo simultâneo é responsável
para escrita (e que, portanto, pode ainda não ter sido escrita), então um erro é gerado
imediatamente.

Sandboxing para Seqüencial Processos
Quando a compilação é particionada para processos makepp simultâneos, geralmente também há um
relacionamento sequencial entre vários pares de processos. Por exemplo, pode haver um
dúzia de processos de compilação simultâneos, seguidos por um único processo de link que não pode ser iniciado
até que todos os processos de compilação sejam concluídos. Essas relações sequenciais devem ser
aplicado por qualquer mecanismo que esteja orquestrando os vários processos makepp (por exemplo,
o sistema de enfileiramento de trabalhos).

Quando os processos têm um relacionamento sequencial conhecido, normalmente não há necessidade de levantar uma
erro quando acessam a mesma parte da árvore, porque o resultado ainda assim é
determinístico.

No entanto, geralmente é benéfico especificar --não-construa opções para o dependente
processo (o processo de link em nosso exemplo) que o notifica sobre as áreas que já foram
foi atualizado pelos processos de pré-requisito (os trabalhos de compilação em nosso exemplo). Nisso
Dessa forma, evitamos a maior parte do trabalho desnecessário de metas de construção nula que eram apenas
atualizado.

Use makepp_sandboxes online usando serviços onworks.net