Provided by: ocaml-base-nox_3.12.1-2ubuntu2_amd64 bug

NAME

       ocamlrun - The Objective Caml bytecode interpreter

SYNOPSIS

       ocamlrun [ options ] filename argument ...

DESCRIPTION

       The  ocamlrun(1)  command  executes  bytecode  files  produced by the linking phase of the
       ocamlc(1) command.

       The first non-option argument is  taken  to  be  the  name  of  the  file  containing  the
       executable  bytecode.  (That  file  is  searched  in the executable path as well as in the
       current directory.) The remaining arguments are passed to the Objective Caml  program,  in
       the string array Sys.argv.  Element 0 of this array is the name of the bytecode executable
       file; elements 1 to n are the remaining arguments.

       In most cases, the bytecode executable files produced by the ocamlc(1) command  are  self-
       executable, and manage to launch the ocamlrun(1) command on themselves automatically.

OPTIONS

       The following command-line options are recognized by ocamlrun(1).

       -b     When the program aborts due to an uncaught exception, print a detailed "back trace"
              of the execution, showing where the exception was raised and which  function  calls
              were  outstanding  at  this  point.  The back trace is printed only if the bytecode
              executable contains debugging information, i.e. was compiled and linked with the -g
              option  to  ocamlc(1)  set.  This option is equivalent to setting the b flag in the
              OCAMLRUNPARAM environment variable (see below).

       -I dir Search the directory dir for  dynamically-loaded  libraries,  in  addition  to  the
              standard  search  path.  -p Print the names of the primitives known to this version
              of ocamlrun(1) and exit.

       -v     Direct the memory manager to print verbose messages on  standard  error.   This  is
              equivalent to setting v=63 in the OCAMLRUNPARAM environment variable (see below).

       -version
              Print version string and exit.

       -vnum  Print short version number and exit.

ENVIRONMENT VARIABLES

       The following environment variable are also consulted:

       CAML_LD_LIBRARY_PATH
              Additional directories to search for dynamically-loaded libraries.

       OCAMLLIB
              The  directory containing the Objective Caml standard library.  (If OCAMLLIB is not
              set, CAMLLIB will be used instead.) Used to locate the ld.conf  configuration  file
              for  dynamic  loading.  If not set, default to the library directory specified when
              compiling Objective Caml.

       OCAMLRUNPARAM
              Set  the  runtime  system  options  and   garbage   collection   parameters.    (If
              OCAMLRUNPARAM  is  not set, CAMLRUNPARAM will be used instead.)  This variable must
              be a sequence of parameter specifications.  A parameter specification is an  option
              letter followed by an = sign, a decimal number (or a hexadecimal number prefixed by
              0x), and an optional multiplier.  There are nine options, six of  which  correspond
              to the fields of the control record documented in The Objective Caml user's manual,
              chapter "Standard Library", section "Gc".

       b      Trigger the printing of a stack backtrace when an  uncaught  exception  aborts  the
              program.  This option takes no argument.

       p      Turn on debugging support for ocamlyacc-generated parsers.  When this option is on,
              the pushdown automaton that executes the parsers prints a  trace  of  its  actions.
              This option takes no argument.

       a (allocation_policy)
              The  policy  used  for allocating in the OCaml heap.  Possible values are 0 for the
              next-fit policy, and 1 for the first-fit policy.  Next-fit is somewhat faster,  but
              first-fit is better for avoiding fragmentation and the associated heap compactions.

       s (minor_heap_size)
              The size of the minor heap (in words).

       i (major_heap_increment)
              The default size increment for the major heap (in words).

       o (space_overhead)
              The major GC speed setting.

       O (max_overhead)
              The heap compaction trigger setting.

       l (stack_limit)
              The limit (in words) of the stack size.

       h      The initial size of the major heap (in words).

       v (verbose)
              What  GC  messages  to  print to stderr.  This is a sum of values selected from the
              following:

              0x001 Start of major GC cycle.

              0x002 Minor collection and major GC slice.

              0x004 Growing and shrinking of the heap.

              0x008 Resizing of stacks and memory manager tables.

              0x010 Heap compaction.

              0x020 Change of GC parameters.

              0x040 Computation of major GC slice size.

              0x080 Calling of finalisation functions.

              0x100 Startup messages (loading the  bytecode  executable  file,  resolving  shared
              libraries).

              The  multiplier  is  k,  M or  G,  for  multiplication  by  2^10,  2^20,  and  2^30
              respectively.  For example, on a 32-bit machine  under  bash,  the  command  export
              OCAMLRUNPARAM='s=256k,v=1'  tells  a  subsequent  ocamlrun to set its initial minor
              heap size to 1 megabyte and to print a message at the start of each major GC cycle.

       CAMLRUNPARAM
              If OCAMLRUNPARAM is not found in the environment, then CAMLRUNPARAM  will  be  used
              instead.  If CAMLRUNPARAM is not found, then the default values will be used.

       PATH   List of directories searched to find the bytecode executable file.

SEE ALSO

       ocamlc(1).
       The Objective Caml user's manual, chapter "Runtime system".

                                                                                      OCAMLRUN(1)