mono - On-line na nuvem

PROGRAMA:

NOME

mono - Gerador de código nativo ECMA-CLI do Mono (Just-in-Time e Ahead-of-Time)

SINOPSE

mono [opções] lima [argumentos ...]

mono-sgen [opções] lima [argumentos ...]

DESCRIÇÃO

mono é uma implementação em tempo de execução da Common Language Infrastructure da ECMA. Isso pode ser
usado para executar aplicativos ECMA e .NET.

O tempo de execução contém um gerador de código nativo que transforma o Common Intermediate
Linguagem em código nativo.

O gerador de código pode operar em dois modos: compilação just in time (JIT) ou compilação antecipada.
compilação de tempo (AOT). Como o código pode ser carregado dinamicamente, o ambiente de tempo de execução e
o JIT está sempre presente, mesmo que o código seja compilado antecipadamente.

O tempo de execução carrega o especificado lima e opcionalmente passa o argumentos para isso. O lima
é uma montagem ECMA. Eles normalmente têm uma extensão .exe ou .dll.

O tempo de execução fornece diversas opções de configuração para execução de aplicativos, por
desenvolvimento e depuração, e para testar e depurar o próprio tempo de execução.

A mono comando usa o coletor de lixo conservador Boehm enquanto o mono-sgen comando
usa um coletor de lixo móvel e geracional.

PORTABILIDADE

Em sistemas baseados em Unix, o Mono fornece um mecanismo para emular o acesso a arquivos no estilo Windows,
isso inclui fornecer uma visão sem distinção entre maiúsculas e minúsculas do sistema de arquivos, separador de diretório
mapeamento (de \ para /) e remoção das letras das unidades.

Esta funcionalidade é habilitada configurando o MONO_IOMAP variável de ambiente para um dos
tudo, distância e caso.

Veja a descrição para MONO_IOMAP na seção de variáveis ​​de ambiente para obter mais detalhes.

TEMPO DE EXECUÇÃO OPÇÕES

As seguintes opções estão disponíveis:

--aot, --aot[=opções]
Esta opção é usada para pré-compilar o código CIL no assembly especificado para nativo
código. O código gerado é armazenado em um arquivo com extensão .so. Este ficheiro
será automaticamente captado pelo tempo de execução quando o assembly for executado.
A compilação antecipada é mais útil se você usá-la em combinação com o
-O=all,-shared sinalizador que permite que todas as otimizações no gerador de código sejam
ser realizado. Algumas dessas otimizações não são práticas para Just-in-Time
compilação, pois podem consumir muito tempo. Ao contrário do .NET Framework,
A compilação antecipada não gerará código independente de domínio: ela gera
o mesmo código que o compilador Just-in-Time produziria. Já que a maioria
aplicativos usam um único domínio, tudo bem. Se você deseja otimizar o
código gerado para uso em aplicativos de vários domínios, considere usar o -O=shared
bandeira. Isso pré-compila os métodos, mas a montagem original ainda é necessária
para executar, pois este contém os metadados e informações de exceção que não são
disponível no arquivo gerado. Ao pré-compilar o código, você pode querer compilar
com todas as otimizações (-O = todas). O código pré-compilado é um código independente de posição.
A pré-compilação é apenas um mecanismo para reduzir o tempo de inicialização e aumentar o compartilhamento de código
em vários processos mono e evita a inicialização do programa de compilação just-in-time
custos. A montagem original ainda deve estar presente, pois os metadados estão contidos
lá. O código AOT normalmente não pode ser movido de um computador para outro (CPU-
otimizações específicas que são detectadas em tempo de execução), então você não deve tentar mover
os conjuntos pré-gerados ou empacotar os conjuntos pré-gerados para
Implantação. Algumas opções estão disponíveis como parâmetro para o --aot linha de comando
opção. As opções são separadas por vírgulas e mais de uma pode ser especificada:

registro automático
O compilador AOT emitirá um inicializador de biblioteca (somente ELF) para automaticamente
registre o módulo compilado aot com o tempo de execução. Isto só é útil em
modo estático

tão mensalmente
Instrui o compilador AOT a gerar código assembly em vez de um objeto
arquivo.

versão vinculada à execução
Se especificado, força os arquivos AOT gerados a serem vinculados ao tempo de execução
versão da compilação Mono. Isso impedirá que os arquivos AOT sejam
consumido por um tempo de execução Mono diferente. cheio Este é atualmente um
recurso experimental, pois não está completo. Isso instrui Mono a
código de pré-compilação que historicamente não foi pré-compilado com AOT.

pinvoke direto
Quando esta opção é especificada, os métodos P/Invoke são invocados diretamente.
de passar pela operação de pesquisa de símbolos do sistema operacional.

caminho-llvm=
O mesmo para as ferramentas llvm 'opt' e 'llc'.

mtriplo=
Use o alvo triplo do estilo GNU para determinar alguma geração de código
opções, ou seja, --mtriple=armv7-linux-gnueabi irá gerar código direcionado
ARMv7. Atualmente, isso é compatível apenas com o back-end ARM. No modo LLVM,
esse triplo é passado para o compilador LLVM llc.

nimt-trampolins=[número]
Ao compilar em modo full aot, os trampolins IMT devem ser pré-criados em
a imagem AOT. Você pode adicionar trampolins de método adicionais com este
argumento. O padrão é 128.

bug do nó
Instrui o compilador AOT a não gerar nenhuma informação de depuração.

sem chamadas diretas
Isso evita que o compilador AOT gere chamadas diretas para um método.
O compilador AOT geralmente gera chamadas diretas para determinados métodos que não
não requer passar pelo PLT (por exemplo, métodos que são conhecidos por
não requer um gancho como um construtor estático) ou chama um método interno simples
chamadas.

anãodebug
Instrui o compilador AOT a emitir informações de depuração DWARF. Quando usado
junto com a opção nodebug, apenas as informações de depuração DWARF são
emitido, mas não as informações que podem ser usadas em tempo de execução.

nrgctx-trampolins=[número]
Ao compilar no modo full aot, os trampolins de compartilhamento genéricos devem ser
pré-criado na imagem AOT. Você pode adicionar trampolins de método adicionais com
esse argumento. O padrão é 1024.

trampolins=[número]
Ao compilar no modo full aot, o método trampolins deve ser pré-criado
na imagem AOT. Você pode adicionar trampolins de método adicionais com este
argumento. O padrão é 1024.

arquivo de saída=[nome do arquivo]
Instrui o compilador AOT a salvar a saída no arquivo especificado.

métodos de impressão ignorada
Se o compilador AOT não puder compilar um método por qualquer motivo, habilitar este
flag irá enviar os métodos ignorados para o console.

readonly-value=namespace.typename.fieldname=tipo/valor
Substitua o valor de um campo estático somente leitura. Normalmente, durante o JIT
compilação, o construtor estático é executado avidamente, então o valor de um estático
O campo readonly é conhecido no momento da compilação e o compilador pode fazer um número
de otimizações baseadas nele. Durante a AOT, em vez disso, o construtor estático
não pode ser executado, então esta opção pode ser usada para definir o valor de tal campo
e habilite o mesmo conjunto de otimizações. O tipo pode ser qualquer um entre i1, i2, i4 para
inteiros dos respectivos tamanhos (em bytes). Observe que assinado/não assinado
os números não importam aqui, apenas o tamanho do armazenamento. Esta opção pode ser
especificado várias vezes e não impede o construtor estático para
o tipo que define o campo a ser executado com as regras usuais em tempo de execução
(portanto, possivelmente calculando um valor diferente para o campo).

salvar temperatura, manter temperatura
Instrui o compilador AOT a manter arquivos temporários.

depuração suave
Isso instrui o compilador a gerar verificações de pontos de sequência que permitem
O depurador suave do Mono para depurar aplicativos mesmo em sistemas onde não está
possível definir pontos de interrupção ou passo único (certos hardware
configurações como celulares e consoles de videogame).

estático Crie um arquivo de objeto ELF (.o) ou .s que possa ser vinculado estaticamente
em um executável ao incorporar o tempo de execução mono. Quando esta opção for
usado, o arquivo objeto precisa ser registrado com o tempo de execução incorporado usando
a função mono_aot_register_module que toma como argumento o
mono_aot_module_ _info símbolo global do arquivo objeto:

extern void *mono_aot_module_hello_info;

mono_aot_register_module (mono_aot_module_hello_info);

stats Imprima várias estatísticas coletadas durante a compilação AOT.

tópicos=[número]
Esta é uma opção experimental para o compilador AOT usar vários threads
ao compilar os métodos.

prefixo da ferramenta =
Precede ao nome das ferramentas executadas pelo compilador AOT, ou seja
'como'/'ld'. Por exemplo, --tool=prefix=arm-linux-gnueabi- tornará o AOT
execução do compilador

símbolos de escrita
Instrui o compilador AOT a emitir informações de símbolos de depuração.

