荔园在线

荔园之美,在春之萌芽,在夏之绽放,在秋之收获,在冬之沉淀

[回到开始] [上一篇][下一篇]


发信人: Kenko (坎坷), 信区: Linux
标  题: man mono的内容
发信站: 荔园晨风BBS站 (2004年11月18日15:47:43 星期四), 转信

Mono(Mono 1.0)                                                  Mono(Mono 1.0)

NAME
       mono  -  Mono's ECMA-CLI native code generator (Just-in-Time and Ahead-
       of-Time)

SYNOPSIS
       mono [options] file [arguments...]

DESCRIPTION
       mono is a runtime implementation of the ECMA  Common  Language  Infras-
       tructure.  This can be used to run ECMA and .NET applications.

       The runtime contains a native code generator that transforms the Common
       Intermediate Language into native code.

       The code generator can operate in two modes: just in  time  compilation
       (JIT)  or  ahead  of time compilation (AOT).  Since code can be dynami-
       cally loaded, the runtime environment and the JIT are  always  present,
       even if code is compiled ahead of time.

       The  runtime  loads  ths specified file and optionally passes the argu-
       ments to it.  The file is an ECMA assembly.  They typically have a .exe

 or .dll extension.

       The  runtime  provides  a  number  of configuration options for running
       applications, for developping and debugging, and for testing and debug-
       ging the runtime itself.

RUNTIME OPTIONS
       The following options are available:

       --aot  This  option is used to precompile the CIL code in the specified
              assembly to native code.  The generated code is stored in a file
              with  the extension .so.  This file will be automatically picked
              up by the runtime when the assembly is executed.

              Ahead-of-Time compilation is most useful if you use it in combi-
              nation  with  the  -O=all,-shared  flag which enables all of the
              optimizations in the code generator to be  performed.   Some  of
              those  optimizations are not practical for Just-in-Time compila-
              tion since they might be very time consuming.

              Unlike the .NET Framework, Ahead-of-Time  compilation  will  not
              generate  domain  independent  code:  it generates the same code
              that the  Just-in-Time  compiler  would  produce.    Since  most
:
applications use a single domain, this is fine.   If you want to
              optimize the generated code for  use  in  multi-domain  applica-
              tions, consider using the -O=shared flag.

              This  pre-compiles  the  methods,  but  the original assembly is
              still required to execute as this one contains the metadata  and
              exception  information  which  is  not availble on the generated
              file.  When precompiling code, you might want  to  compile  with
              all optimizations (-O=all).  Pre-compiled code is position inde-
              pendent code.

              Pre compilation is just a mechanism to reduce startup time,  and
              avoid  just-in-time  compilation  costs.   The original assembly
              must still be present, as the metadata is contained there.

       --config filename
              Load the specified configuration file  instead  of  the  default
              one(s).  The default files are /etc/mono/config and ~/.mono/con-
              fig or the file specified in the MONO_CONFIG  environment  vari-
              able,  if  set.   See the mono-config(5) man page for details on
              the format of this file.

       --help , -h
 Displays usage instructions.

       --optimize=MODE , -O=mode
              MODE is a comma separated  list  of  optimizations.   They  also
              allow  optimizations to be turned off by prefixing the optimiza-
              tion name with a minus sign.

              The following optimizations are implemented:
                           all        Turn on all optimizations
                           peephole   Peephole postpass
                           branch     Branch optimizations
                           inline     Inline method calls
                           cfold      Constant folding
                           consprop   Constant propagation
                           copyprop   Copy propagation
                           deadce     Dead code elimination
                           linears    Linear scan global reg allocation
                           cmov       Conditional moves
                           shared     Emit per-domain code
                           sched      Instruction scheduling
                           intrins    Intrinsic method implementations
                           tailc      Tail recursion and tail calls
                           loop       Loop related optimizations
:
 leaf       Leaf procedures optimizations
                           profile    Use profiling information

              For example, to enable all the optimization but dead code elimi-
              nation and inlining, you can use:
                   -O=all,-deadce,-inline

       -V , --version
              Prints JIT version information.

DEVELOPMENT OPTIONS
       The following options are used to help when developing a JITed applica-
       tion.

       --debug
              Turns on the debugging mode in the runtime.  If an assembly  was
              compiled with debugging information, it will produce line number
              information for stack traces.

       --profile[=profiler[:profiler_args]]
              Instructs the runtime to  collect  profiling  information  about
              execution times and memory allocation, and dump it at the end of
              the execution.  If a profiler is not specified, the default pro-
