mono: online nel cloud

PROGRAMMA:

NOME

mono - Generatore di codice nativo ECMA-CLI di Mono (Just-in-Time e Ahead-of-Time)

SINOSSI

mono [opzioni] filetto [argomenti...]

mono-sgen [opzioni] filetto [argomenti...]

DESCRIZIONE

mono è un'implementazione runtime dell'ECMA Common Language Infrastructure. Questo può essere
utilizzato per eseguire applicazioni ECMA e .NET.

Il runtime contiene un generatore di codice nativo che trasforma il Common Intermediate
Lingua in codice nativo.

Il generatore di codice può funzionare in due modalità: compilazione just in time (JIT) o prima di
compilazione del tempo (AOT). Poiché il codice può essere caricato dinamicamente, l'ambiente di runtime e
i JIT sono sempre presenti, anche se il codice viene compilato in anticipo.

Il runtime carica lo specificato filetto e facoltativamente passa il argomenti ad esso. Il filetto
è un assieme ECMA. In genere hanno un'estensione .exe o .dll.

Il runtime fornisce una serie di opzioni di configurazione per l'esecuzione di applicazioni, per
sviluppo e debug e per il test e il debug del runtime stesso.

Le mono comando utilizza il Garbage Collector conservativo Boehm mentre il comando mono-sgen command
utilizza un netturbino commovente e generazionale.

PORTABILITÀ

Sui sistemi basati su Unix, Mono fornisce un meccanismo per emulare l'accesso ai file in stile Windows,
ciò include fornire una vista senza distinzione tra maiuscole e minuscole del file system, separatore di directory
mappatura (da \ a /) e rimuovere le lettere di unità.

Questa funzionalità è abilitata impostando il MONO_IOMAP variabile d'ambiente a uno di
Tutti, guidare che a Astuccio.

Vedere la descrizione per MONO_IOMAP nella sezione delle variabili di ambiente per maggiori dettagli.

DURATA VERSIONI

Sono disponibili le seguenti opzioni:

--aota, --aot[=opzioni]
Questa opzione viene utilizzata per precompilare il codice CIL nell'assembly specificato in nativo
codice. Il codice generato viene memorizzato in un file con estensione .so. Questa vita
verrà automaticamente prelevato dal runtime quando viene eseguito l'assieme.
La compilazione anticipata è molto utile se la usi in combinazione con il
-O=all,-shared flag che abilita tutte le ottimizzazioni nel generatore di codice a
essere eseguita. Alcune di queste ottimizzazioni non sono pratiche per il Just-in-Time
compilazione poiché potrebbero richiedere molto tempo. A differenza di .NET Framework,
La compilazione anticipata non genererà codice indipendente dal dominio: genera
lo stesso codice che produrrebbe il compilatore Just-in-Time. Dal momento che la maggior parte
le applicazioni utilizzano un singolo dominio, questo va bene. Se vuoi ottimizzare il
codice generato per l'utilizzo in applicazioni multidominio, considerare l'utilizzo di -O=shared
bandiera. Questo precompila i metodi, ma è ancora necessario l'assembly originale
eseguire poiché questo contiene i metadati e le informazioni sull'eccezione che non lo sono
disponibile sul file generato. Durante la precompilazione del codice, potresti voler compilare
con tutte le ottimizzazioni (-O=all). Il codice precompilato è un codice indipendente dalla posizione.
La pre-compilazione è solo un meccanismo per ridurre i tempi di avvio, aumentare la condivisione del codice
su più processi mono ed evita l'avvio del programma di compilazione just-in-time
costi. L'assembly originale deve essere ancora presente, poiché i metadati sono contenuti
là. Il codice AOT in genere non può essere spostato da un computer a un altro (CPU-
ottimizzazioni specifiche che vengono rilevate in fase di esecuzione) quindi non dovresti provare a spostarti
gli assemblaggi pregenerati o imballare gli assemblaggi pregenerati per
distribuzione. Alcune opzioni sono disponibili come parametro per il --aota riga di comando
opzione. Le opzioni sono separate da virgole ed è possibile specificarne più di una:

autorig
Il compilatore AOT emetterà automaticamente un inizializzatore di libreria (solo ELF)
registrare il modulo compilato aot con il runtime. Questo è utile solo in
modalità statica

assolo
Indica al compilatore AOT di emettere il codice assembly invece di un oggetto
file.

bind-to-runtime-versione
Se specificato, forza il collegamento dei file AOT generati al runtime
versione della compilazione Mono. Ciò impedirà ai file AOT di essere
consumato da un diverso runtime Mono. pieno Questo è attualmente un
caratteristica sperimentale in quanto non completa. Questo istruisce Mono a
precompilare il codice che storicamente non è stato precompilato con AOT.

richiamo diretto
Quando questa opzione è specificata, i metodi P/Invoke vengono invece invocati direttamente
di passare attraverso l'operazione di ricerca dei simboli del sistema operativo.

percorso-llvm=
Lo stesso per gli strumenti llvm 'opt' e 'llc'.

mtripla=
Usa la tripla destinazione in stile GNU per determinare una generazione di codice
opzioni, ad esempio --mtriple=armv7-linux-gnueabi genererà codice mirato
ARMv7. Questo è attualmente supportato solo dal backend ARM. In modalità LLVM,
questa tripla viene passata al compilatore LLVM llc.

nimt-trampolini=[numero]
Quando si compila in modalità full aot, i trampolini IMT devono essere precreati in
l'immagine AOT. Puoi aggiungere ulteriori trampolini di metodo con questo
discussione. Il valore predefinito è 128.

bug dei nodi
Indica al compilatore AOT di non emettere alcuna informazione di debug.

no-chiamate-dirette
Ciò impedisce al compilatore AOT di generare chiamate dirette a un metodo.
Il compilatore AOT di solito genera chiamate dirette per determinati metodi che lo fanno
non richiedono di passare attraverso il PLT (ad esempio, metodi noti per
non richiede un hook come un costruttore statico) o chiama in un semplice internal
chiamate.

nanodebug
Indica al compilatore AOT di emettere informazioni di debug DWARF. Quando usato
insieme all'opzione nodebug, solo le informazioni di debug DWARF sono
emesse, ma non le informazioni che possono essere utilizzate in fase di esecuzione.

nrgctx-trampolini=[numero]
Quando si compila in modalità full aot, i trampolini di condivisione generici devono essere
precreato nell'immagine AOT. È possibile aggiungere ulteriori trampolini di metodo con
questo argomento. Il valore predefinito è 1024.

ntrampolini=[numero]
Quando si compila in modalità full aot, il metodo trampolini deve essere precreato
nell'immagine AOT. Puoi aggiungere ulteriori trampolini di metodo con questo
discussione. Il valore predefinito è 1024.

outfile=[nomefile]
Indica al compilatore AOT di salvare l'output nel file specificato.

metodi-saltati di stampa
Se il compilatore AOT non può compilare un metodo per qualsiasi motivo, abilitarlo
flag restituirà alla console i metodi ignorati.

readonly-value=spazio dei nomi.typename.fieldname=tipo/valore
Sostituisci il valore di un campo di sola lettura statico. Di solito, durante JIT
compilazione, il costruttore statico viene eseguito avidamente, quindi il valore di uno statico
il campo readonly è noto al momento della compilazione e il compilatore può fare un numero
di ottimizzazioni basate su di esso. Durante AOT, invece, il costruttore statico
non può essere eseguito, quindi questa opzione può essere utilizzata per impostare il valore di un tale campo
e abilitare lo stesso set di ottimizzazioni. Il tipo può essere uno qualsiasi tra i1, i2, i4 per
numeri interi delle rispettive dimensioni (in byte). Nota che firmato/non firmato
i numeri non contano qui, solo la dimensione dello spazio di archiviazione. Questa opzione può essere
specificato più volte e non impedisce il costruttore statico per
il tipo che definisce il campo da eseguire con le solite regole a runtime
(quindi eventualmente calcolando un valore diverso per il campo).

salva-temps, mantieni-temps
Indica al compilatore AOT di conservare i file temporanei.

debug soft
Questo istruisce il compilatore a generare controlli del punto di sequenza che consentono
Il soft debugger di Mono per eseguire il debug delle applicazioni anche su sistemi in cui non lo è
possibile impostare punti di interruzione o a passo singolo (alcuni hardware
configurazioni come i telefoni cellulari e le console per videogiochi).

statico Crea un file oggetto ELF (.o) o un file .s che può essere collegato staticamente
in un eseguibile quando si incorpora il runtime mono. Quando questa opzione è
utilizzato, il file oggetto deve essere registrato con il runtime incorporato utilizzando
la funzione mono_aot_register_module che prende come argomento il
mono_aot_module_ _info simbolo globale dal file oggetto:

vuoto esterno *mono_aot_module_hello_info;

mono_aot_register_module (mono_aot_module_hello_info);

stats Stampa varie statistiche raccolte durante la compilazione AOT.

thread=[numero]
Questa è un'opzione sperimentale per il compilatore AOT per utilizzare più thread
durante la compilazione dei metodi.

tool-prefix=
antepone al nome degli strumenti eseguiti dal compilatore AOT, ad es
'come'/'ld'. Ad esempio, --tool=prefix=arm-linux-gnueabi- farà l'AOT
esecuzione del compilatore

scrivere-simboli
Indica al compilatore AOT di emettere informazioni sui simboli di debug.