Para obter mais informações sobre AOT, consulte: http://www.mono-project.com/docs/advanced/aot/

--attach=[opções]
Atualmente a única opção suportada por este argumento de linha de comando é desabiltar qual
desativa a funcionalidade de anexação.

--config nome do arquivo
Carregue o arquivo de configuração especificado em vez dos arquivos padrão. O padrão
arquivos são /etc/mono/config e ~/.mono/config ou o arquivo especificado no
Variável de ambiente MONO_CONFIG, se definida. Veja o configuração mono(5) página de manual para
detalhes sobre o formato deste arquivo.

--debugger-agent=[opções]
Isso instrui o tempo de execução Mono a iniciar um agente de depuração dentro do tempo de execução Mono
e conectá-lo a uma interface de usuário cliente controlará o processo Mono. Esse
opção é normalmente usada por IDEs, como o IDE MonoDevelop.

A configuração é especificada usando uma ou mais das seguintes opções:

endereço=host:porta
Use esta opção para especificar o endereço IP onde seu cliente depurador está
ouvindo.

nível de log=NÍVEL
Especifica o nível de log de diagnóstico para

arquivo de log=nome do arquivo
Usado para especificar o arquivo onde o log será armazenado, o padrão é
saída padrão.

servidor=[s/n]
O padrão é não, com a opção padrão Mono se conectará ativamente ao
host/porta configurado com o endereço opção. Se você definir como 'y',
instrui o tempo de execução do Mono a iniciar a depuração no modo servidor, onde o Mono
espera ativamente que o front-end do depurador se conecte ao processo Mono.
O Mono imprimirá o endereço IP e a porta onde está escutando.

setpgid=[s/n]
Se definido como sim, Mono irá ligar setpgid(0, 0) on startup, if que função is
disponível on da sistema. Este is útil for assegurando que sinais entregue
para a processo que is executando da depurado e guarante que os mesmos estão não propagado para da
depurado, por exemplo, quando Ctrl-C envia SIGINT para da sdb ferramenta.

suspender=[s/n]
O padrão é sim, com a opção padrão Mono suspenderá a VM na inicialização
até que ele se conecte com êxito a um front-end do depurador. Se você configurá-lo para
'n', em conjunto com servidor=y, ele instrui o tempo de execução do Mono a ser executado como
normal, enquanto armazena em cache os metadados para enviar ao front-end do depurador em
conexão..

transporte=nome_transporte
Isto é usado para especificar o transporte que o depurador usará para
comunicar. Deve ser especificado e atualmente exige que isso seja
'dt_socket'.

--Área de Trabalho
Configura a máquina virtual para ser mais adequada a aplicativos de desktop.
Atualmente isso configura o sistema GC para evitar a expansão do heap tanto quanto possível
às custas de desacelerar um pouco a coleta de lixo.

--full-aot
Este é um sinalizador experimental que instrui o tempo de execução do Mono a não gerar nenhum
código em tempo de execução e dependem exclusivamente do código gerado a partir do uso de mono
--aot=full anteriormente. Isto é útil para plataformas que não permitem
geração de código. Observe que esse recurso abortará a execução em tempo de execução se um
codepath em seu programa ou as bibliotecas de classes do Mono tentam gerar código
dinamicamente. Você deve testar seu software antecipadamente e certificar-se de não
usar quaisquer recursos dinâmicos.

--gc=boehm, --gc=sgen
Seleciona o mecanismo Garbage Collector para Mono usar, Boehm ou SGen. Atualmente
isso apenas garante que você esteja executando o mono or mono-sgen comandos.
Este sinalizador pode ser definido no MONO_ENV_OPTIONS variável de ambiente para forçar todos
seu filho processa para usar um tipo específico de GC com o tempo de execução Mono.

--Socorro, -h
Exibe instruções de uso.

--llvm Se o tempo de execução Mono foi compilado com suporte LLVM (não disponível em todos
configurações), o Mono usará o mecanismo de otimização e geração de código LLVM para
Compilação JIT ou AOT. Para mais informações consulte: http://www.mono-
project.com/docs/advanced/mono-llvm/

--nollvm
Ao usar um Mono que foi compilado com suporte LLVM, ele força o Mono a
fallback para seu mecanismo JIT e não usar o backend LLVM.

--optimize=MODO, -O=MODO
MODE é uma lista de otimizações separada por vírgulas. Eles também permitem otimizações para
ser desativado prefixando o nome da otimização com um sinal de menos. Em geral,
O Mono foi ajustado para usar o conjunto padrão de sinalizadores, antes de usar esses sinalizadores para um
configuração de implantação, talvez você queira realmente medir os benefícios de usá-los.
Os seguintes sinalizadores de otimização são implementados no mecanismo principal:
Abcrem Remoção de verificações vinculadas ao array
all Ative todas as otimizações
aot Uso do código compilado Ahead Of Time
Otimizações de filial
cfold Dobragem constante
movimentos condicionais cmov [arquidependência]
deadce Eliminação de código morto
consprop Propagação constante
copyprop Propagação de cópia
fcmov Fast x86 FP compara [arquidependência]
float32 Execute aritmética flutuante de 32 bits usando operações de 32 bits
gshared Ativa o compartilhamento de código genérico.
inline Chamadas de método inline
intrínsecos Implementações de métodos intrínsecos
lineares Alocação de registro global de varredura linear
leaf Otimizações de procedimentos Leaf
loop Otimizações relacionadas ao loop
olho mágico Pós-passagem do olho mágico
precomp Pré-compilar todos os métodos antes de executar Main
agendado Agendamento de instruções
código de emissão por domínio compartilhado
sse2 Instruções SSE2 em x86 [arch-dependency]
tailc Recursão final e chamadas finais
Por exemplo, para permitir toda a otimização, exceto a eliminação e inlining de código morto,
você pode usar:
-O=todos,-deadce,-inline
Os sinalizadores sinalizados com [arch-dependency] indicam que a opção fornecida se
usado em combinação com a compilação Ahead of Time (--aot flag) produziria pré-
código compilado que dependerá da CPU atual e pode não ser movido com segurança para
outro computador.

As seguintes otimizações são suportadas

flutuar 32
Solicita que o tempo de execução execute operações de ponto flutuante de 32 bits usando
apenas 32 bits. Por padrão, o tempo de execução Mono tenta usar o valor mais alto
precisão disponível para operações de ponto flutuante, mas embora isso possa
renderizar melhores resultados, o código poderá ficar mais lento. Estas opções também
afeta o código gerado pelo back-end do LLVM.

em linha Controla se o tempo de execução deve tentar ser embutido (o padrão) ou não
invocações de métodos embutidos

--runtime=VERSÃO
Mono suporta diferentes versões de tempo de execução. A versão utilizada depende do programa
que está sendo executado ou em seu arquivo de configuração (denominado program.exe.config). Esse
opção pode ser usada para substituir essa autodetecção, forçando um tempo de execução diferente
versão a ser usada. Observe que isso só deve ser usado para selecionar um compatível posterior
versão de tempo de execução diferente daquela em que o programa foi compilado. Um uso típico é
para executar um programa 1.1 em uma versão 2.0:
mono --runtime=v2.0.50727 programa.exe

--segurança, --segurança=modo
Ative o gerenciador de segurança, um recurso atualmente experimental no Mono e é
DESLIGADO por padrão. O novo verificador de código também pode ser habilitado com esta opção.

Usar segurança sem parâmetros equivale a chamá-la com o "cas"
parâmetro.

Os seguintes modos são suportados:

núcleo-clr
Ativa o sistema de segurança core-clr, normalmente usado para
Aplicações de luar/luz prateada. Ele fornece uma segurança muito mais simples
sistema diferente do CAS, consulte http://www.mono-project.com/docs/web/moonlight/ for
mais detalhes e links para as descrições deste novo sistema.

válido
Habilita o novo verificador e executa verificação básica para validade do código.
Neste modo, códigos inseguros e P/Invoke são permitidos. Este modo fornece um
melhor garantia de segurança, mas ainda é possível que o código gerenciado trave
Mono.

verificável
Habilita o novo verificador e realiza verificação completa do código que está sendo
executado. Ele permite apenas a execução de código verificável. Código inseguro é
não é permitido, mas P/Invoke é. Este modo não deve permitir que código gerenciado seja
acidente mono. A verificação não é tão rigorosa quanto a norma ECMA 335 para
para permanecer compatível com o tempo de execução do MS.

O sistema de segurança atua no código do usuário: código contido no mscorlib ou no código global
o cache de assembly é sempre confiável.

--servidor
Configura a máquina virtual para ser mais adequada às operações do servidor
(atualmente, permite uma inicialização mais pesada do threadpool).

--verifique-tudo
Verifica mscorlib e assemblies no cache de assembly global para IL válido e todos
código de usuário para verificabilidade de IL.