:
 filer  is  used.  profiler_args is a profiler-specific string of
              options for the profiler itself.

       The default profiler accepts -time and -alloc to options to disable the
       time profiling or the memory allocation profilng.

JIT MAINTAINER OPTIONS
       The  maintainer  options  are only used by those developing the runtime
       itself, and not typically of interest to runtime users or developers.

       --compile name
              This compiles a method (namespace.name:methodname), this is used
              for testing the compiler performance or to examine the output of
              the code generator.

       --compileall
              Compiles all the methods in an assembly.  This is used  to  test
              the  compiler  performance  or to examine the output of the code
              generator

       --graph=TYPE METHOD
              This generates a postscript file with a graph with  the  details
              about  the  specified  method (namespace.name:methodname).  This
:
requires  `dot'  and  ghostview  to  be  installed  (it  expects
              Ghostview to be called "gv").

       The following graphs are available:
                 cfg        Control Flow Graph (CFG)
                 dtree      Dominator Tree
                 code       CFG showing code
                 ssa        CFG showing code after SSA translation
                 optcode    CFG showing code after IR optimizations

       Some  graphs will only be available if certain optimizations are turned
       on.

       --ncompile
              Instruct the runtime on the number  of  times  that  the  method
              specified  by  --compile  (or all the methods if --compileall is
              used) to be compiled.  This is used for testing the code genera-
              tor performance.

       -v , --verbose
              Increases the verbosity level, each time it is listed, increases
              the verbosity level to include more information (including,  for
              example,  a disassembly of the native code produced, code selec-
:
 tor info etc.).

       --break method
              Inserts a breakpoint before the method whose  name  is  `method'
              (namespace.class:methodname).   Use  `Main'  as  method  name to
              insert a breakpoint on the application's main method.

       --breakonex
              Inserts a breakpoint on exceptions.  This allows  you  to  debug
              your  application  with  a  native debugger when an exception is
              thrown.

       --trace[=expression]
              Shows method names as they are invoked.  By default all  methods
              are traced.

       The  trace  can be customized to include or exclude methods, classes or
       assemblies.  A trace expression is a comma separated list  of  targets,
       each  target can be prefixed with a minus sign to turn off a particular
       target.  The words `program' and `all' have special meaning.  `program'
       refers  to  the  main  program  being executed, and `all' means all the
       method calls.
 Assemblies are specified by their name, for example, to trace all calls
       in the System assembly, use:

            mono --trace=System app.exe

       Classes  are  specified  with the T: prefix.  For example, to trace all
       calls to the System.String class, use:

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

       And individual methods are referenced with the M: prefix, and the stan-
       dar method notation:

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

       As previously noted, various rules can be specified at once:

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

       You  can exclude pieces, the next example traces calls to System.String
       except for the System.String:Concat method.

            mono --trace=T:System.String,-M:System.String:Concat
:
 Finally, namespaces can be specified using the N: prefix:

            mono --trace=N:System.Xml

ENVIRONMENT VARIABLES
       GC_DONT_GC
              Turns off the garbage collection in Mono.  This should  be  only
              used for debugging purposes

       MONO_ASPNET_NODELETE
              If set to any value, temporary source files generated by ASP.NET
              support classes will not be removed. They will be  kept  in  the
              user's temporary directory.

       MONO_CFG_DIR
              If set, this variable overrides the default system configuration
              directory ($PREFIX/etc).  It's  used  to  locate  machine.config
              file.

       MONO_CONFIG
              If  set,  this variable overrides the default runtime configura-
              tion file ($PREFIX/etc/mono/config). The --config  command  line
:
options overrides the environment variable.

       MONO_LOG_LEVEL
              If  set, the logging level is changed to the set value. Possible
              values are "error", "critical",  "warning",  "message",  "info",
              "debug".  The  default value is "error". Messages with a logging
              level greater then or equal to the log level will be printed  to
              stdout/stderr.

       MONO_LOG_MASK
              If  set, the log mask is changed to the set value. Possible val-
              ues are "asm" (assembly loader), "type", "dll"  (native  library
              loader),  "gc"  (garbage collector), "cfg" (config file loader),
              "all". The default value  is  "all".  Changing  the  mask  value
              allows you to display only messages for a certain component. You
              can use multiple masks by comma separating them. For example  to
              see  config  file  messages and assembly loader messages set you
              mask to "asm,cfg".

       MONO_DEBUG
              If set, enables some features of the runtime useful  for  debug-
              ging.  It makes the runtime display the stack traces for all the
              threads running and exit when mono is interrupted  (Ctrl-C)  and