Per ulteriori informazioni sull'AOT, vedere: http://www.mono-project.com/docs/advanced/aot/

--attach=[opzioni]
Attualmente l'unica opzione supportata da questo argomento della riga di comando è disable quale
disabilita la funzionalità di collegamento.

--config Nome del file
Carica il file di configurazione specificato invece di quello predefinito. Il predefinito
i file sono /etc/mono/config e ~/.mono/config o il file specificato nel
MONO_CONFIG variabile di ambiente, se impostata. Vedi il configurazione mono(5) pagina man per
dettagli sul formato di questo file.

--debugger-agent=[opzioni]
Questo indica al runtime Mono di avviare un agente di debug all'interno del runtime Mono
e collegarlo a un'interfaccia utente client controllerà il processo Mono. Questo
viene in genere utilizzata dagli IDE, come l'IDE MonoDevelop.

La configurazione viene specificata utilizzando una o più delle seguenti opzioni:

indirizzo=host:porta
Usa questa opzione per specificare l'indirizzo IP in cui si trova il tuo client debugger
ascoltare.

loglevel=LIVELLO
Specifica il livello del registro di diagnostica per

logfile=nomefile
Utilizzato per specificare il file in cui verrà archiviato il registro, il valore predefinito è
uscita standard.

server=[s/n]
Il valore predefinito è no, con l'opzione predefinita Mono si connetterà attivamente al
host/porta configurato con il indirizzo opzione. Se lo imposti su 'y', è
indica al runtime Mono di avviare il debug in modalità server, dove Mono
attende attivamente che il front-end del debugger si connetta al processo Mono.
Mono stamperà per memorizzare l'indirizzo IP e la porta su cui è in ascolto.

setpgid=[s/n]
Se impostato su sì, Mono chiamerà setpgid(0, 0) on avvio, if che funzione is
disponibile on , il . Si is utile per assicurando che Segnali consegnato
a a processi che is esecuzione , il debugger sono non è un propagato a , il
debugger, per esempio quando Ctrl-Do invia SIGINT a , il sdb strumento.

sospendere=[s/n]
Il valore predefinito è sì, con l'opzione predefinita Mono sospenderà la VM all'avvio
fino a quando non si connette correttamente a un front-end del debugger. Se lo imposti su
'n', in combinazione con server=y, indica al runtime Mono di essere eseguito come
normale, durante la memorizzazione nella cache dei metadati da inviare al front-end del debugger
connessione..

trasporto=nome_trasporto
Questo è usato per specificare il trasporto che il debugger userà per
comunicare. Deve essere specificato e attualmente richiede che questo sia
'dt_socket'.

--desktop
Configura la macchina virtuale in modo che sia più adatta per le applicazioni desktop.
Attualmente questo imposta il sistema GC per evitare di espandere il più possibile l'heap
a scapito di rallentare un po' la raccolta dei rifiuti.

--full-aot
Questo è un flag sperimentale che indica al runtime Mono di non generarne nessuno
codice in fase di esecuzione e dipendono esclusivamente dal codice generato dall'utilizzo di mono
--aot=pieno in precedenza. Questo è utile per le piattaforme che non consentono la dinamica
generazione del codice. Nota che questa funzione interromperà l'esecuzione in fase di esecuzione se a
codepath nel tuo programma o le librerie di classi di Mono tentano di generare codice
dinamicamente. Dovresti testare il tuo software in anticipo e assicurarti di non farlo
utilizzare qualsiasi caratteristica dinamica.

--gc=bohm, --gc=sgen
Seleziona il motore Garbage Collector per l'uso di Mono, Boehm o SGen. Attualmente
questo assicura semplicemente che tu stia eseguendo il mono or mono-sgen comandi.
Questo flag può essere impostato nel MONO_ENV_OPZIONI variabile d'ambiente per forzare tutto
tuo figlio elabora per utilizzare un particolare tipo di GC con il runtime Mono.

--Aiuto, -h
Visualizza le istruzioni per l'uso.

--llvm Se il runtime Mono è stato compilato con il supporto LLVM (non disponibile in tutti
configurazioni), Mono utilizzerà l'ottimizzazione LLVM e il motore di generazione del codice per
Compilazione JIT o AOT. Per maggiori informazioni consultare: http://www.mono-
project.com/docs/advanced/mono-llvm/

--nollvm
Quando si utilizza un Mono che è stato compilato con il supporto LLVM, costringe Mono a
fallback al suo motore JIT e non usa il backend LLVM.