Isso é diferente de --segurançaé verificável ou válido porque essas opções
verifique apenas o código do usuário e pule mscorlib e assemblies localizados no global
cache de montagem.

-V, --versão
Imprime informações de versão JIT (configuração do sistema, número de versão e filial
nomes, se disponíveis).

DESENVOLVIMENTO OPÇÕES

As opções a seguir são usadas para ajudar no desenvolvimento de um aplicativo JITed.

--depurar, --debug=OPÇÕES
Ativa o modo de depuração no tempo de execução. Se uma montagem foi compilada com
informações de depuração, ele produzirá informações de número de linha para rastreamentos de pilha.

O argumento opcional OPTIONS é uma lista separada por vírgulas de opções de depuração.
Essas opções estão desativadas por padrão, pois geram arquivos muito maiores e mais lentos.
código em tempo de execução.

As seguintes opções são suportadas:

lança Produz um erro detalhado ao lançar uma InvalidCastException. Esse
a opção precisa ser habilitada, pois isso gera código mais detalhado na execução
tempo.

otimizações mdb
Desative algumas otimizações JIT que normalmente só são desativadas durante a execução
dentro do depurador. Isso pode ser útil se você quiser anexar ao
executando o processo com mdb.

gdb Gere e registre informações de depuração com gdb. Isto só é suportado
em algumas plataformas e somente ao usar o gdb 7.0 ou posterior.

--profile[=profiler[:profiler_args]]
Ativa a criação de perfil. Para obter mais informações sobre criação de perfil de aplicativos e código
cobertura, consulte as seções "PERFIL" e "COBERTURA DE CÓDIGO" abaixo.

Esta opção pode ser usada múltiplas vezes, cada vez carregará um
criador de perfil adicional. Isso permite que os desenvolvedores usem módulos que estendem o JIT
através da interface de perfil Mono.

--trace[=expressão]
Mostra os nomes dos métodos à medida que são invocados. Por padrão, todos os métodos são rastreados. O
trace pode ser personalizado para incluir ou excluir métodos, classes ou assemblies. A
expressão de rastreamento é uma lista de alvos separados por vírgula, cada alvo pode ser prefixado
com um sinal de menos para desligar um alvo específico. As palavras “programa”, “todos” e
'deficiente' tem um significado especial. `programa' refere-se ao programa principal sendo
executado, e `all' significa todas as chamadas de método. A opção `disabled' é usada para
inicie com o rastreamento desativado. Ele pode ser ativado posteriormente no
programa enviando o sinal SIGUSR2 para o tempo de execução. As montagens são especificadas por
seu nome, por exemplo, para rastrear todas as chamadas na montagem do sistema, use:

mono --trace=Sistema app.exe

As classes são especificadas com o prefixo T:. Por exemplo, para rastrear todas as chamadas para o
Classe System.String, use:

mono --trace=T:System.String app.exe

E os métodos individuais são referenciados com o prefixo M: e o método padrão
notação:

mono --trace=M:System.Console:WriteLine app.exe

Exceções também podem ser rastreadas, isso fará com que um rastreamento de pilha seja impresso sempre
uma exceção do tipo especificado é lançada. O tipo de exceção pode ser especificado
com ou sem o namespace e para rastrear todas as exceções, especifique 'all' como o
Digite o nome.

mono --trace=E:System.Exception app.exe

Conforme observado anteriormente, várias regras podem ser especificadas ao mesmo tempo:

mono --trace=T:System.String,T:System.Random app.exe

Você pode excluir partes, o próximo exemplo rastreia chamadas para System.String exceto para
o método System.String:Concat.

mono --trace=T:System.String,-M:System.String:Concat

Você pode rastrear transições gerenciadas para não gerenciadas usando o qualificador wrapper:

mono --trace=wrapper app.exe

Finalmente, os namespaces podem ser especificados usando o prefixo N::

mono --trace=N:System.Xml

--no-x86-stack-align
Não alinhe stack frames na arquitetura x86. Por padrão, o Mono alinha a pilha
quadros para 16 bytes em x86, para que o ponto flutuante local e as variáveis ​​SIMD possam ser
devidamente alinhado. Esta opção desativa o alinhamento, o que geralmente salva um
instrução por chamada, mas pode resultar em ponto flutuante significativamente menor e
Desempenho do SIMD.

--jitmap
Gere um mapa de método JIT em um arquivo /tmp/perf-PID.map. Este arquivo é então usado, para
por exemplo, pela ferramenta perf incluída nos kernels Linux recentes. Cada linha do arquivo
tem:

Nome do método HEXADDR HEXSIZE

Atualmente esta opção é suportada apenas no Linux.

JIT MANUTENÇÃO OPÇÕES

As opções do mantenedor são usadas apenas por aqueles que desenvolvem o próprio tempo de execução, e não
normalmente de interesse para usuários ou desenvolvedores de tempo de execução.

--pausa método
Insere um ponto de interrupção antes do método cujo nome é `método'
(namespace.class:nome do método). Use `Main' como nome do método para inserir um ponto de interrupção
o método principal do aplicativo. Você também pode usá-lo com genéricos, por exemplo
"System.Collections.Generic.Queue`1:Peek"

--breakonex
Insere um ponto de interrupção nas exceções. Isso permite que você depure seu aplicativo com
um depurador nativo quando uma exceção é lançada.

--compilar nome
Isso compila um método (namespace.name:methodname), usado para testar o
desempenho do compilador ou para examinar a saída do gerador de código.

--compileall
Compila todos os métodos em um assembly. Isso é usado para testar o compilador
desempenho ou para examinar a saída do gerador de código

--gráfico=TIPO MÉTODO
Isso gera um arquivo postscript com um gráfico com os detalhes sobre o especificado
método (namespace.nome:nome do método). Isso requer que `dot' e ghostview sejam
instalado (espera que o Ghostview seja chamado de "gv"). Os gráficos a seguir são
disponível:
cfg Gráfico de Fluxo de Controle (CFG)
Árvore Dominadora dtree
código CFG mostrando código
ssa CFG mostrando o código após a tradução do SSA
optcode CFG mostrando código após otimizações de IR
Alguns gráficos só estarão disponíveis se determinadas otimizações estiverem ativadas.

--ncompilar
Instrua o tempo de execução sobre o número de vezes que o método especificado por --compile
(ou todos os métodos se --compileall for usado) a serem compilados. Isto é usado para
testando o desempenho do gerador de código.

--Estatísticas
Exibe informações sobre o trabalho realizado pelo tempo de execução durante a execução de um
aplicação.

--wapi=hps|semdel
Realizar manutenção dos dados compartilhados do processo. semdel irá deletar o global
semáforo. hps listará os identificadores usados ​​atualmente.

-v, --verbose
Aumenta o nível de verbosidade, cada vez que é listado, aumenta a verbosidade
nível para incluir mais informações (incluindo, por exemplo, uma desmontagem do
código nativo produzido, informações do seletor de código, etc.).

ANEXAR SUPPORT

O tempo de execução Mono permite que processos externos se conectem a um processo em execução e carreguem
assemblies no programa em execução. Para anexar ao processo, um protocolo especial é
implementado na montagem Mono.Management.

Com este suporte é possível carregar montagens que possuem um ponto de entrada (são
criado com -target:exe ou -target:winexe) para ser carregado e executado no processo Mono.

O código é carregado no domínio raiz e inicia a execução no tempo de execução especial
anexe o fio. O programa anexado deve criar seus próprios threads e retornar após
invocação.

Este suporte permite, por exemplo, depurar aplicativos tendo o shell csharp anexado
para executar processos.

PERFIL

O tempo de execução mono inclui um criador de perfil que pode ser usado para explorar vários parâmetros de desempenho.
problemas relacionados em sua aplicação. O profiler é ativado passando o --profile
argumento de linha de comando para o tempo de execução Mono, o formato é:

--profile[=profiler[:profiler_args]]

Mono tem um criador de perfil interno chamado 'default' (e também é o padrão se nenhum argumento for
especificado), mas os desenvolvedores podem escrever perfis personalizados, consulte a seção "PERFIL PERSONALIZADOS"
para mais detalhes.

Se um perfil não for especificado, o criador de perfil padrão será usado. O profiler_args é um
sequência de opções específicas do criador de perfil para o próprio criador de perfil. O criador de perfil padrão aceita
as seguintes opções 'aloc' para perfilar o consumo de memória pela aplicação; 'hora de
traçar o perfil do tempo gasto em cada rotina; 'jit' para coletar o tempo gasto em métodos de compilação JIT
e 'stat' para realizar o perfil estatístico da amostra. Se nenhuma opção for fornecida, o
o padrão é 'alocar, tempo, jit'.

Por padrão, os dados do perfil são impressos em stdout: para alterar isso, use o 'file=filename'
opção para enviar os dados para o nome do arquivo. Por exemplo:

mono --profile programa.exe

Isso executará o programa com o criador de perfil padrão e fará tempo e alocação
perfis.

mono --profile=default:stat,alloc,file=prof.out program.exe

Fará um exemplo de perfil estatístico e perfil de alocação em program.exe. O perfil
os dados são colocados em prof.out. Observe que o criador de perfil estatístico tem uma sobrecarga muito baixa e
deve ser o criador de perfil preferido a ser usado (para uma melhor saída, use o caminho completo para o mono
binário ao executar e certifique-se de ter instalado o utilitário addr2line que vem de
o pacote binutils).

LOG ANALISADOR

Este é o criador de perfil mais avançado.

O Mono log profiler pode ser usado para coletar muitas informações sobre um programa em execução
no tempo de execução Mono. Esses dados podem ser usados ​​(enquanto o processo está em execução e posteriormente)
para fazer análises do comportamento do programa, determinar o uso de recursos, problemas de desempenho ou
até procure padrões de execução específicos.

Isso é feito registrando os eventos fornecidos pelo tempo de execução Mono por meio do
interface de criação de perfil e gravá-los periodicamente em um arquivo que pode ser inspecionado posteriormente
com o relatório mprof(1) ferramenta.

Mais informações sobre como usar o log profiler estão disponíveis no site relatório mprof(1)
Disputas de Comerciais.

SUPORTE PERFIS

Mono fornece um mecanismo para carregar outros módulos de perfil que na forma de arquivos compartilhados
bibliotecas. Esses módulos de criação de perfil podem ser conectados a várias partes do tempo de execução do Mono para
coletar informações sobre o código que está sendo executado.

Para usar um profiler de terceiros você deve passar o nome do profiler para o Mono, assim:

mono --profile = programa personalizado.exe

No exemplo acima, o Mono carregará o criador de perfil definido pelo usuário da biblioteca compartilhada
`mono-profiler-custom.so'. Este módulo do criador de perfil deve estar na sua biblioteca do vinculador dinâmico
caminho.