:
 print  some  additional messages on error conditions. It may not
              exit cleanly. Use at your own risk.

       MONO_DISABLE_AIO
              If set, tells mono NOT to attempt using native asynchronous  I/O
              services.  In that case, the threadpool is used for asynchronous
              I/O on files and sockets.

       MONO_DISABLE_SHM
              If this variable is set, it disables the shared memory  part  of
              the  Windows  I/O  Emulation  layer, and handles (files, events,
              mutexes, pipes) will not be shared  across  processes.   Process
              creation  is  also  disabled.   This option is only available on
              Unix.

       MONO_EGD_SOCKET
              For platforms that do not otherwise have a way of obtaining ran-
              dom bytes this can be set to the name of a file system socket on
              which an egd or prngd daemon is listening.

       MONO_EXTERNAL_ENCODINGS
              If set, contains a colon-separated list of text encodings to try
              when  turning externally-generated text (e.g. command-line argu-
:

 ments or filenames) into Unicode.  The encoding names come  from
              the   list   provided   by   iconv,   and   the   special   case
              "default_locale" which refers to the  current  locale's  default
              encoding.

              When  reading  externally-generated  text strings UTF-8 is tried
              first, and then this list is tried in order with the first  suc-
              cessful  conversion  ending  the  search.  When writing external
              text (e.g. new filenames or  arguments  to  new  processes)  the
              first  item  in  this  list is used, or UTF-8 if the environment
              variable is not set.

       MONO_MANAGED_WATCHER
              If set to any value, System.IO.FileSystemWatcher  will  use  the
              default  managed  implementation (slow). If unset, mono will try
              to use FAM under Unix systems and native API calls  on  Windows,
              falling back to the managed implementation on error.

       MONO_PATH
              Provides  a search path to the runtime where to look for library
              files.  Directories are separated by the platform path separator
              (colons        on        unix).       Example:       /home/user-
              name/lib:/usr/local/mono/lib
:
 MONO_GAC_PREFIX
              Provides a prefix the runtime uses to look for  Global  Assembly
              Caches.   Directories are separated by the platform path separa-
              tor (colons on unix). MONO_GAC_PREFIX should point  to  the  top
              directory of a prefixed install. Or to the directory provided in
              the    gacutil    /gacdir    command.    Example:    /home/user-
              name/.mono:/usr/local/mono/

       MONO_SHARED_DIR
              If  set  its  the  directory  where  the ".wapi" handle state is
              stored.  This is the directory where the Windows  I/O  Emulation
              layer  stores  its  shared  state  data (files, events, mutexes,
              pipes).  By default Mono will store the ".wapi" directory in the
              users's home directory.

FILES
       On  Unix assemblies are loaded from the installation lib directory.  If
       you set `prefix' to /usr, the assemblies will be located  in  /usr/lib.
       On Windows, the assemblies are loaded from the directory where mono and
       mint live.

       /etc/mono/config, ~/.mono/config
 Mono runtime configuration file.  See the  mono-config(5)  manual  page
       for more information.

MAILING LISTS
       Visit http://mail.ximian.com/mailman/mono-list for details.

WEB SITE
       Visit: http://www.go-mono.com for details

SEE ALSO
       mcs(1),mint(1),monodis(1),mono-config(5).

       For ASP.NET-related documentation, see the xsp(1) manual page

                                                                Mono(Mono 1.0)
(END)


--
::::::^^::::::::.'   | ./ ||`\       |
:::::::::::::::/ `-. |/._ ||  \
::::::::::::::|      ||   ||   \
 ~~=~_~^~ =~ \~~~~~~~'~~~~'~~~~/~~`` ~=~^~
~^^~~-=~^~ ^ `--------------'~^~=~^~_~^=~^~
※ 来源:·荔园晨风BBS站 bbs.szu.edu.cn·[FROM: 192.168.25.57]


[回到开始] [上一篇][下一篇]

荔园在线首页 友情链接:深圳大学 深大招生 荔园晨风BBS S-Term软件 网络书店