Opções
Com esta descrição dos modos e parâmetros disponíveis, você descobrirá que o fry
tem várias especiarias guardadas na manga para você temperar a execução do seu código.
Argumentos de linha de comando
A interface CLI oferece alguns modos de operação:
fry [OPÇÕES]
read-eval-print-loop (REPL)fry [OPÇÕES] ARQUIVO [ARGS]
executar um arquivo FatScriptfry [OPÇÕES] -b/-o ENTRADA SAÍDA
criar um bundlefry [OPÇÕES] -f ARQUIVO...
formatar arquivos de código-fonte do FatScript
Aqui estão os parâmetros de opção disponíveis:
-a, --ast
exibir apenas a árvore sintática abstrata-b, --bundle
salvar bundle em arquivo de saída (implica em -p)-c, --clock
habilitar o registro de tempo e estatísticas (benchmark)-d, --debug
habilitar logs de debug (implica em -c)-e, --error
continuar em caso de erro (alternar)-f, --format
formatar arquivos de código-fonte do FatScript-h, --help
exibir ajuda e sair-i, --interactive
iniciar REPL após execução do arquivo-k, --stack #
define a profundidade da pilha (contagem de frames)-m, --meta
exibir informações sobre a build-n, --nodes #
definir limite de memória (contagem de nós)-o, --obfuscate
ofuscar o bundle (implica em -b)-p, --probe
realizar análise estática (teste seco)-s, --save
armazenar sessão do REPL em repl.fat-v, --version
exibir número da versão e sair-w, --warranty
exibir isenção de responsabilidade e sair
Observe que, quando no modo REPL ou ao usar --probe
, a opção -e
(continuar em caso de erro) é ativada por padrão.
Gerenciamento de memória
fry
gerencia a memória automaticamente sem pré-reserva. Você pode limitar o uso da memória especificando o número de nós com as opções da CLI:
-n <count>
para uma contagem exata de nós-n <count>k
para kilonós, contagem * 1000-n <count>m
para meganós, contagem * 1000000
Por exemplo, fry -n 5k meuPrograma.fat
restringe o aplicativo a 5000 nós.
O coletor de lixo (GC) é executado automaticamente quando restam 256 nós antes que o limite final de memória seja atingido (premonição do GC). Você também pode invocar o GC a qualquer momento chamando o método runGC
da biblioteca system desde a thread principal.
Usar uma contagem de nós negativa desativa o coletor de lixo, mas ainda define o limite de memória para o valor absoluto, o que pode ser útil para fins de depuração.
Estimativa de bytes (x64)
Cada nó em uma plataforma de 64 bits usa aproximadamente ~200 bytes. O tamanho real do nó depende dos dados que ele contém. Por exemplo, o limite padrão é 10 milhões de nós, seu programa pode chegar a usar cerca de 2 GB de RAM ao atingir o limite padrão.
Use a opção -c
ou --clock
para imprimir as estatísticas de execução e ter uma melhor compreensão de como seu programa está se comportando na prática.
Verificação de tempo de execução
Existem dois comandos embutidos para verificar o uso de memória em tempo de execução:
$nodesUsage
nós alocados no momento (O(1))$bytesUsage
bytes alocados no momento (O(n))
verificar os bytes alocados no momento é uma operação cara, pois precisa percorrer todos os nós para verificar o tamanho real de cada um
Tamanho da pilha
A profundidade máxima da pilha é definida em parameters.h
, no entanto, você pode personalizar o tamanho da pilha até certo ponto usando opções da linha de comando (CLI):
-k <count>
para um número exato de frames-k <count>k
para kibiframes, count * 1024
Arquivo "run commands"
Na inicialização, fry
procura um arquivo .fryrc
no mesmo caminho do arquivo do programa e, se não encontrado, também no diretório de atual. Se encontrado, é executado como uma fase de "pré-cozimento" para configurar o ambiente para a execução do programa.
Gerenciamento de memória com .fryrc
Você pode usar o arquivo .fryrc
para definir o limite de memória para seu projeto sem precisar especificá-lo como argumento da CLI. Para fazer isso, você pode usar o método setMem
fornecido pela biblioteca system, assim:
_ <- fat.system
setMem(64000) # define 64k nós como limite de memória
Detalhes de inicialização
As opções da linha de comando são aplicadas primeiro, exceto pelo limite de memória. Durante a fase de pré-cozimento, o fry
usa o limite padrão de 10 milhões de nós, independentemente da opção da linha de comando. Se você definir um limite de memória no arquivo .fryrc
, esse limite terá efeito a partir desse ponto e substituirá a opção da linha de comando para toda a execução. Se o arquivo .fryrc
não definir um limite de memória, a opção da linha de comando terá efeito após a fase de pré-cozimento.
O escopo de pré-cozimento é invisível por padrão. Após a execução do arquivo .fryrc
, um escopo zerado é fornecido para o seu programa, o que permite testar seu código com um limite muito baixo de nós ao usar um arquivo .fryrc
sem afetar a contagem de nós. Isso também impede que o namespace .fryrc
entre em conflito com o escopo global do seu programa. No entanto, se você quiser manter as entradas declaradas no .fryrc
no escopo global para fins de configuração, pode chamar o comando embutido $keepDotFry
em algum lugar do arquivo .fryrc
.
Outro uso possível, além de configurar o limite de memória, é pré-carregar as importações comuns, por exemplo, os tipos padrão:
$keepDotFry
_ <- fat.type._