Uma lista de outros criadores de perfil de terceiros está disponível no site da Mono (www.mono-
project.com/docs/advanced/performance-tips/)

Perfis personalizados são gravados como bibliotecas compartilhadas. A biblioteca compartilhada deve ser chamada de `mono-
profiler-NAME.so' onde `NAME' é o nome do seu criador de perfil.

Para obter um exemplo de como escrever seu próprio criador de perfil personalizado, procure na árvore de origem do Mono em
as amostras/profiler.c.

CÓDIGO COBERTURA

Mono vem com um módulo de cobertura de código. Este módulo é ativado usando o Mono
--profile = opção cov. O formato é: --profile=cov[:nome-montagem[/namespace]] teste-
suíte.exe

Por padrão, a cobertura de código será padronizada para todos os assemblies carregados, você pode limitar isso
especificando o nome do assembly, por exemplo, para realizar cobertura de código nas rotinas do seu
uso do programa, por exemplo, a linha de comando a seguir limita a cobertura do código às rotinas
na montagem "demo":

mono --profile=cov:demo demo.exe

Observe que o nome da assembleia não inclui a extensão.

Você pode restringir ainda mais a saída de cobertura de código especificando um namespace:

mono --profile=cov:demo/My.Utilities demo.exe

Que executará apenas a cobertura de código no assembly e no namespace especificados.

A saída típica é assim:

Não coberto: Classe:.ctor()
Não coberto: Classe:A ()
Não coberto: Driver:.ctor()
Não coberto: Driver:método ()
Cobertura parcial: Driver:Principal ()
deslocamento 0x000a

Os deslocamentos exibidos são deslocamentos IL.

Uma ferramenta de cobertura mais poderosa está disponível no módulo `monocov'. Veja o monocópia(1)
página do manual para detalhes.

DEPURAÇÃO AUXILIA

Para depurar aplicativos gerenciados, você pode usar o mdb comando, um depurador de linha de comando.

É possível obter um stack trace de todas as threads ativas no Mono enviando o comando
Sinal QUIT para Mono, você pode fazer isso na linha de comando, assim:

matar -QUIT pid

Onde pid é o ID do processo Mono que você deseja examinar. O processo irá
continue correndo depois, mas seu estado não é garantido.

Importante: este é um mecanismo de último recurso para depuração de aplicativos e não deve ser
usado para monitorar ou testar um aplicativo de produção. A integridade do tempo de execução após
o envio deste sinal não é garantido e o aplicativo pode travar ou encerrar a qualquer momento.
dado ponto depois.

A --debug=casts opção pode ser usada para obter informações mais detalhadas sobre elenco inválido
operações, fornecerá informações sobre os tipos envolvidos.

Você pode usar as variáveis ​​de ambiente MONO_LOG_LEVEL e MONO_LOG_MASK para obter detalhes
saída de depuração sobre a execução do seu aplicativo no Mono.

A MONO_LOG_LEVEL variável de ambiente, se definida, o nível de registro será alterado para definido
valor. Os valores possíveis são "erro", "crítico", "aviso", "mensagem", "informações", "depuração". O
o valor padrão é "erro". Mensagens com um nível de registro maior ou igual ao registro
o nível será impresso em stdout/stderr.

Use "info" para rastrear o carregamento dinâmico de montagens.

Use o MONO_LOG_MASK variável de ambiente para limitar a extensão das mensagens que você recebe: Se
definido, a máscara de log é alterada para o valor definido. Os valores possíveis são "asm" (montagem
loader), "type", "dll" (carregador de biblioteca nativa), "gc" (coletor de lixo), "cfg" (config
carregador de arquivos), "aot" (pré-compilador), "segurança" (por exemplo, suporte ao Moonlight CoreCLR) e "todos".
O valor padrão é "todos". Alterar o valor da máscara permite exibir apenas mensagens
para um determinado componente. Você pode usar várias máscaras separando-as por vírgula. Por exemplo
para ver as mensagens do arquivo de configuração e as mensagens do carregador de montagem, defina sua máscara como "asm, cfg".

O seguinte é um uso comum para rastrear problemas com P/Invoke:

$ MONO_LOG_LEVEL="depurar" MONO_LOG_MASK="dll" mono cola.exe

DEPURAÇÃO COM LLDB

Se você estiver usando LLDB, poderá usar o mono.py script para imprimir alguns dados internos
estruturas com ele. Para usar isso, adicione isso ao seu $HOME/.lldbinit arquivo:
importação de script de comando $PREFIX/lib/mono/lldb/mono.py

Onde $PREFIX é o valor do prefixo que você usou quando configurou o Mono (normalmente / usr).

Feito isso, você pode inspecionar algumas estruturas de dados do Mono Runtime, por exemplo:
(lldb) método p

(MonoMethod *) $0 = 0x05026ac0 [mscorlib]System.OutOfMemoryException:.ctor()

SERIALIZAÇÃO

O mecanismo de serialização XML do Mono, por padrão, usará uma abordagem baseada em reflexão para
serialize, que pode ser lento para processamento contínuo (aplicativos de serviço da web). O
mecanismo de serialização determinará quando uma classe deve usar um serializador ajustado manualmente com base em
alguns parâmetros e, se necessário, produzirá um serializador C# personalizado para seus tipos
em tempo de execução. Este serializador personalizado é carregado dinamicamente em seu
aplicação.

Você pode controlar isso com a variável de ambiente MONO_XMLSERIALIZER_THS.

Os valores possíveis são 'não' para desabilitar o uso de um serializador personalizado C# ou um
inteiro que é o número mínimo de usos antes que o tempo de execução produza um personalizado
serializador (0 produzirá um serializador personalizado no primeiro acesso, 50 produzirá um
serializador no 50º uso). Mono irá recorrer a um serializador interpretado se o
a geração do serializador falha de alguma forma. Este comportamento pode ser desabilitado definindo a opção
`sem retorno' (por exemplo: MONO_XMLSERIALIZER_THS=0,nofallback).

MEIO AMBIENTE VARIÁVEIS

GC_DONT_GC
Desativa a coleta de lixo no Mono. Isso deve ser usado apenas para depuração
fins

LVM_COUNT
Quando o Mono é compilado com suporte a LLVM, isso instrui o tempo de execução a parar de usar
LLVM após o número especificado de métodos ser JITed. Esta é uma ferramenta usada em
diagnósticos para ajudar a isolar problemas no back-end de geração de código. Por exemplo
LLVM_COUNT=10 compilaria apenas 10 métodos com LLVM e depois mudaria para o Mono
Motor JIT. LLVM_COUNT=0 desabilitaria completamente o mecanismo LLVM.

MONO_AOT_CACHE
Se definida, esta variável instruirá o Mono a compilar antecipadamente novos assemblies em
demanda e armazena o resultado em um cache em ~/.mono/aot-cache.