--optimize=MODALITÀ, -O=MODALITÀ
MODE è un elenco separato da virgole di ottimizzazioni. Consentono inoltre le ottimizzazioni per
essere disattivato anteponendo al nome dell'ottimizzazione un segno meno. Generalmente,
Mono è stato messo a punto per utilizzare il set predefinito di flag, prima di utilizzare questi flag per a
impostazione di distribuzione, potresti voler misurare effettivamente i vantaggi del loro utilizzo.
I seguenti flag di ottimizzazione sono implementati nel motore principale:
abcrem Rimozione dei controlli associati all'array
all Attiva tutte le ottimizzazioni
aot Utilizzo del codice compilato in anticipo
filiale Ottimizzazioni filiale
cfold Piegatura costante
cmov Mosse condizionali [dipendenza dall'arco]
deadce Eliminazione del codice morto
consprop Propagazione costante
copyprop Propagazione della copia
fcmov Fast x86 FP confronta [dipendenza dall'arco]
float32 Eseguire l'aritmetica float a 32 bit utilizzando operazioni a 32 bit
gshared Abilita la condivisione del codice generico.
inline Chiamate al metodo in linea
intrins Implementazioni del metodo intrinseco
linears Allocazione reg globale scansione lineare
foglia Ottimizzazioni procedure foglia
loop Ottimizzazioni relative al loop
spioncino Spioncino postpass
precomp Precompila tutti i metodi prima di eseguire Main
sched Programmazione delle istruzioni
condiviso Emetti codice per dominio
sse2 Istruzioni SSE2 su x86 [dipendenza dall'architettura]
tailc Ricorsione di coda e richiami di coda
Ad esempio, per abilitare tutta l'ottimizzazione tranne l'eliminazione del codice morto e l'inlining,
Puoi usare:
-O=tutto,-morto,-in linea
I flag che sono contrassegnati con [arch-dependency] indicano che l'opzione data if
utilizzato in combinazione con la compilazione Ahead of Time (--aot flag) produrrebbe pre-
codice compilato che dipenderà dalla CPU corrente e potrebbe non essere spostato in sicurezza in
un altro computer.

Sono supportate le seguenti ottimizzazioni

float32
Richiede che il runtime esegua operazioni in virgola mobile a 32 bit utilizzando
solo 32 bit. Per impostazione predefinita, il runtime Mono cerca di utilizzare il più alto
precisione disponibile per le operazioni in virgola mobile, ma mentre questo potrebbe
ottenere risultati migliori, il codice potrebbe essere eseguito più lentamente. Anche questa opzione
influisce sul codice generato dal backend LLVM.

inline Controlla se il runtime deve tentare di eseguire l'inline (impostazione predefinita) o meno
invocazioni di metodi in linea

--runtime=VERSIONE
Mono supporta diverse versioni di runtime. La versione utilizzata dipende dal programma
che è in esecuzione o sul suo file di configurazione (denominato program.exe.config). Questo
l'opzione può essere utilizzata per ignorare tale rilevamento automatico, forzando un runtime diverso
versione da utilizzare. Nota che questo dovrebbe essere usato solo per selezionare un compatibile successivo
versione runtime rispetto a quella con cui è stato compilato il programma. Un uso tipico è
per eseguire un programma 1.1 su una versione 2.0:
mono --runtime=v2.0.50727 programma.exe

--sicurezza, --security=modalità
Attiva il gestore della sicurezza, una funzionalità attualmente sperimentale in Mono ed è
SPENTO per impostazione predefinita. Anche il nuovo verificatore di codice può essere abilitato con questa opzione.

Usare la sicurezza senza parametri equivale a chiamarla con il "cas"
parametro.

Sono supportate le seguenti modalità:

core-clr
Abilita il sistema di sicurezza core-clr, generalmente utilizzato per
Applicazioni Moonlight/Silverlight. Fornisce una sicurezza molto più semplice
sistema rispetto a CAS, vedere http://www.mono-project.com/docs/web/moonlight/ per
maggiori dettagli e link alle descrizioni di questo nuovo sistema.

valido
Abilita il nuovo verificatore ed esegue la verifica di base per la validità del codice.
In questa modalità sono consentiti codice non sicuro e P/Invoke. Questa modalità fornisce un
migliore garanzia di sicurezza ma è ancora possibile che il codice gestito vada in crash
Mono.

verificabile
Abilita il nuovo verificatore ed esegue la verifica completa del codice in corso
eseguito. Consente solo l'esecuzione di codice verificabile. Il codice non sicuro è
non consentito ma P/Invoke lo è. Questa modalità non dovrebbe consentire al codice gestito di
crash mono. La verifica non è così rigorosa come lo standard ECMA 335 in ordine
per rimanere compatibile con il runtime MS.

Il sistema di sicurezza agisce sul codice utente: codice contenuto in mscorlib o nel global
la cache di assemblaggio è sempre attendibile.

--server
Configura la macchina virtuale per essere più adatta alle operazioni del server
(attualmente, consente un'inizializzazione del pool di thread più pesante).

--verifica-tutto
Verifica mscorlib e assembly nella global assembly cache per IL valido e tutto
codice utente per verificabilità IL.

Questo è diverso da --sicurezzaè verificabile o valida in quanto queste opzioni
controlla solo il codice utente e salta mscorlib e gli assembly situati nel global
cache di montaggio.

-V, --versione
Stampa le informazioni sulla versione JIT (configurazione del sistema, numero di versione e ramo
nomi se disponibili).

SVILUPPO VERSIONI

Le seguenti opzioni vengono utilizzate per aiutare durante lo sviluppo di un'applicazione JIT.

- debug, --debug=OPZIONI
Attiva la modalità di debug in runtime. Se un assembly è stato compilato con
informazioni di debug, produrrà informazioni sul numero di riga per le tracce dello stack.

L'argomento OPTIONS facoltativo è un elenco separato da virgole di opzioni di debug.
Queste opzioni sono disattivate per impostazione predefinita poiché generano molto più grandi e più lente
codice in fase di esecuzione.

Sono supportate le seguenti opzioni:

calchi Produce un errore dettagliato durante la generazione di un'InvalidCastException. Questo
l'opzione deve essere abilitata in quanto genera codice più dettagliato durante l'esecuzione
tempo.

ottimizzazioni mdb
Disabilita alcune ottimizzazioni JIT che di solito sono disabilitate solo durante l'esecuzione
all'interno del debugger. Questo può essere utile se vuoi allegare al
processo in esecuzione con mdb.

gdb Genera e registra le informazioni di debug con gdb. Questo è supportato solo
su alcune piattaforme e solo quando si utilizza gdb 7.0 o successivo.

--profile[=profiler[:profiler_args]]
Attiva la profilazione. Per maggiori informazioni sulle applicazioni e sul codice di profilazione
copertura vedere le sezioni "PROFILATURA" e "COPERTURA CODICE" di seguito.

Questa opzione può essere utilizzata più volte, ogni volta caricherà un
profilatore aggiuntivo. Ciò consente agli sviluppatori di utilizzare moduli che estendono il JIT
attraverso l'interfaccia di profilazione Mono.

--trace[=espressione]
Mostra i nomi dei metodi quando vengono invocati. Per impostazione predefinita, vengono tracciati tutti i metodi. Il
trace può essere personalizzato per includere o escludere metodi, classi o assembly. UN
l'espressione di traccia è un elenco di obiettivi separati da virgole, ogni obiettivo può essere preceduto da un prefisso
con un segno meno per disattivare un particolare obiettivo. Le parole "programma", "tutto" e
"disabile" ha un significato speciale. "programma" si riferisce al programma principale in corso
eseguito, e "all" indica tutte le chiamate al metodo. L'opzione "disabilitato" è usata per
avvia con la traccia disabilitata. Può essere abilitato in un secondo momento nel
programma inviando il segnale SIGUSR2 al runtime. Gli assemblaggi sono specificati da
il loro nome, ad esempio, per tracciare tutte le chiamate nell'assembly di sistema, utilizzare:

mono --trace=App di sistema.exe

Le classi sono specificate con il prefisso T:. Ad esempio, per tracciare tutte le chiamate al
Classe System.String, utilizzare:

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

E i singoli metodi sono referenziati con il prefisso M: e il metodo standard
notazione:

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

Le eccezioni possono anche essere tracciate, causerà la stampa di una traccia dello stack ogni volta
viene generata un'eccezione del tipo specificato. È possibile specificare il tipo di eccezione
con o senza lo spazio dei nomi e per tracciare tutte le eccezioni, specificare 'all' come
digitare il nome.

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

Come notato in precedenza, è possibile specificare diverse regole contemporaneamente:

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

Puoi escludere pezzi, il prossimo esempio traccia le chiamate a System.String tranne che per
il metodo System.String:Concat.

mono --trace=T:Stringa.Sistema,-M:Stringa.Sistema:Concat

Puoi tracciare le transizioni gestite e non gestite utilizzando il qualificatore wrapper:

mono --trace=wrapper app.exe

Infine, gli spazi dei nomi possono essere specificati utilizzando il prefisso N::

mono --trace=N:System.Xml

--no-x86-stack-align
Non allineare gli stack frame sull'architettura x86. Per impostazione predefinita, Mono allinea lo stack
frame a 16 byte su x86, in modo che le variabili locali in virgola mobile e SIMD possano essere
correttamente allineato. Questa opzione disattiva l'allineamento, che di solito ne salva uno
istruzioni per chiamata, ma potrebbe comportare una virgola mobile significativamente più bassa e
Prestazioni SIMD.

--jitmap
Genera una mappa del metodo JIT in un file /tmp/perf-PID.map. Questo file viene quindi utilizzato, per
esempio, dallo strumento perf incluso nei recenti kernel Linux. Ogni riga nel file
ha:

HEXADDR HEXSIZE nome metodo

Attualmente questa opzione è supportata solo su Linux.

JIT MANUTENTORE VERSIONI

Le opzioni del manutentore sono utilizzate solo da coloro che sviluppano il runtime stesso e non
tipicamente di interesse per gli utenti runtime o gli sviluppatori.

--rottura metodo
Inserisce un punto di interruzione prima del metodo il cui nome è "metodo"
(namespace.class:methodname). Usa "Main" come nome del metodo su cui inserire un punto di interruzione
il metodo principale dell'applicazione. Puoi usarlo anche con i generici, per esempio
"System.Collections.Generic.Queue`1:Peek"

--breakonex
Inserisce un punto di interruzione sulle eccezioni. Ciò ti consente di eseguire il debug della tua applicazione con
un debugger nativo quando viene generata un'eccezione.

--compilare Nome
Questo compila un metodo (namespace.name:methodname), questo è usato per testare il
prestazioni del compilatore o per esaminare l'output del generatore di codice.

--compila tutto
Compila tutti i metodi in un assembly. Questo è usato per testare il compilatore
prestazioni o per esaminare l'output del generatore di codice

--graph=TIPO METODO
Questo genera un file postscript con un grafico con i dettagli su quanto specificato
metodo (namespace.name:methodname). Ciò richiede "punto" e ghostview per essere
installato (si aspetta che Ghostview si chiami "gv"). I seguenti grafici sono
disponibile:
cfg Grafico del flusso di controllo (CFG)
dtree Albero dominatore
codice CFG che mostra il codice
ssa CFG che mostra il codice dopo la traduzione SSA
optcode CFG che mostra il codice dopo le ottimizzazioni IR
Alcuni grafici saranno disponibili solo se sono attivate determinate ottimizzazioni.

--ncompile
Istruire il runtime sul numero di volte in cui il metodo specificato da --compile
(o tutti i metodi se si usa --compileall) da compilare. Questo è usato per
testare le prestazioni del generatore di codice.

--statistiche
Visualizza le informazioni sul lavoro svolto dal runtime durante l'esecuzione di an
applicazione.

--wapi=hps|semdel
Eseguire la manutenzione dei dati condivisi di processo. semdel eliminerà il globale
semaforo. hps elencherà gli handle attualmente utilizzati.

-v, --verboso
Aumenta il livello di verbosità, ogni volta che viene elencato, aumenta la verbosità
livello per includere più informazioni (compreso, ad esempio, uno smontaggio del
codice nativo prodotto, informazioni sul selettore di codice, ecc.).

ALLEGARE SUPPORTO

Il runtime Mono consente ai processi esterni di collegarsi a un processo in esecuzione e caricare
assemblee nel programma in esecuzione. Per allegare al processo, un protocollo speciale è
implementato nell'assembly Mono.Management.

Con questo supporto è possibile caricare assiemi che hanno un punto di ingresso (sono
creato con -target:exe o -target:winexe) per essere caricato ed eseguito nel processo Mono.

Il codice viene caricato nel dominio principale e avvia l'esecuzione nel runtime speciale
allegare il filo. Il programma allegato dovrebbe creare i propri thread e tornare dopo
invocazione.

Questo supporto consente ad esempio di eseguire il debug delle applicazioni collegando la shell csharp
ai processi in esecuzione.

PROFILAZIONE

Il runtime mono include un profiler che può essere utilizzato per esplorare varie prestazioni
problemi correlati nella tua applicazione. Il profiler viene attivato passando il --profile
argomento della riga di comando per il runtime Mono, il formato è:

--profile[=profiler[:profiler_args]]

Mono ha un profiler integrato chiamato 'predefinito' (ed è anche l'impostazione predefinita se non ci sono argomenti
specificato), ma gli sviluppatori possono scrivere profili personalizzati, vedere la sezione "PROFILI PERSONALIZZATI"
per ulteriori dettagli.

Se un profiler non è specificato, viene utilizzato il profiler predefinito. Il profiler_args è un
stringa di opzioni specifica del profiler per il profiler stesso. Il profiler predefinito accetta
le seguenti opzioni 'alloc' per profilare il consumo di memoria da parte dell'applicazione; 'tempo di
profilare il tempo speso per ogni routine; 'jit' per raccogliere il tempo impiegato nei metodi di compilazione JIT
e 'stat' per eseguire la profilazione statistica del campione. Se non vengono fornite opzioni, il
l'impostazione predefinita è 'alloc,time,jit'.

Per impostazione predefinita i dati del profilo vengono stampati su stdout: per modificarlo, utilizzare 'file=filename'
opzione per inviare i dati a filename. Per esempio:

mono --profile programma.exe

Questo eseguirà il programma con il profiler predefinito e farà tempo e allocazione
profilazione.

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

Farà un esempio di profilazione statistica e di allocazione su program.exe. Il profilo
i dati vengono inseriti in prof.out. Si noti che il profiler statistico ha un sovraccarico molto basso e
dovrebbe essere il profiler preferito da usare (per un output migliore usa il percorso completo per il mono
binario durante l'esecuzione e assicurati di aver installato l'utility addr2line che proviene da
il pacchetto binutils).

LOG PROFILATORE

Questo è il profiler più avanzato.

Il Mono ceppo profiler può essere utilizzato per raccogliere molte informazioni su un programma in esecuzione
nel runtime Mono. Questi dati possono essere utilizzati (sia mentre il processo è in esecuzione che in seguito)
per eseguire analisi del comportamento del programma, determinare l'utilizzo delle risorse, problemi di prestazioni o
anche cercare particolari schemi di esecuzione.

Ciò si ottiene registrando gli eventi forniti dal runtime Mono tramite il
interfaccia di profilazione e scriverli periodicamente in un file che può essere successivamente ispezionato
con la mprof-relazione(1) strumento.

Maggiori informazioni su come utilizzare il log profiler sono disponibili sul mprof-relazione(1)
.

CUSTOM PROFILATORI

Mono fornisce un meccanismo per caricare altri moduli di profilazione che sotto forma di condivisi
biblioteche. Questi moduli di profilatura possono collegarsi a varie parti del runtime Mono per
raccogliere informazioni sul codice in esecuzione.

Per utilizzare un profiler di terze parti devi passare il nome del profiler a Mono, in questo modo:

mono --profile=programma personalizzato.exe

Nell'esempio sopra, Mono caricherà il profiler definito dall'utente dalla libreria condivisa
`mono-profiler-custom.so'. Questo modulo profiler deve trovarsi nella libreria del linker dinamico
sentiero.

Un elenco di altri profilatori di terze parti è disponibile sul sito Web di Mono (www.mono-
project.com/docs/advanced/performance-tips/)

I profili personalizzati vengono scritti come librerie condivise. La libreria condivisa deve essere chiamata `mono-
profiler-NAME.so' dove "NAME" è il nome del tuo profiler.

Per un esempio di come scrivere il tuo profiler personalizzato, guarda nell'albero dei sorgenti Mono per in
i campioni/profilatore.c.

CODICE COPERTURA

Mono viene fornito con un modulo di copertura del codice. Questo modulo si attiva utilizzando il Mono
--profile=opzione cov. Il formato è: --profile=cov[:nome-assieme[/spazio dei nomi]] test-
suite.exe

Per impostazione predefinita, la copertura del codice verrà impostata su tutti gli assembly caricati, è possibile limitarla con
specificando il nome dell'assembly, ad esempio per eseguire la copertura del codice nelle routine del tuo
uso del programma, ad esempio la seguente riga di comando limita la copertura del codice alle routine
nell'assemblea "demo":

mono --profile=cov:demo demo.exe

Si noti che il nome-assemblea non include l'estensione.

È possibile limitare ulteriormente l'output della copertura del codice specificando uno spazio dei nomi:

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

Che eseguirà solo la copertura del codice nell'assembly e nello spazio dei nomi specificati.

L'output tipico è simile a questo:

Non coperto: Classe:.ctor ()
Non coperto: Classe:A ()
Non coperto: Driver:.ctor ()
Non coperto: Driver:metodo ()
Copertura parziale: Driver:Principale ()
offset 0x000a

Gli offset visualizzati sono offset IL.

Uno strumento di copertura più potente è disponibile nel modulo `monocov'. Vedi il monocova(1)
pagina man per i dettagli.

DEBUG AIDS

Per eseguire il debug delle applicazioni gestite, puoi utilizzare il MDB comando, un debugger da riga di comando.

È possibile ottenere una traccia dello stack di tutti i thread attivi in ​​Mono inviando il
QUIT segnale a Mono, puoi farlo dalla riga di comando, in questo modo:

kill -QUIT pid

Dove pid è l'ID processo del processo Mono che si desidera esaminare. Il processo sarà
continuare l'esecuzione in seguito, ma il suo stato non è garantito.

Importante: questo è un meccanismo di ultima istanza per il debug delle applicazioni e non dovrebbe essere
utilizzato per monitorare o sondare un'applicazione di produzione. L'integrità del runtime dopo
l'invio di questo segnale non è garantito e l'applicazione potrebbe bloccarsi o terminare in qualsiasi momento
dato punto dopo.

Le --debug=cast l'opzione può essere utilizzata per ottenere informazioni più dettagliate per Cast non valido
operazioni, fornirà informazioni sui tipi coinvolti.

Puoi usare le variabili di ambiente MONO_LOG_LEVEL e MONO_LOG_MASK per ottenere dettagli
output di debug sull'esecuzione dell'applicazione all'interno di Mono.

Le MONO_LOG_LIVELLO variabile d'ambiente se impostata, il livello di registrazione viene modificato in set
valore. I valori possibili sono "error", "critical", "warning", "message", "info", "debug". Il
il valore predefinito è "errore". Messaggi con un livello di registrazione maggiore o uguale al registro
livello verrà stampato su stdout/stderr.

Utilizzare "info" per tenere traccia del caricamento dinamico degli assiemi.

Usa il MONO_LOG_MASK variabile d'ambiente per limitare l'estensione dei messaggi che ricevi: If
set, la maschera del registro viene modificata al valore impostato. I valori possibili sono "asm" (assembly
loader), "type", "dll" (loader libreria nativa), "gc" (garbage collector), "cfg" (config
caricatore di file), "aot" (precompilatore), "security" (ad es. supporto Moonlight CoreCLR) e "all".
Il valore predefinito è "tutto". La modifica del valore della maschera consente di visualizzare solo i messaggi
per un determinato componente. Puoi utilizzare più maschere separandole con una virgola. Per esempio
per vedere i messaggi del file di configurazione e i messaggi del caricatore di assembly impostare la maschera su "asm,cfg".

Quanto segue è un uso comune per rintracciare i problemi con P/Invoke:

$ MONO_LOG_LEVEL="debug" MONO_LOG_MASK="dll" mono glue.exe

DEBUG CON LDB

Se stai usando LLDB, puoi usare il mono.py script per stampare alcuni dati interni
strutture con esso. Per usarlo, aggiungilo al tuo $HOME/.lldbinit file:
script di comando import $PREFIX/lib/mono/lldb/mono.py

Dove $PREFIXèil valore del prefisso che hai usato quando hai configurato Mono (in genere / usr).

Fatto ciò, puoi ispezionare alcune strutture dati Mono Runtime, ad esempio:
(lldb) metodo p

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

SERIALIZZAZIONE

Il motore di serializzazione XML di Mono per impostazione predefinita utilizzerà un approccio basato sulla riflessione per
serializzare che potrebbe essere lento per l'elaborazione continua (applicazioni di servizi Web). Il
Il motore di serializzazione determinerà quando una classe deve utilizzare un serializzatore messo a punto manualmente basato su
alcuni parametri e, se necessario, produrrà un serializzatore C# personalizzato per i tuoi tipi
in fase di esecuzione. Questo serializzatore personalizzato viene quindi caricato dinamicamente nel tuo
applicazione.

Puoi controllarlo con la variabile di ambiente MONO_XMLSERIALIZER_THS.

I valori possibili sono "no" per disabilitare l'uso di un serializzatore personalizzato C# o
intero che è il numero minimo di utilizzi prima che il runtime produca un custom
serializer (0 produrrà un serializzatore personalizzato al primo accesso, 50 produrrà a
serializzatore al 50° utilizzo). Mono eseguirà il fallback su un serializzatore interpretato se il
la generazione del serializzatore in qualche modo fallisce. Questo comportamento può essere disabilitato impostando l'opzione
"senza fallback" (ad esempio: MONO_XMLSERIALIZER_THS=0,nofallback).

AMBIENTE VARIABILI

GC_DONT_GC
Disattiva la raccolta dei rifiuti in Mono. Questo dovrebbe essere usato solo per il debug
fini

LVM_COUNT
Quando Mono è compilato con il supporto LLVM, questo indica al runtime di smettere di usare
LLVM dopo che il numero specificato di metodi è stato sottoposto a JIT. Questo è uno strumento utilizzato in
diagnostica per isolare i problemi nel backend di generazione del codice. Per esempio
LLVM_COUNT=10 compilerebbe solo 10 metodi con LLVM e poi passerebbe a Mono
motore JIT. LLVM_COUNT=0 disabiliterebbe del tutto il motore LLVM.

MONO_AOT_CACHE
Se impostata, questa variabile indicherà a Mono di compilare in anticipo i nuovi assembly su
richiedere e memorizzare il risultato in una cache in ~/.mono/aot-cache.

MONO_ASPNET_INHIBIT_SETTINGSMAP
Mono contiene una funzionalità che consente di modificare le impostazioni nei file .config
fornito con Mono utilizzando i mapper della sezione di configurazione. I mappatori e la mappatura
le regole sono definite nel file $prefix/etc/mono/2.0/settings.map e, facoltativamente, in
il file settings.map che si trova nella directory di primo livello dell'applicazione ASP.NET.
Entrambi i file vengono letti da System.Web all'avvio dell'applicazione, se si trovano in
posizioni sopra. Se non vuoi che la mappatura venga eseguita puoi impostare questo
variabile nel tuo ambiente prima di avviare l'applicazione e nessuna azione sarà
prese.

MONO_ASPNET_WEBCONFIG_CACHESIZE
Mono ha una cache di oggetti ConfigSection per velocizzare WebConfigurationManager
interrogazioni. La sua dimensione predefinita è 100 elementi e, quando sono necessari più elementi, cache
iniziano gli sgomberi. Se gli sfratti sono troppo frequenti questo potrebbe imporre
sovraccarico non necessario, che potrebbe essere evitato utilizzando questa variabile di ambiente per
impostare una dimensione della cache maggiore (o ridurre i requisiti di memoria diminuendola).

MONO_CAIRO_DEBUG_DISPOSE
Se impostato, fa sì che Mono.Cairo raccolga le tracce dello stack quando gli oggetti vengono allocati, quindi
che gli avvisi di finalizzazione/eliminazione includano informazioni sull'istanza
origine.

MONO_CFG_DIR
Se impostata, questa variabile sovrascrive la directory di configurazione del sistema predefinita
($ PREFISSO/ecc). Viene utilizzato per individuare il file machine.config.

MONO_COM
Imposta lo stile dell'interoperabilità COM. Se il valore di questa variabile è "MS" verrà utilizzato Mono
routine di marhsalling di stringhe da liboleaut32 per la libreria di tipi BSTR, any
altri valori utilizzeranno il marshalling di stringhe BSTR mono incorporato.

MONO_CONFIG
Se impostata, questa variabile sovrascrive il file di configurazione runtime predefinito
($PREFIX/etc/mono/config). Le opzioni della riga di comando --config sovrascrivono
variabile d'ambiente.

MONO_CPU_ARCH
Ignora il meccanismo di rilevamento automatico della CPU. Attualmente utilizzato solo su braccio. Il
il formato del valore è il seguente:

"armvV [pollice[2]]"

dove V è il numero di architettura 4, 5, 6, 7 e le opzioni possono essere attualmente essere
"pollice" o "pollice2". Esempio:

MONO_CPU_ARCH="armv4 pollice" mono...

MONO_ARM_FORCE_SOFT_FLOAT
Quando Mono è costruito con un fallback mobile morbido su ARM e questa variabile è impostata su
"1", Mono emetterà sempre un codice a virgola mobile, anche se viene rilevata un'unità VFP.

MONO_DISABLE_AIO
Se impostato, indica a mono di NON tentare di utilizzare i servizi di I/O asincroni nativi. In ciò
caso, viene utilizzata un'implementazione di selezione/selezione predefinita. Attualmente solo epoll() è
supportato.

MONO_DISABLE_MANAGED_COLLAZIONE
Se questa variabile d'ambienteè 'sì', il runtime usa regole di confronto non gestite (che
in realtà significa nessuna confronto sensibile alle impostazioni cultura). Disabilita internamente gestito
funzionalità di confronto richiamata tramite i membri di System.Globalization.CompareInfo
classe. Le regole di confronto sono abilitate per impostazione predefinita.

MONO_DISABLE_SHM
Solo Unix: se impostato, disabilita i file di memoria condivisa utilizzati per gli handle tra processi:
il processo ha solo handle privati. Ciò significa che gli handle di processo e thread sono
non disponibile per altri processi e mutex denominati, eventi denominati e denominati
i semafori non sono visibili tra i processi. Questo può essere abilitato anche da
default passando l'opzione "--disable-shared-handles" per configurare. Questo è il
predefinito da mono 2.8 in poi.

MONO_DISABLE_AREA_CONDIVISA
Solo Unix: se impostato, disabilita l'utilizzo della memoria condivisa per esporre le prestazioni
contatori. Ciò significa che non sarà possibile leggere entrambe le prestazioni dall'esterno
contatori di questi processi o leggere quelli di processi esterni.

MONO_DNS
Quando impostato, abilita l'uso di un resolver DNS completamente gestito invece del normale
funzioni libc. Questo risolutore funziona molto meglio quando vengono eseguite più query
parallelo.

Si noti che /etc/nsswitch.conf verrà ignorato.

MONO_EGD_SOCKET
Per piattaforme che altrimenti non hanno un modo per ottenere byte casuali questo può
essere impostato sul nome di un socket del file system su cui si trova un demone egd o prngd
ascoltando.

MONO_ENABLE_SHM
Solo Unix: abilita il supporto per gli handle tra processi. Le maniglie tra processi sono
utilizzato per esporre handle di processo, handle di thread, mutex denominati, eventi denominati e
semafori denominati attraverso i processi Unix.

MONO_ENV_OPZIONI
Questa variabile di ambiente ti consente di passare argomenti della riga di comando a un Mono
processo attraverso l'ambiente. Questo è utile ad esempio per forzare tutti i tuoi
Processi mono per utilizzare LLVM o SGEN senza dover modificare alcuno script di avvio.

MONO_ENV_OPZIONI
Utilizzato per passare opzioni extra all'agente debugger nel runtime, così com'erano
passato usando --debugger-agent=.

MONO_EVENTLOG_TYPE
Imposta il tipo di provider del registro eventi da utilizzare (per System.Diagnostics.EventLog).
I valori possibili sono:

locale[:percorso]
Persiste i registri degli eventi e le voci nel file system locale. La directory in
quale mantenere i registri degli eventi, le origini degli eventi e le voci possono essere specificate
come parte del valore. Se il percorso non è impostato in modo esplicito, il valore predefinito è
"/var/lib/mono/eventlog" su Unix e "%APPDATA%no\ventlog" su Windows.

win32 si utilizza , il nativo win32 API a scrivere eventi che a registri evento i registri che a evento
fonti nel registro. Questo è disponibile solo su Windows. Su Unix, il
autorizzazione alla directory per il registro degli eventi individuali e le directory di origine degli eventi
è impostato su 777 (con +t bit) consentendo a tutti di leggere e scrivere il registro degli eventi
voci consentendo solo la cancellazione delle voci da parte degli utenti che
li ha creati.

nullo Scarta silenziosamente tutti gli eventi.

L'impostazione predefinita è "null" su Unix (e versioni di Windows precedenti a NT) e "win32" su
Windows NT (e versioni successive).

MONO_CODIFICA_ESTERNA
Se impostato, contiene un elenco di codifiche di testo separate da due punti da provare quando si gira
testo generato esternamente (ad es. argomenti della riga di comando o nomi di file) in Unicode.
I nomi di codifica provengono dall'elenco fornito da iconv e dal caso speciale
"default_locale" che si riferisce alla codifica predefinita della locale corrente.

Quando si leggono stringhe di testo generate esternamente, viene provato prima UTF-8, quindi questo
l'elenco viene provato in ordine con la prima conversione riuscita che termina la ricerca.
Quando si scrive testo esterno (es. nuovi nomi di file o argomenti per nuovi processi) il
viene utilizzato il primo elemento in questo elenco o UTF-8 se la variabile di ambiente non è impostata.

Il problema con l'utilizzo di MONO_EXTERNAL_ENCODINGS per elaborare i file è che
si traduce in un problema: sebbene sia possibile ottenere il nome file corretto, non lo è
necessariamente possibile aprire il file. In generale, se hai problemi con
codifiche nei nomi dei file dovresti usare il programma "convmv".

MONO_GC_PARAMS
Quando si utilizza Mono con il Garbage Collector SGen, questa variabile ne controlla diversi
parametri del collettore. Il valore della variabile è un elenco separato da virgole di
parole.

vivaio=Taglia
Imposta la dimensione del vivaio. La dimensione è specificata in byte e deve essere a
potenza di due. I suffissi `k', `m' e `g' possono essere usati per specificare kilo-,
rispettivamente mega e gigabyte. Il vivaio è la prima generazione (di
Due). Un asilo nido più grande di solito accelererà il programma, ma ovviamente lo farà
utilizzare più memoria. La dimensione predefinita dell'asilo nido 4 MB.

maggiore=collettore Specifica quale collettore principale utilizzare.
Le opzioni sono "marksweep" per il raccoglitore Mark&Sweep e "marksweep-conc"
per Mark&Sweep simultaneo. Il raccoglitore Mark&Sweep non simultaneo è il
predefinito.

limite-soft-heap=Taglia
Una volta che la dimensione dell'heap diventa maggiore di questa dimensione, ignora quale sia la maggiore predefinita
la metrica di attivazione della raccolta dice e consente solo quattro dimensioni dell'asilo nido maggiori
crescita del cumulo tra le collezioni principali.

soglia-evacuazione=soglia
Imposta la soglia di evacuazione in percentuale. Questa opzione è disponibile solo su
i maggiori collezionisti di Mark&Sweep. Il valore deve essere un numero intero nell'intervallo
Da 0 a 100. Il valore predefinito è 66. Se la fase di scansione della raccolta trova
che l'occupazione di un tipo di blocco heap specifico è inferiore a questo
percentuale, farà una raccolta di copie per quel tipo di blocco nel prossimo
raccolta importante, riportando così l'occupazione a quasi il 100%. UN
il valore 0 disattiva l'evacuazione.

(no-)pigro-sweep
Abilita o disabilita la scansione pigra per il raccoglitore Mark&Sweep. Se abilitato,
lo spazzamento dei singoli blocchi principali dell'heap viene eseguito in modo frammentario ogni volta che il
necessità, in genere durante le collezioni vivaio. Lo spazzamento pigro è abilitato
per impostazione predefinita.

(no-)sweep-concorrente
Abilita o disabilita la scansione simultanea per il raccoglitore Mark&Sweep. Se
abilitato, l'iterazione di tutti i blocchi principali per determinare quali possono essere
liberato e quali devono essere conservati e spazzati, è fatto in concomitanza con
il programma in esecuzione. Lo sweep simultaneo è abilitato per impostazione predefinita.

segno-pila=modalità mark
Specifica come devono essere scansionati i thread dell'applicazione. Le opzioni sono `precise`
e "conservatore". La marcatura precisa consente al collezionista di sapere quali valori
nello stack ci sono i riferimenti e cosa no. Minacce di contrassegno conservativo tutti
valori come potenziali riferimenti e lasciarli intatti. Marcatura precisa
riduce i rifiuti galleggianti e può accelerare la raccolta e l'allocazione dei vivai
tasso, ha il rovescio della medaglia di richiedere una significativa memoria extra per
metodo compilato. L'opzione giusta, purtroppo, richiede sperimentazione.

rapporto-obiettivo-salvataggio=rapporto
Specifica il rapporto di salvataggio di destinazione per il raccoglitore principale. Il collezionista lascia
una determinata quantità di memoria da promuovere dalla scuola materna a causa di minori
raccolte prima che attivi una raccolta importante. Questo importo si basa su
quanta memoria si aspetta di liberare. È rappresentato come un rapporto tra le dimensioni
del mucchio dopo una raccolta importante. I valori validi sono compresi tra 0.1 e 2.0.
Il valore predefinito è 0.5. Valori più piccoli manterranno più piccola la dimensione dell'heap principale
ma attiverà raccolte più importanti. Allo stesso modo, utilizzeranno valori più grandi
più memoria e si traducono in raccolte principali meno frequenti. Questa opzione è
SPERIMENTALE, quindi potrebbe scomparire nelle versioni successive di mono.

rapporto-quota-predefinito=rapporto
Specifica l'indennità di allocazione predefinita quando la dimensione calcolata è troppo
piccolo. L'indennità di allocazione è la quantità di memoria che il collezionista lascia essere
promosso prima di innescare una grande raccolta. È un rapporto del vivaio
dimensione. I valori validi sono compresi tra 1.0 e 10.0. L'impostazione predefinita è 4.0. Più piccola
i valori portano a cumuli più piccoli e raccolte maggiori più frequenti. Allo stesso modo,
valori più grandi consentiranno all'heap di crescere più velocemente ma utilizzeranno più memoria quando lo farà
raggiunge una dimensione stabile. Questa opzione è SPERIMENTALE, quindi potrebbe scomparire
nelle versioni successive di mono.

minore=minore-collezionista
Specifica quale raccoglitore secondario utilizzare. Le opzioni sono "semplici" che promuovono
tutti gli oggetti dal vivaio direttamente alla vecchia generazione e 'divisi'
che consente all'oggetto di rimanere più a lungo nel vivaio prima di essere promosso.

rapporto di allocazione=rapporto
Specifica il rapporto di memoria del vivaio che deve essere utilizzato dallo spazio di allocazione.
Questo può essere utilizzato solo con il raccoglitore minore diviso. I valori validi sono
numeri interi compresi tra 1 e 100. Il valore predefinito è 60.

promozione-età=
Specifica l'età richiesta di un oggetto che deve raggiungere all'interno del vivaio prima
stato promosso alla vecchia generazione. Questo può essere utilizzato solo con il
collezionista minore diviso. I valori validi sono numeri interi compresi tra 1 e 14. Predefinito
è 2.

(non) cementazione
Abilita o disabilita la cementazione. Questo può ridurre drasticamente la scuola materna
tempi di raccolta su alcuni benchmark in cui si fa riferimento agli oggetti appuntati
dal mucchio maggiore.

MONO_GC_DEBUG
Quando si utilizza Mono con il Garbage Collector SGEN, questa variabile d'ambiente può essere
utilizzato per attivare varie funzionalità di debug del raccoglitore. Il valore di questo
variabile è un elenco di parole separate da virgole. Non utilizzare queste opzioni in
produzione.

numero Imposta il livello di debug sul numero specificato.

indennità di stampa
Dopo ogni raccolta principale stampa il consumo di memoria per il prima e il dopo
la riscossione e l'indennità per il collezionista minore, ovvero quanto il
heap può crescere da raccolte minori prima della successiva major
viene attivata la raccolta.

stampa pinning
Raccoglie statistiche sulle classi i cui oggetti sono appuntati nell'asilo
e per cui vengono aggiunte voci remset globali. Stampa quelle statistiche quando
chiudere.

raccogliere-prima-allocs

check-at-minori-collezioni
Questo esegue un controllo di coerenza su raccolte minori e cancella anche il
asilo nido al momento della raccolta, invece dell'impostazione predefinita, quando i buffer sono
allocato (clear-at-gc). Il controllo di coerenza assicura che non vi siano
riferimenti da maggiori a minori che non sono negli insiemi ricordati.

controllo-coerenza-unione-mod
Controlla che la scheda mod-union sia coerente prima di ogni finitura
grande pausa di raccolta. Questo controllo è applicabile solo a major concorrenti
collezionisti.

bit-segno di spunta
I controlli che contrassegnano i bit nell'heap principale sono coerenti alla fine di ciascuno
raccolta importante. Bit di contrassegno coerenti significano che se un oggetto è contrassegnato,
devono essere contrassegnati anche tutti gli oggetti a cui ha fatto riferimento.

check-nursery-appuntato
Dopo le raccolte in vivaio e prima di iniziare le raccolte simultanee, controllare
se tutti gli oggetti della scuola materna sono appuntati o meno, a seconda di
contesto. Non fa nulla quando viene utilizzato il raccoglitore vivaio diviso.

xdomain-controlli
Esegue un controllo per assicurarsi che non siano rimasti riferimenti a uno scarico
Dominio app.

clear-at-tlab-creazione
Cancella il vivaio in modo incrementale quando i buffer di allocazione locale del thread
(TLAB) vengono creati. L'impostazione predefinita cancella l'intero vivaio in GC
tempo.

debug-clear-at-tlab-creation
Cancella il vivaio in modo incrementale quando i buffer di allocazione locale del thread
(TLAB) vengono creati, ma al momento di GC lo riempie con il byte `0xff`, che
dovrebbe provocare un arresto anomalo più rapidamente se `clear-at-tlab-creation` non lo fa
funzionare correttamente.

cancella-at-gc
Questo cancella l'asilo nido al momento del GC invece di farlo quando il thread è locale
viene creato il buffer di allocazione (TLAB). L'impostazione predefinita è cancellare l'asilo nido a
Tempo di creazione del TLAB.

disabilita-minore
Non fare raccolte minori. Se il vivaio è pieno, una raccolta importante è
attivato invece, a meno che anch'esso non sia disabilitato.

disabilita-maggiore
Non fare raccolte importanti.

segno-pila-conservativo
Forza il GC a scansionare lo stack in modo conservativo, anche se la scansione precisa è
a disposizione.

nessun-allocatore-gestito
Disabilita l'allocatore gestito.

check-scan-inizia
Se impostato, esegue un controllo di plausibilità su scan_start prima e dopo ciascuno
collezione

verificare-nursery-at-minor-gc
Se impostato, fa un oggetto completo a piedi della scuola materna all'inizio di ogni
raccolta minore.

discarica-asilo nido-a-minor-gc
Se impostato, scarica il contenuto dell'asilo all'inizio di ogni minore
collezione. Richiede l'impostazione di verificare-nursery-at-minor-gc.

dump-heap=filetto
Scarica il contenuto dell'heap nel file specificato. Per visualizzare il
informazioni, utilizzare lo strumento mono-heapviz.

protocollo binario=filetto
Emette l'output di debug nel file specificato. Perché funzioni, Mono
deve essere compilato con il BINARY_PROTOCOL define su sgen-gc.c. Puoi
quindi usa questo comando per esplorare l'output
sgen-grep-binprot 0x1234 0x5678 < file

vivaio-canarini
Se impostato, gli oggetti allocati nel vivaio sono suffissi con un canarino (guardia)
word, che viene verificata su ogni raccolta minore. Può essere usato per rilevare/debug
problemi di corruzione dell'heap.

non-finalizzare
Se abilitato, i finalizzatori non verranno eseguiti. Tutto il resto sarà inalterato:
gli oggetti finalizzabili verranno comunque inseriti nella coda di finalizzazione dove
sopravvivere fino a quando non sono programmati per la finalizzazione. Una volta che non sono in coda
più saranno raccolti regolarmente.

finalizzatori di log
Accedi dettagliatamente al processo di finalizzazione per facilitare il debug.

MONO_GAC_PREFIX
Fornisce un prefisso utilizzato dal runtime per cercare Global Assembly Cache. Directory
sono separati dal separatore del percorso della piattaforma (due punti su unix). MONO_GAC_PREFIX
dovrebbe puntare alla directory principale di un'installazione prefissata. O alla directory
fornito nel comando gacutil /gacdir. Esempio:
/home/nomeutente/.mono:/usr/local/mono/

MONO_IOMAP
Abilita il supporto per la riscrittura dei nomi di file per assistere le applicazioni scritte male che
percorsi di Windows hardcoded. Imposta su un elenco separato da due punti di "unità" per rimuovere l'unità
lettere, o "case" per eseguire la corrispondenza di file senza distinzione tra maiuscole e minuscole in ogni directory in a
sentiero. "all" abilita tutti i metodi di riscrittura. (Le barre rovesciate sono sempre mappate su
barre se questa variabile è impostata su un'opzione valida).
Ad esempio, questo funzionerebbe dalla shell:

MONO_IOMAP=unità:custodia
esporta MONO_IOMAP

Se stai usando mod_mono per ospitare le tue applicazioni web, puoi usare il MonoIOMAP
direttiva invece, in questo modo:

MonoIOMAP tutto

See mod_mono(8) per maggiori dettagli.

Inoltre. Mono include un modulo profiler che consente di tenere traccia di cosa
modifiche ai percorsi dei file che il codice IOMAP deve fare. Il codice di monitoraggio riporta il
posizione gestita (traccia dello stack completo) da cui è stata effettuata la chiamata IOMAP-ed e, su
process exit, le posizioni in cui sono state create tutte le stringhe IOMAP-ed in managed
codice. Quest'ultimo rapporto è solo approssimativo in quanto non è sempre possibile
stimare la posizione effettiva in cui è stata creata la stringa. Il codice usa simple
euristica: analizza la traccia dello stack che riporta alla posizione di allocazione della stringa
e ignora tutto il codice gestito che risiede anche negli assembly installati in GAC
come nelle librerie di classi fornite con Mono (poiché si presume che siano prive di
problemi di distinzione tra maiuscole e minuscole). Quindi riporta la prima posizione nel codice dell'utente -
nella maggior parte dei casi questo sarà il luogo in cui è allocata la stringa o molto vicino a
la posizione. Il codice di reporting è implementato come modulo di profilazione personalizzato (vedi
la sezione "PROFILATURA") e può essere caricato nel seguente modo:

mono --profile=iomap la tua applicazione.exe

Si noti, tuttavia, che Mono attualmente supporta solo un modulo profiler alla volta.

MONO_LLVM
Quando Mono utilizza il backend di generazione del codice LLVM, puoi utilizzare questo ambiente
variabile per passare le opzioni di generazione del codice al compilatore LLVM.

MONO_MANAGED_WATCHER
Se impostato su "disabilitato", System.IO.FileSystemWatcher utilizzerà un file watcher
implementazione che ignora silenziosamente tutte le richieste di sorveglianza. Se impostato su qualsiasi
altro valore, System.IO.FileSystemWatcher utilizzerà il default managed
attuazione (lento). Se non impostato, mono proverà a utilizzare inotify, FAM, Gamin, kevent
sotto i sistemi Unix e le chiamate API native su Windows, ricorrendo al gestito
attuazione in caso di errore.

MONO_MESSAGING_PROVIDER
Mono supporta un modello di plugin per la sua implementazione di System.Messaging rendendolo
possibile supportare una varietà di implementazioni di messaggistica (es. AMQP, ActiveMQ).
Per specificare quale implementazione di messaggistica deve essere utilizzata la variabile ambiente
deve essere impostato sul nome completo della classe per il provider. Ad esempio, per utilizzare RabbitMQ
basata sull'implementazione AMQP la variabile dovrebbe essere impostata su:

Mono.Messaging.ConiglioMQ.ConiglioMQMessagingProvider,Mono.Messaging.ConiglioMQ

MONO_NO_SMP
Se impostato fa sì che il processo mono sia associato a un singolo processore. Può essere
utile durante il debug o per aggirare le race condition.

MONO_NO_TLS
Disabilita l'inlining degli accessi locali del thread. Prova a impostarlo se ricevi un segfault
all'inizio dell'esecuzione di mono.

MONO_PERCORSO
Fornisce un percorso di ricerca al runtime dove cercare la libreria
File. Questo è uno strumento utile per il debug delle applicazioni, ma
non dovrebbe essere utilizzato dalle applicazioni distribuite in quanto interrompe l'assieme
caricatore in modi sottili.
Le directory sono separate dal separatore del percorso della piattaforma (due punti su Unix). Esempio:
/home/nomeutente/lib:/usr/local/mono/lib
I percorsi relativi vengono risolti in base alla directory corrente al momento dell'avvio.
Le soluzioni alternative a MONO_PATH includono: installazione di librerie in
la Global Assembly Cache (vedi gacutil(1)) o avere il dipendente
librerie fianco a fianco con l'eseguibile principale.
Per una descrizione completa delle pratiche consigliate per l'applicazione
distribuzione, vedere
http://www.mono-project.com/docs/getting-started/application-deployment/

MONO_RTC
Supporto RTC sperimentale nel profiler statistico: se l'utente ha
il permesso, vengono raccolte statistiche più accurate. Il MONO_RTC
il valore deve essere limitato a ciò che consente il rtc di Linux: potenza di due
da 64 a 8192 Hz. Per abilitare frequenze più alte come 4096 Hz, esegui come root:

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

Per esempio:

MONO_RTC=4096 mono --profiler=default:stat program.exe

MONO_DIR_CONDIVISA
Se impostato è la directory in cui è memorizzato lo stato dell'handle ".wapi". Questo è il
directory in cui il livello di emulazione I/O di Windows memorizza i suoi dati di stato condivisi
(file, eventi, mutex, pipe). Per impostazione predefinita, Mono memorizzerà la directory ".wapi"
nella home directory degli utenti.

MONO_SHARED_NOMEHOST
Utilizza il valore stringa di questa variabile in sostituzione del nome host quando
creazione di nomi di file nella directory ".wapi". Questo aiuta se il nome host del tuo
è probabile che la macchina venga cambiata quando è in esecuzione un'applicazione mono o se si dispone di un
Directory .wapi condivisa tra diversi computer. Mono in genere usa il
hostname per creare i file che vengono utilizzati per condividere lo stato su più Mono
processi. Questo viene fatto per supportare le home directory che potrebbero essere condivise nel
rete.

MONO_STRICT_IO_EMULAZIONE
Se impostato, vengono effettuati controlli aggiuntivi durante le operazioni di I/O. Attualmente, questo include solo
blocchi di avviso sulle scritture di file.

MONO_TEMA
Il nome del tema che deve essere utilizzato da Windows.Forms. I temi disponibili oggi includono
"clearlooks", "nice" e "win32". L'impostazione predefinita è "win32".

MONO_TLS_SESSION_CACHE_TIMEOUT
Il tempo, in secondi, che la cache della sessione SSL/TLS manterrà la sua voce per evitare
una nuova negoziazione tra il client e un server. La negoziazione è molto CPU
intensivo, quindi un valore personalizzato specifico dell'applicazione può rivelarsi utile per i piccoli
sistemi integrati. L'impostazione predefinita è 180 secondi.

MONO_THREADS_PER_CPU
Il numero minimo di thread nel pool di thread generale sarà
MONO_THREADS_PER_CPU * numero di CPU. Il valore predefinito per questa variabile è 1.

MONO_XMLSERIALIZER_THS
Controlla la soglia per XmlSerializer per produrre un serializzatore personalizzato per a
data classe invece di usare l'interprete basato su Reflection. I possibili valori
sono `no' per disabilitare l'uso di un serializzatore personalizzato o un numero per indicare quando il
XmlSerializer dovrebbe iniziare la serializzazione. Il valore predefinito è 50, il che significa che
il serializzatore personalizzato verrà prodotto al 50° utilizzo.

MONO_X509_REVOCATION_MODE
Imposta la modalità di revoca utilizzata durante la convalida di una catena di certificati X509 (https,
ftps, smtps...). L'impostazione predefinita è 'nocheck', che non esegue alcun controllo di revoca su
tutto. Gli altri valori possibili sono 'offline', che esegue il controllo CRL (non
implementato ancora) e 'online' che utilizza OCSP e CRL per verificare la revoca
stato (non ancora implementato).

AMBIENTE VARIABILI PER DEBUG

MONO_ASPNET_NODELETE
Se impostato su qualsiasi valore, i file di origine temporanei generati dalle classi di supporto ASP.NET
non verrà rimosso. Verranno conservati nella directory temporanea dell'utente.

MONO_DEBUG
Se impostato, abilita alcune funzionalità del runtime utili per il debug. Questa variabile
dovrebbe contenere un elenco separato da virgole di opzioni di debug. Attualmente, il
sono supportate le seguenti opzioni:

break-on-non verificato
Se questa variabile è impostata, quando la Mono VM incontra un problema di verifica,
invece di lanciare un'eccezione, entrerà nel debugger. Questo è
utile durante il debug dei problemi del verificatore

calchi Questa opzione può essere utilizzata per ottenere informazioni più dettagliate da InvalidCast
eccezioni, fornirà informazioni sui tipi coinvolti.

raccogliere-pagefault-stats
Raccoglie informazioni sui pagefault. Questo è usato internamente per tracciare
il numero di errori di pagina prodotti per caricare i metadati. Per visualizzare questo
informazioni è necessario utilizzare questa opzione con l'opzione della riga di comando "--stats".

dont-free-domini
Questa è un'ottimizzazione per applicazioni multi-AppDomain (più comunemente
applicazioni ASP.NET). A causa di limitazioni interne Mono, Mono per impostazione predefinita
non utilizza allocazioni digitate su applicazioni multi-appDomain come potrebbero
perdita di memoria quando un dominio viene scaricato. Sebbene questa sia una buona impostazione predefinita, per
applicazioni che utilizzano molto più che su AppDomain (ad esempio, ASP.NET
applicazioni) vale la pena barattare le piccole perdite per l'aumento
prestazioni (inoltre, poiché le applicazioni ASP.NET probabilmente non funzioneranno
per scaricare i domini applicativi sui sistemi di produzione, vale la pena usare
questa caratteristica).

dyn-runtime-invoke
Indica al runtime di provare a utilizzare invece un wrapper di richiamo runtime generico
di creare un wrapper di invocazione.

gdb Equivalente a impostare il MONO_XDEBUG variabile, questo emette simboli in a
libreria condivisa poiché il codice è JITed che può essere caricato in GDB per ispezionare
simboli.

gen-seq-punti
Genera automaticamente punti di sequenza in cui lo stack IL è vuoto. Queste
sono luoghi in cui il debugger può impostare un punto di interruzione.

controlli-null-espliciti
Fa in modo che JIT generi un controllo NULL esplicito sui dereference delle variabili
invece di dipendere dal sistema operativo per aumentare un SIGSEGV o un altro
forma di evento trap quando si accede a una posizione di memoria non valida.

maniglia-sigint
Cattura il segnale di interruzione (Control-C) e visualizza una traccia dello stack quando
premuto. Utile per scoprire dove viene eseguito il programma in un dato momento
punto. Visualizza solo la traccia dello stack di un singolo thread.

init-stack
Indica al runtime di inizializzare lo stack con alcuni valori noti (0x2a
su x86-64) all'inizio di un metodo per assistere nel debugging del motore JIT.

mantenere-delegati
Questa opzione farà trapelare i trampolini dei delegati a cui non si fa più riferimento come
per presentare all'utente ulteriori informazioni su un uso improprio del delegato.
Fondamentalmente potrebbe essere creata un'istanza delegata, passata a codice non gestito,
e nessun riferimento mantenuto nel codice gestito, che eliminerà il codice nella spazzatura.
Con questa opzione è possibile risalire all'origine dei problemi.

reverse-pinvoke-eccezioni
Questa opzione farà interrompere mono con un messaggio descrittivo durante
lo stack si srotola dopo un'eccezione raggiunge uno stack frame nativo. Questo
si verifica quando un delegato gestito viene passato al codice nativo e il gestore
delegato genera un'eccezione. Mono normalmente cercherà di srotolare lo stack per
il primo gestore di eccezioni (gestito) e salterà qualsiasi stack nativo
frame nel processo. Questo porta a un comportamento indefinito (poiché mono non lo fa
sapere come elaborare i frame nativi), perdite e forse anche arresti anomali.

no-gdb-backtrace
Questa opzione disabiliterà il backtrace GDB emesso dal runtime dopo a
SIGSEGV o SIGABRT in codice non gestito.

sospensione su sigegv
Questa opzione sospenderà il programma quando viene ricevuto un SIGSEGV nativo.
Questo è utile per il debug di arresti anomali che non si verificano con gdb, poiché a
il processo live contiene più informazioni di un file core.

check-pinvoke-call conv
Questa opzione fa sì che il runtime controlli la mancata corrispondenza delle convenzioni di chiamata
quando si usa pinvoke, cioè mescolando cdecl/stdcall. Funziona solo su windows. Se
viene rilevata una mancata corrispondenza, viene generata un'ExecutionEngineException.

MONO_LOG_LIVELLO
Il livello di registrazione, i valori possibili sono "error", "critical", "warning", "message",
"info" e "debug". Vedere la sezione DEBUG per maggiori dettagli.

MONO_LOG_MASK
Controlla il dominio del runtime Mono a cui verrà applicata la registrazione. Se impostato, il
la maschera di registro viene modificata al valore impostato. I valori possibili sono "asm" (caricatore di assemblaggi),
"type", "dll" (caricatore della libreria nativa), "gc" (garbage collector), "cfg" (file di configurazione
loader), "aot" (precompilatore), "security" (es. supporto Moonlight CoreCLR) e
"tutto". Il valore predefinito è "tutto". La modifica del valore della maschera consente di visualizzare
solo messaggi per un determinato componente. Puoi usare più maschere per virgola
separandoli. Ad esempio per vedere i messaggi del file di configurazione e il caricatore di assembly
i messaggi impostano la maschera su "asm,cfg".

MONO_TRACCIA
Utilizzato per la traccia di runtime delle chiamate al metodo. Il formato della traccia separata da virgole
opzioni è:

[-]M:nome del metodo
[-]N:spazio dei nomi
[-]T:nome classe
[-]tutto
[-]programma
disabilitato Uscita traccia disattivata all'avvio.

È possibile attivare/disattivare l'output di traccia inviando un segnale SIGUSR2 al programma.

MONO_TRACE_LISTENER
Se impostato, abilita System.Diagnostics.DefaultTraceListener, che stamperà il file
output delle classi System.Diagnostics Trace e Debug. Può essere impostato su a
filename e in Console.Out o Console.Error per visualizzare l'output nello standard output
o errore standard, rispettivamente. Se è impostato su Console.Out o Console.Error you
può aggiungere un prefisso opzionale che verrà utilizzato durante la scrittura di messaggi come questo:
Console.Error:MyProgramName. Vedere System.Diagnostics.DefaultTraceListener
documentazione per ulteriori informazioni.

MONO_WCF_TRACE
Ciò semplifica la funzionalità di diagnostica WCF semplicemente emettendo tutti i messaggi di registro da
Motore WCF su "stdout", "stderr" o qualsiasi file passato a questa variabile di ambiente.
Il formato del registro è lo stesso del normale output diagnostico.

MONO_XECCEZIONI
Questo genera un'eccezione quando viene rilevato un errore X11; per impostazione predefinita un messaggio è
visualizzato ma l'esecuzione continua

MONO_XMLSERIALIZER_DEBUG
Impostare questo valore su 1 per impedire al serializzatore di rimuovere i file temporanei
che sono creati per una serializzazione veloce; Questo potrebbe essere utile durante il debug.

MONO_XSYNC
Viene utilizzato nell'implementazione System.Windows.Forms durante l'esecuzione con X11
back-end. Viene utilizzato per eseguire il debug dei problemi in Windows.Forms poiché forza tutti i file
i comandi inviati al server X11 devono essere eseguiti in modo sincrono. La modalità predefinita di
l'operazione è asincrona, il che rende difficile isolare la radice di determinati
problemi.

MONO_GENERIC_CONDIVISIONE
Questa variabile di ambiente controlla il tipo di condivisione generica utilizzata. Questa variabile
viene utilizzato dagli sviluppatori JIT interni e non deve essere modificato in produzione. Non
usalo. La variabile controlla quali classi avranno una condivisione di codice generica
abilitato. I valori ammessi sono:

contro tutti i Tutto il codice generato può essere condiviso.

collezioni
Solo le classi in System.Collections.Generic avranno il codice condiviso
(Questo è il valore predefinito).

corlib Solo il codice in corlib avrà il suo codice condiviso.

nessuna Non verrà eseguita alcuna condivisione di codice generico.
La condivisione del codice generico per impostazione predefinita si applica solo alle raccolte. Il Mono JIT per impostazione predefinita
si accende.

MONO_XDEBUG
Quando è impostata la MONO_XDEBUG env var, vengono emesse le informazioni di debug per il codice JIT
in una libreria condivisa, caricabile in gdb. Ciò consente, ad esempio, di vedere gestito
nomi dei frame sui backtrace gdb.

MONO_VERBOSE_METODO
Abilita la massima verbosità JIT per il metodo specificato. Questo è molto utile
per diagnosticare problemi di compilazione errata di un metodo specifico.

MONO_VERBOSE_HWCAP
Se impostato, rende le informazioni di output JIT sulle funzioni della CPU rilevate (come SSE,
CMOV, FCMOV, ecc.) allo stdout.

MONO_CONSERVATIVO_HWCAP
Se impostato, JIT non eseguirà alcun rilevamento della capacità hardware. Può essere
utile per individuare la causa dei problemi JIT. Questa è l'impostazione predefinita quando viene creato Mono
come un compilatore incrociato AOT, in modo che il codice generato venga eseguito sulla maggior parte dell'hardware.

VALGRIND

Se vuoi usare Valgrind, troverai utile il file `mono.supp', che contiene il file
soppressioni per il GC che attivano avvisi errati. Usalo in questo modo:
valgrind --suppressions=mono.supp mono ...

DTRACE

Su alcune piattaforme, Mono può esporre una serie di sonde DTrace (note anche come user-land
staticamente definiti, sonde USDT).

Sono definiti nel file `mono.d'.

ves-init-inizio, ves-init-fine
Inizio e fine dell'inizializzazione del runtime.

metodo-compilazione-inizio, metodo-compilazione-fine
Inizio e fine della compilazione del metodo. Gli argomenti del probe sono il nome della classe, il metodo
nome e firma, e in caso di successo o fallimento della compilazione del metodo
compilazione.

gc-inizio, fine gc
Inizio e fine della raccolta dei rifiuti.

Per verificare la disponibilità delle sonde, eseguire:
dtrace -P mono'$target' -l -c mono

PERMESSI

L'implementazione di Ping di Mono per il rilevamento della raggiungibilità della rete può creare i pacchetti ICMP
stesso senza richiedere il comando ping di sistema per eseguire il lavoro. Se vuoi abilitare
questo su Linux per utenti non root, è necessario concedere autorizzazioni speciali al binario Mono.

Come root, esegui questo comando:
# setcap cap_net_raw=+ep /usr/bin/mono

Utilizzare il mono online utilizzando i servizi onworks.net