Man Linux: Main Page and Category List


       jocamlrun - The JoCaml bytecode interpreter


       jocamlrun [ -v ] filename argument ...


       The  jocamlrun(1)  command  executes  bytecode  files  produced  by the
       linking phase of the jocamlc(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 jocamlc(1)
       command are self-executable, and  manage  to  launch  the  jocamlrun(1)
       command on themselves automatically.


       The following command-line option is recognized by jocamlrun(1).

       -v     When set, the memory manager prints verbose messages on standard
              error to signal garbage collections and heap extensions.


       The following environment variable are also consulted:

              Set the 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, and an optional  multiplier.   There  are  seven

       b (backtrace)
              Print a stack backtrace in case of an uncaught exception.

       s (minor_heap_size)
              Size of the minor heap.

       i (major_heap_increment)
              Minimum size increment for the major heap.

       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:

       1      Start of major GC cycle.

       2      Minor collection and major GC slice.

       4      Growing and shrinking of the heap.

       8      Resizing of stacks and memory manager tables.

       16     Heap compaction.

       32     Change of GC parameters.

       64     Computation of major GC slice size.

       128    Calling of finalisation function.

       256    Startup messages.

              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  jocamlrun to set its initial minor heap size to 1
              megabyte and to print a message at the start of  each  major  GC

       PATH   List  of  directories  searched  to find the bytecode executable


       The Objective Caml users manual, chapter "Runtime system".