MONO_ASPNET_INHIBIT_SETTINGSMAP
Mono contém um recurso que permite modificar configurações nos arquivos .config
fornecido com o Mono usando mapeadores de seção de configuração. Os mapeadores e o mapeamento
regras são definidas no arquivo $prefix/etc/mono/2.0/settings.map e, opcionalmente, em
o arquivo settings.map encontrado no diretório de nível superior do seu aplicativo ASP.NET.
Ambos os arquivos são lidos pelo System.Web na inicialização do aplicativo, se forem encontrados no
locais acima. Se você não deseja que o mapeamento seja realizado, você pode definir isso
variável em seu ambiente antes de iniciar o aplicativo e nenhuma ação será
ocupado.

MONO_ASPNET_WEBCONFIG_CACHESIZE
Mono possui um cache de objetos ConfigSection para acelerar o WebConfigurationManager
consultas. Seu tamanho padrão é 100 itens e quando mais itens são necessários, o cache
despejos começam a acontecer. Se os despejos forem demasiado frequentes, isso poderá impor
sobrecarga desnecessária, que poderia ser evitada usando esta variável de ambiente para
configure um tamanho de cache maior (ou reduza os requisitos de memória diminuindo-o).

MONO_CAIRO_DEBUG_DISPOSE
Se definido, faz com que o Mono.Cairo colete rastreamentos de pilha quando os objetos são alocados, então
que os avisos de finalização/descarte incluam informações sobre a instância
origem.

MONO_CFG_DIR
Se definida, esta variável substitui o diretório de configuração padrão do sistema
($PREFIX/etc). É usado para localizar o arquivo machine.config.

MONO_COM
Define o estilo de interoperabilidade COM. Se o valor desta variável for "MS" Mono usará
rotinas de empacotamento de string do liboleaut32 para a biblioteca de tipos BSTR, qualquer
outros valores usarão o empacotamento de string BSTR mono-integrado.

MONO_CONFIG
Se definida, esta variável substitui o arquivo de configuração de tempo de execução padrão
($PREFIX/etc/mono/config). As opções de linha de comando --config substituem as
variável de ambiente.

MONO_CPU_ARCH
Substitua o mecanismo de detecção automática da CPU. Atualmente usado apenas no braço. O
o formato do valor é o seguinte:

"armvV [polegar[2]]"

onde V é o número da arquitetura 4, 5, 6, 7 e as opções podem ser atualmente
"polegar" ou "polegar2". Exemplo:

MONO_CPU_ARCH="polegar armv4" mono ...

MONO_ARM_FORCE_SOFT_FLOAT
Quando o Mono é construído com um substituto de flutuação suave no ARM e esta variável é definida como
"1", Mono sempre emitirá código de flutuação suave, mesmo se uma unidade VFP for detectada.

MONO_DISABLE_AIO
Se definido, diz ao mono para NÃO tentar usar serviços de E/S assíncronos nativos. Naquilo
Nesse caso, uma implementação padrão de seleção/pesquisa é usada. Atualmente apenas epoll() é
suportado.

MONO_DISABLE_MANAGED_COLLATION
Se esta variável de ambiente for `sim', o tempo de execução usará agrupamento não gerenciado (que
na verdade, significa que não há agrupamento sensível à cultura). Ele desativa internamente o gerenciamento
funcionalidade de agrupamento invocada por meio dos membros de System.Globalization.CompareInfo
aula. O agrupamento está habilitado por padrão.

MONO_DISABLE_SHM
Somente Unix: se definido, desativa os arquivos de memória compartilhada usados ​​para identificadores de processo cruzado:
processo tem apenas identificadores privados. Isso significa que os identificadores de processo e thread são
não está disponível para outros processos e mutexes nomeados, eventos nomeados e
semáforos não são visíveis entre processos. Isso também pode ser ativado por
padrão passando a opção "--disable-shared-handles" para configurar. Isto é o
padrão de mono 2.8 em diante.

MONO_DISABLE_SHARED_AREA
Somente Unix: se definido, desativa o uso de memória compartilhada para expor o desempenho
contadores. Isso significa que não será possível ler externamente o desempenho
contadores deste processo ou leia aqueles de processos externos.

MONO_DNS
Quando definido, permite o uso de um resolvedor DNS totalmente gerenciado em vez do normal
funções libc. Este resolvedor tem um desempenho muito melhor quando várias consultas são executadas em
paralelo.

Observe que /etc/nsswitch.conf será ignorado.

MONO_EGD_SOCKET
Para plataformas que de outra forma não possuem uma maneira de obter bytes aleatórios, isso pode
ser definido como o nome de um soquete do sistema de arquivos no qual um daemon egd ou prngd está
ouvindo.

MONO_ENABLE_SHM
Somente Unix: Habilite o suporte para identificadores de processos cruzados. Os identificadores de processo cruzado são
usado para expor identificadores de processo, identificadores de thread, mutexes nomeados, eventos nomeados e
semáforos nomeados em processos Unix.

MONO_ENV_OPTIONS
Esta variável de ambiente permite passar argumentos de linha de comando para um Mono
processo através do ambiente. Isto é útil, por exemplo, para forçar todos os seus
Processos mono para usar LLVM ou SGEN sem precisar modificar nenhum script de inicialização.

MONO_ENV_OPTIONS
Usado para passar opções extras para o agente depurador em tempo de execução, como eram
passado usando --debugger-agent=.

MONO_EVENTLOG_TYPE
Define o tipo de provedor de log de eventos a ser usado (para System.Diagnostics.EventLog).
Os valores possíveis são:

local[:caminho]
Persiste logs de eventos e entradas no sistema de arquivos local. O diretório em
para persistir os logs de eventos, fontes de eventos e entradas podem ser especificadas
como parte do valor. Se o caminho não for definido explicitamente, o padrão será
"/var/lib/mono/eventlog" no unix e "%APPDATA%no\ventlog" no Windows.

win32 Uso da nativo win32 API para escrever eventos e registradores evento toras e evento
fontes no registro. Isso está disponível apenas no Windows. No Unix, o
permissão de diretório para log de eventos individuais e diretórios de origem de eventos
está definido como 777 (com bit +t) permitindo que todos leiam e gravem o log de eventos
entradas, permitindo apenas que as entradas sejam excluídas pelo(s) usuário(s) que
os criou.

nulo Descarta silenciosamente quaisquer eventos.

O padrão é "nulo" no Unix (e versões do Windows anteriores ao NT) e "win32" no
Windows NT (e superior).

MONO_EXTERNAL_ENCODINGS
Se definido, contém uma lista separada por dois pontos de codificações de texto para tentar ao virar
texto gerado externamente (por exemplo, argumentos de linha de comando ou nomes de arquivos) em Unicode.
Os nomes de codificação vêm da lista fornecida por iconv, e o caso especial
"default_locale" que se refere à codificação padrão da localidade atual.

Ao ler strings de texto geradas externamente, o UTF-8 é tentado primeiro e, em seguida, este
list é tentada em ordem, com a primeira conversão bem-sucedida encerrando a pesquisa.
Ao escrever texto externo (por exemplo, novos nomes de arquivos ou argumentos para novos processos), o
primeiro item desta lista é usado ou UTF-8 se a variável de ambiente não estiver definida.

O problema de usar MONO_EXTERNAL_ENCODINGS para processar seus arquivos é que
resulta em um problema: embora seja possível obter o nome de arquivo correto, não é
necessariamente possível abrir o arquivo. Em geral, se você tiver problemas com
codificações em seus nomes de arquivos você deve usar o programa "convmv".

MONO_GC_PARAMS
Ao usar Mono com o coletor de lixo SGen esta variável controla vários
parâmetros do coletor. O valor da variável é uma lista separada por vírgulas de
palavras.

tamanho do berçário =tamanho
Define o tamanho do berçário. O tamanho é especificado em bytes e deve ser um
potência de dois. Os sufixos `k', `m' e `g' podem ser usados ​​para especificar quilo-,
mega e gigabytes, respectivamente. A creche é a primeira geração (de
dois). Um viveiro maior normalmente acelerará o programa, mas obviamente
usar mais memória. O tamanho padrão do berçário é 4 MB.

maior=coletor Especifica qual coletor principal usar.
As opções são `marksweep' para o coletor Mark&Sweep e `marksweep-conc'
para Mark&Sweep simultâneo. O coletor Mark&Sweep não concorrente é o
padrão.

limite de heap suave=tamanho
Quando o tamanho do heap ficar maior que esse tamanho, ignore qual é o principal padrão
a métrica de gatilho de coleta diz e permite apenas quatro tamanhos de viveiros de grande porte
crescimento de heap entre as principais coleções.

limite de evacuação=limiar
Define o limite de evacuação em percentagem. Esta opção só está disponível em
os principais colecionadores da Mark&Sweep. O valor deve ser um número inteiro no intervalo
0 a 100. O padrão é 66. Se a fase de varredura da coleção encontrar
que a ocupação de um tipo específico de bloco de heap é menor que isso
porcentagem, ele fará uma coleta de cópias para aquele tipo de bloco na próxima
grande arrecadação, restaurando assim a ocupação para perto de 100 por cento. A
o valor 0 desativa a evacuação.

(não) varredura preguiçosa
Ativa ou desativa a varredura lenta para o coletor Mark&Sweep. Se habilitado,
a varredura dos principais blocos de heap individuais é feita gradativamente sempre que o
surge a necessidade, normalmente durante as coletas do berçário. A varredura lenta está ativada
por padrão.

(não) varredura simultânea
Ativa ou desativa a varredura simultânea para o coletor Mark&Sweep. Se
habilitado, a iteração de todos os blocos principais para determinar quais deles podem ser
liberados e quais devem ser mantidos e varridos, é feito simultaneamente com
o programa em execução. A varredura simultânea está habilitada por padrão.

marca de pilha =modo de marcação
Especifica como os threads do aplicativo devem ser verificados. As opções são `precisas`
e `conservador`. A marcação precisa permite ao coletor saber quais valores
na pilha estão referências e o que não são. A marcação conservadora ameaça todos
valores como referências potenciais e deixá-los intocados. Marcação precisa
reduz o lixo flutuante e pode acelerar a coleta e alocação do berçário
taxa, tem a desvantagem de exigir uma memória extra significativa por
método compilado. A opção certa, infelizmente, requer experimentação.

proporção de salvamento =relação
Especifica a taxa de salvamento desejada para o coletor principal. O coletor permite
uma determinada quantidade de memória a ser promovida do berçário devido a menores
coleções antes de acionar uma coleção principal. Este montante é baseado
quanta memória ele espera liberar. É representado como uma proporção do tamanho
da pilha após uma grande coleção. Os valores válidos estão entre 0.1 e 2.0.
O padrão é 0.5. Valores menores manterão o tamanho do heap principal menor
mas irá desencadear mais coleções importantes. Da mesma forma, valores maiores usarão
mais memória e resultam em coleções principais menos frequentes. Esta opção é
EXPERIMENTAL, portanto pode desaparecer em versões posteriores do mono.

proporção de subsídio padrão =relação
Especifica o subsídio de alocação padrão quando o tamanho calculado é muito
pequeno. A permissão de alocação é quanta memória o coletor deixa ser
promovida antes de desencadear uma grande arrecadação. É uma proporção do berçário
tamanho. Os valores válidos estão entre 1.0 e 10.0. O padrão é 4.0. Menor
valores levam a heaps menores e coleções principais mais frequentes. Da mesma maneira,
valores maiores permitirão que o heap cresça mais rápido, mas usará mais memória quando
atinge um tamanho estável. Esta opção é EXPERIMENTAL, então pode desaparecer
em versões posteriores do mono.

menor =colecionador menor
Especifica qual coletor secundário usar. As opções são 'simples', o que promove
todos os objetos do berçário diretamente para a velha geração e 'divididos'
o que permite que o objeto fique mais tempo no berçário antes de ser promovido.

proporção de alocação=relação
Especifica a proporção de memória do berçário a ser usada pelo espaço de alocação.
Isso só pode ser usado com o coletor secundário dividido. Os valores válidos são
números inteiros entre 1 e 100. O padrão é 60.

idade da promoção =idade
Especifica a idade exigida que um objeto deve atingir dentro do berçário antes
foi promovido à velha geração. Isso só pode ser usado com o
dividir colecionador menor. Os valores válidos são números inteiros entre 1 e 14. Padrão
é 2.

(não) cimentação
Ativa ou desativa a cimentação. Isto pode reduzir drasticamente
tempos de coleta em alguns benchmarks onde objetos fixados são referidos
da pilha principal.

MONO_GC_DEBUG
Ao usar Mono com o coletor de lixo SGen, esta variável de ambiente pode ser
usado para ativar vários recursos de depuração do coletor. O valor disso
variável é uma lista de palavras separadas por vírgula. Não use essas opções em
produção.

número Define o nível de depuração para o número especificado.

subsídio de impressão
Depois de cada coleção principal imprime o consumo de memória antes e depois
a arrecadação e o subsídio para o cobrador menor, ou seja, quanto custa
heap pode crescer a partir de coleções menores antes da próxima grande
a coleta é acionada.

fixação de impressão
Reúne estatísticas sobre as turmas cujos objetos estão fixados na creche
e para os quais entradas de remset globais são adicionadas. Imprime essas estatísticas quando
desligando.

coletar antes de alocar

verificar coleções menores
Isso executa uma verificação de consistência em coleções menores e também limpa o
berçário no momento da coleta, em vez do padrão, quando os buffers são
alocado (clear-at-gc). A verificação de consistência garante que não haja
referências maiores para menores que não estão nos conjuntos lembrados.

verificação de consistência mod-union
Verifica se a tabela de cartas mod-union é consistente antes de cada finalização
grande pausa na coleta. Esta verificação só é aplicável a grandes
colecionadores.

bits de marca de seleção
Verifica se os bits de marcação no heap principal são consistentes no final de cada
grande coleção. Bits de marcação consistentes significam que se um objeto for marcado,
todos os objetos aos quais ele tinha referências também devem ser marcados.

cheque-berçário-fixado
Após as coletas em berçário e antes de iniciar as coletas simultâneas, verifique
se todos os objetos do berçário estão fixados ou não - dependendo
contexto. Não faz nada quando o coletor de berçário dividido é usado.

verificações de xdomain
Executa uma verificação para garantir que nenhuma referência seja deixada para um descarregado
AppDomain.

criação clara na tlab
Limpa o berçário de forma incremental quando os buffers de alocação local do thread
(TLAB) são criados. A configuração padrão limpa todo o berçário no GC
tempo.

debug-clear-at-tlab-creation
Limpa o berçário de forma incremental quando os buffers de alocação local do thread
(TLAB) são criados, mas no momento do GC o preenche com o byte `0xff`, que
deve resultar em uma falha mais rapidamente se `clear-at-tlab-creation` não
funcionar corretamente.

limpar no gc
Isso limpa o berçário no momento do GC, em vez de fazer isso quando o thread local
buffer de alocação (TLAB) é criado. O padrão é limpar o berçário em
Hora de criação do TLAB.

desabilitar-menor
Não faça coleções menores. Se o viveiro estiver cheio, uma grande arrecadação é
em vez disso, acionado, a menos que também esteja desativado.

desativar principal
Não faça grandes coleções.

marca de pilha conservadora
Força o GC a varrer a pilha de forma conservadora, mesmo que a varredura precisa seja
disponíveis.

alocador sem gerenciamento
Desativa o alocador gerenciado.

verificação-scan-inicia
Se definido, faz uma verificação de plausibilidade no scan_starts antes e depois de cada
coleção

verificar-berçário-em-menor-gc
Se definido, faz um passeio completo pelos objetos do berçário no início de cada
coleção menor.

despejar-berçário-em-menor-gc
Se definido, despeja o conteúdo do berçário no início de cada menor
coleção. Requer que verify-nursery-at-minor-gc seja definido.

heap-dump =lima
Faz dump do conteúdo do heap no arquivo especificado. Para visualizar o
informações, use a ferramenta mono-heapviz.

protocolo binário =lima
Gera a saída de depuração para o arquivo especificado. Para que isso funcione, Mono
precisa ser compilado com o BINARY_PROTOCOL definido em sgen-gc.c. Você pode
então use este comando para explorar a saída
sgen-grep-binprot 0x1234 0x5678 <arquivo

berçário-canários
Se definido, os objetos alocados no berçário recebem o sufixo de um canário (guarda)
palavra, que é verificada em cada coleção secundária. Pode ser usado para detectar/depurar
problemas de corrupção de pilha.

não finalizar
Se ativado, os finalizadores não serão executados. Todo o resto não será afetado:
objetos finalizáveis ​​ainda serão colocados na fila de finalização onde eles
sobreviver até que estejam programados para serem finalizados. Uma vez que eles não estão na fila
mais eles serão coletados regularmente.

finalizadores de log
Registre detalhadamente o processo de finalização para ajudar na depuração.

MONO_GAC_PREFIX
Fornece um prefixo que o tempo de execução usa para procurar caches de assembly globais. Diretórios
são separados pelo separador de caminho da plataforma (dois pontos no unix). MONO_GAC_PREFIX
deve apontar para o diretório superior de uma instalação prefixada. Ou para o diretório
fornecido no comando gacutil /gacdir. Exemplo:
/home/nome de usuário/.mono:/usr/local/mono/

MONO_IOMAP
Habilita algum suporte para reescrita de nome de arquivo para ajudar aplicativos mal escritos que
caminhos do Windows codificados. Defina uma lista separada por dois pontos de "unidade" para remover a unidade
letras ou "case" para fazer a correspondência de arquivos sem distinção entre maiúsculas e minúsculas em todos os diretórios de um
caminho. "all" habilita todos os métodos de reescrita. (As barras invertidas são sempre mapeadas para
barras se esta variável estiver definida como uma opção válida).
Por exemplo, isso funcionaria no shell:

MONO_IOMAP=unidade:caso
exportar MONO_IOMAP

Se você estiver usando mod_mono para hospedar suas aplicações web, você pode usar o MonoIOMAP
diretiva em vez disso, assim:

MonoIOMAP todos

See mod_mono(8) para obter mais detalhes.

Adicionalmente. Mono inclui um módulo de perfil que permite rastrear o que
ajustes nos caminhos de arquivo que o código IOMAP precisa fazer. O código de rastreamento informa o
local gerenciado (rastreamento de pilha completo) a partir do qual a chamada IOMAP foi feita e, em
saída do processo, os locais onde todas as strings editadas pelo IOMAP foram criadas no gerenciado
código. Este último relatório é apenas aproximado, pois nem sempre é possível
estimar o local real onde a string foi criada. O código usa simples
heurística - analisa o rastreamento de pilha que leva de volta ao local de alocação da string
e ignora todo o código gerenciado que também reside em assemblies instalados no GAC
como nas bibliotecas de classes fornecidas com o Mono (uma vez que são consideradas livres de
questões de sensibilidade a maiúsculas e minúsculas). Em seguida, ele informa o primeiro local no código do usuário -
na maioria dos casos este será o local onde a string está alocada ou muito próximo
a localização. O código de relatório é implementado como um módulo de perfil personalizado (consulte
seção "PROFILING") e pode ser carregado da seguinte maneira:

mono --profile=iomap seuaplicativo.exe

Observe, entretanto, que o Mono atualmente suporta apenas um módulo de perfil por vez.

MONO_LLVM
Quando o Mono está usando o backend de geração de código LLVM, você pode usar este ambiente
variável para passar opções de geração de código para o compilador LLVM.

MONO_MANAGED_WATCHER
Se definido como "desativado", System.IO.FileSystemWatcher usará um observador de arquivos
implementação que ignora silenciosamente todas as solicitações de observação. Se definido como qualquer
outro valor, System.IO.FileSystemWatcher usará o gerenciado padrão
implementação (lenta). Se não for definido, o mono tentará usar inotify, FAM, Gamin, kevent
em sistemas Unix e chamadas de API nativas no Windows, recorrendo ao gerenciado
implementação em caso de erro.

MONO_MESSAGING_PROVIDER
Mono suporta um modelo de plugin para sua implementação de System.Messaging tornando-o
possível suportar uma variedade de implementações de mensagens (por exemplo, AMQP, ActiveMQ).
Para especificar qual implementação de mensagens deve ser usada, a variável evironement
precisa ser definido como o nome completo da classe do provedor. Por exemplo, para usar o RabbitMQ
implementação AMQP baseada, a variável deve ser definida como:

Mono.Messaging.RabbitMQ.RabbitMQMessagingProvider,Mono.Messaging.RabbitMQ

MONO_NO_SMP
Se definido, faz com que o processo mono seja vinculado a um único processador. Isto pode ser
útil ao depurar ou contornar condições de corrida.

MONO_NO_TLS
Desative o inlining de acessos locais de thread. Tente definir isso se você receber um segfault
no início da execução de mono.

MONO_PATH
Fornece um caminho de pesquisa para o tempo de execução onde procurar pela biblioteca
arquivos. Esta é uma ferramenta conveniente para depuração de aplicativos, mas
não deve ser usado por aplicativos implantados, pois quebra a montagem
carregador de maneiras sutis.
Os diretórios são separados pelo separador de caminho da plataforma (dois pontos no Unix). Exemplo:
/ home / nome de usuário / lib: / usr / local / mono / lib
Os caminhos relativos são resolvidos com base no diretório atual no momento da inicialização.
Soluções alternativas para MONO_PATH incluem: instalar bibliotecas em
o Cache de Assembly Global (veja gacutil(1)) ou ter o dependente
bibliotecas lado a lado com o executável principal.
Para obter uma descrição completa das práticas recomendadas para aplicação
implantação, consulte
http://www.mono-project.com/docs/getting-started/application-deployment/

MONO_RTC
Suporte experimental de RTC no criador de perfil estatístico: se o usuário tiver
a permissão, estatísticas mais precisas são coletadas. O MONO_RTC
o valor deve ser restrito ao que o rtc do Linux permite: potência de dois
de 64 a 8192Hz. Para habilitar frequências mais altas como 4096 Hz, execute como root:

eco 4096 > /proc/sys/dev/rtc/max-user-freq

Por exemplo:

MONO_RTC=4096 mono --profiler=padrão:stat program.exe

MONO_SHARED_DIR
Se definido, é o diretório onde o estado do identificador ".wapi" está armazenado. Isto é o
diretório onde a camada de emulação de E/S do Windows armazena seus dados de estado compartilhado
(arquivos, eventos, mutexes, pipes). Por padrão, o Mono armazenará o diretório ".wapi"
no diretório inicial dos usuários.

MONO_SHARED_HOSTNAME
Usa o valor de string desta variável como um substituto para o nome do host quando
criando nomes de arquivos no diretório ".wapi". Isso ajuda se o nome do host do seu
é provável que a máquina seja alterada quando um aplicativo mono estiver em execução ou se você tiver um
Diretório .wapi compartilhado entre vários computadores diferentes. Mono normalmente usa o
hostname para criar os arquivos que são usados ​​para compartilhar o estado entre vários Mono
processos. Isto é feito para suportar diretórios pessoais que podem ser compartilhados pelo
rede.

MONO_STRICT_IO_EMULATION
Se definido, verificações extras serão feitas durante as operações de E/S. Atualmente, isso inclui apenas
bloqueios consultivos em torno de gravações de arquivos.

MONO_THEME
O nome do tema a ser usado pelo Windows.Forms. Os temas disponíveis hoje incluem
"clearlooks", "nice" e "win32". O padrão é “win32”.

MONO_TLS_SESSION_CACHE_TIMEOUT
O tempo, em segundos, que o cache da sessão SSL/TLS manterá sua entrada para evitar
uma nova negociação entre o cliente e um servidor. A negociação é muito CPU
intensivo, portanto, um valor personalizado específico do aplicativo pode ser útil para pequenos
sistemas embarcados. O padrão é 180 segundos.

MONO_THREADS_PER_CPU
O número mínimo de threads no threadpool geral será
MONO_THREADS_PER_CPU * número de CPUs. O valor padrão para esta variável é 1.

MONO_XMLSERIALIZER_THS
Controla o limite para o XmlSerializer produzir um serializador personalizado para um
dada classe em vez de usar o interpretador baseado em Reflexão. Os valores possíveis
são `não' para desabilitar o uso de um serializador personalizado ou um número para indicar quando o
XmlSerializer deve iniciar a serialização. O valor padrão é 50, o que significa que
o serializador personalizado será produzido no 50º uso.

MONO_X509_REVOCATION_MODE
Define o modo de revogação usado ao validar uma cadeia de certificados X509 (https,
ftps, smtps...). O padrão é 'nocheck', que não executa nenhuma verificação de revogação em
todos. Os outros valores possíveis são 'offline', que executa a verificação da CRL (não
implementado ainda) e 'online' que usa OCSP e CRL para verificar a revogação
status (ainda não implementado).

MEIO AMBIENTE VARIÁVEIS PARA DEPURAÇÃO

MONO_ASPNET_NODELETE
Se definido com qualquer valor, arquivos de origem temporários gerados por classes de suporte ASP.NET
não será removido. Eles serão mantidos no diretório temporário do usuário.

MONO_DEBUG
Se definido, habilita alguns recursos do tempo de execução úteis para depuração. Esta variável
deve conter uma lista separada por vírgulas de opções de depuração. Atualmente, o
as seguintes opções são suportadas:

interrupção não verificada
Se esta variável for definida, quando a VM Mono tiver um problema de verificação,
em vez de lançar uma exceção, ele invadirá o depurador. Isso é
útil ao depurar problemas do verificador

lança Esta opção pode ser usada para obter informações mais detalhadas do InvalidCast
exceções, fornecerá informações sobre os tipos envolvidos.

coletar estatísticas de pagefault
Coleta informações sobre pagefaults. Isso é usado internamente para rastrear
o número de falhas de página produzidas para carregar metadados. Para exibir isso
informações, você deve usar esta opção com a opção de linha de comando "--stats".

não-domínios gratuitos
Esta é uma otimização para aplicativos multi-AppDomain (mais comumente
aplicativos ASP.NET). Devido a limitações internas Mono, Mono por padrão
não usa alocações digitadas em aplicativos multi-appDomain, pois poderiam
vazar memória quando um domínio é descarregado. Embora este seja um bom padrão, por
aplicativos que usam muito mais do que AppDomain (por exemplo, ASP.NET
aplicações) vale a pena trocar os pequenos vazamentos pelo aumento
desempenho (além disso, já que os aplicativos ASP.NET provavelmente não serão
para descarregar os domínios da aplicação em sistemas de produção, vale a pena usar
este recurso).

dyn-runtime-invoke
Instrui o tempo de execução a tentar usar um wrapper genérico de invocação de tempo de execução
de criar um wrapper de invocação.

gdb Equivalente a definir o MONO_XDEBUG variável, isso emite símbolos em um
biblioteca compartilhada, pois o código é JITed e pode ser carregado no GDB para inspecionar
símbolos.

pontos gen-seq
Gera automaticamente pontos de sequência onde a pilha IL está vazia. Esses
são locais onde o depurador pode definir um ponto de interrupção.

verificações nulas explícitas
Faz o JIT gerar uma verificação NULL explícita nas desreferências de variáveis
em vez de depender do sistema operacional para levantar um SIGSEGV ou outro
forma de evento trap quando um local de memória inválido é acessado.

identificador-sigilo
Captura o sinal de interrupção (Control-C) e exibe um rastreamento de pilha quando
pressionado. Útil para descobrir onde o programa está sendo executado em um determinado
apontar. Isso exibe apenas o rastreamento de pilha de um único thread.

pilhas de inicialização
Instrui o tempo de execução para inicializar a pilha com alguns valores conhecidos (0x2a
em x86-64) no início de um método para auxiliar na depuração do mecanismo JIT.

manter-delegados
Esta opção vazará trampolins de delegados que não são mais referenciados como
para apresentar ao usuário mais informações sobre o uso indevido de um delegado.
Basicamente, uma instância delegada pode ser criada, passada para código não gerenciado,
e nenhuma referência mantida no código gerenciado, o que irá coletar o código como lixo.
Com esta opção é possível rastrear a origem dos problemas.

exceções de pinvoke reverso
Esta opção fará com que o mono seja abortado com uma mensagem descritiva quando durante
desenrolamento da pilha após uma exceção, ele atinge um quadro de pilha nativo. Esse
acontece quando um delegado gerenciado é passado para o código nativo, e o gerenciado
delegado lança uma exceção. Mono normalmente tentará desenrolar a pilha para
o primeiro manipulador de exceção (gerenciado) e ignorará qualquer pilha nativa
quadros no processo. Isso leva a um comportamento indefinido (já que mono não
saber como processar frames nativos), vazamentos e possivelmente travamentos também.

sem-gdb-backtrace
Esta opção desabilitará o backtrace GDB emitido pelo tempo de execução após um
SIGSEGV ou SIGABRT em código não gerenciado.

suspender em sigsegv
Esta opção suspenderá o programa quando um SIGSEGV nativo for recebido.
Isto é útil para depurar falhas que não acontecem no gdb, já que um
O processo live contém mais informações do que um arquivo principal.

verificar-pinvoke-callconv
Esta opção faz com que o tempo de execução verifique incompatibilidades de convenção de chamada
ao usar pinvoke, ou seja, misturar cdecl/stdcall. Só funciona no Windows. Se
uma incompatibilidade for detectada, uma ExecutionEngineException será lançada.

MONO_LOG_LEVEL
O nível de registro, os valores possíveis são `error', `critical', `warning', `message',
`info' e `depurar'. Veja a seção DEBUGGING para mais detalhes.

MONO_LOG_MASK
Controla o domínio do tempo de execução Mono ao qual o registro será aplicado. Se definido, o
a máscara de log é alterada para o valor definido. Os valores possíveis são "asm" (carregador de montagem),
"type", "dll" (carregador de biblioteca nativa), "gc" (coletor de lixo), "cfg" (arquivo de configuração
loader), "aot" (pré-compilador), "segurança" (por exemplo, suporte Moonlight CoreCLR) e
"todos". O valor padrão é "todos". Alterar o valor da máscara permite exibir
apenas mensagens para um determinado componente. Você pode usar várias máscaras por vírgula
separando-os. Por exemplo, para ver mensagens do arquivo de configuração e carregador de montagem
mensagens definem sua máscara para "asm, cfg".

MONO_TRACE
Usado para rastreamento em tempo de execução de chamadas de método. O formato do rastreamento separado por vírgula
as opções são:

[-]M:nome do método
[-]N:espaço para nome
[-]T:nome da classe
[-]todos
[-]programa
desativado Saída de rastreamento desativada na inicialização.

Você pode ativar/desativar a saída de rastreamento enviando um sinal SIGUSR2 para o programa.

MONO_TRACE_LISTENER
Se definido, habilita System.Diagnostics.DefaultTraceListener, que imprimirá o
saída das classes System.Diagnostics Trace e Debug. Pode ser definido para um
nome do arquivo e para Console.Out ou Console.Error para exibir a saída para a saída padrão
ou erro padrão, respectivamente. Se estiver definido como Console.Out ou Console.Error você
pode anexar um prefixo opcional que será usado ao escrever mensagens como esta:
Console.Error:MeuNomedoPrograma. Consulte o System.Diagnostics.DefaultTraceListener
documentação para obter mais informações.

MONO_WCF_TRACE
Isso facilita a funcionalidade de diagnóstico do WCF, simplesmente gerando todas as mensagens de log do
Mecanismo WCF para "stdout", "stderr" ou qualquer arquivo passado para esta variável de ambiente.
O formato do log é o mesmo da saída de diagnóstico normal.

MONO_XEXCEPTIONS
Isso lança uma exceção quando um erro X11 é encontrado; por padrão, uma mensagem é
exibido, mas a execução continua

MONO_XMLSERIALIZER_DEBUG
Defina este valor como 1 para evitar que o serializador remova os arquivos temporários
que são criados para serialização rápida; Isso pode ser útil durante a depuração.

MONO_XSYNC
Isso é usado na implementação System.Windows.Forms ao executar com o X11
Processo interno. Isso é usado para depurar problemas no Windows.Forms, pois força todos os
comandos enviados ao servidor X11 para serem feitos de forma síncrona. O modo padrão de
a operação é assíncrona, o que torna difícil isolar a raiz de certos
problemas.

MONO_GENERIC_SHARING
Esta variável de ambiente controla o tipo de compartilhamento genérico usado. Esta variável
é usado por desenvolvedores JIT internos e não deve ser alterado na produção. Não
use-o. A variável controla quais classes terão compartilhamento de código genérico
habilitado. Os valores permitidos são:

todos os Todo o código gerado pode ser compartilhado.

coleções
Somente as classes em System.Collections.Generic terão seu código compartilhado
(Este é o valor padrão).

corlib Somente o código em corlib terá seu código compartilhado.

Nenhum Nenhum compartilhamento de código genérico será realizado.
O compartilhamento de código genérico, por padrão, aplica-se apenas a coleções. O Mono JIT por padrão
ativa isso.

MONO_XDEBUG
Quando a variável env MONO_XDEBUG é definida, as informações de depuração para o código JITted são emitidas
em uma biblioteca compartilhada, carregável no gdb. Isto permite, por exemplo, ver
nomes de quadros em backtraces gdb.

MONO_VERBOSE_METHOD
Ativa o detalhamento máximo do JIT para o método especificado. Isso é muito útil
para diagnosticar problemas de compilação incorreta de um método específico.

MONO_VERBOSE_HWCAP
Se definido, faz com que o JIT produza informações sobre recursos detectados da CPU (como SSE,
CMOV, FCMOV, etc) para saída padrão.

MONO_CONSERVATIVE_HWCAP
Se definido, o JIT não executará nenhuma detecção de capacidade de hardware. Isto pode ser
útil para identificar a causa dos problemas JIT. Este é o padrão quando o Mono é construído
como um compilador cruzado AOT, para que o código gerado seja executado na maioria dos hardwares.

VALGRIND

Se você quiser usar Valgrind, você achará útil o arquivo `mono.supp', ele contém o
supressões para o GC que acionam avisos incorretos. Use assim:
valgrind --suppressions=mono.supp mono ...

DTRACE

Em algumas plataformas, o Mono pode expor um conjunto de testes do DTrace (também conhecido como user-land
definido estaticamente, sondas USDT).

Eles são definidos no arquivo `mono.d'.

ves-init-begin, ves-init-end
Início e fim da inicialização do tempo de execução.

método-compile-begin, fim da compilação do método
Início e fim da compilação do método. Os argumentos do teste são nome da classe, método
nome e assinatura, e em caso de sucesso ou falha no final da compilação do método
compilação.

gc-início, final do gc
Início e fim da coleta de lixo.

Para verificar a disponibilidade dos probes, execute:
dtrace -P mono'$alvo' -l -c mono

PERMISSÕES

A implementação do Ping do Mono para detectar a acessibilidade da rede pode criar os pacotes ICMP
sozinho sem exigir que o comando ping do sistema faça o trabalho. Se você deseja ativar
isso no Linux para usuários não root, você precisa conceder permissões especiais ao binário Mono.

Como root, execute este comando:
# setcap cap_net_raw=+ep /usr/bin/mono

Use mono online usando serviços onworks.net