File:  [gforth] / gforth / doc / vmgen.texi
Revision 1.1: download - view: text, annotated - select for diffs
Thu May 16 09:07:29 2002 UTC (20 years, 8 months ago) by anton
Branches: MAIN
CVS tags: HEAD
changed mailing list address in README
started working on vmgen documentation

    1: @include version.texi
    3: @c @ifnottex
    4: This file documents vmgen (Gforth @value{VERSION}).
    6: @section Introduction
    8: Vmgen is a tool for writing efficient interpreters.  It takes a simple
    9: virtual machine description and generates efficient C code for dealing
   10: with the virtual machine code in various ways (in particular, executing
   11: it).  The run-time efficiency of the resulting interpreters is usually
   12: within a factor of 10 of machine code produced by an optimizing
   13: compiler.
   15: The interpreter design strategy supported by vmgen is to divide the
   16: interpreter into two parts:
   18: @itemize @bullet
   20: @item The @emph{front end} takes the source code of the language to be
   21: implemented, and translates it into virtual machine code.  This is
   22: similar to an ordinary compiler front end; typically an interpreter
   23: front-end performs no optimization, so it is relatively simple to
   24: implement and runs fast.
   26: @item The @emph{virtual machine interpreter} executes the virtual
   27: machine code.
   29: @end itemize
   31: Such a division is usually used in interpreters, for modularity as well
   32: as for efficiency reasons.  The virtual machine code is typically passed
   33: between front end and virtual machine interpreter in memory, like in a
   34: load-and-go compiler; this avoids the complexity and time cost of
   35: writing the code to a file and reading it again.
   37: A @emph{virtual machine} (VM) represents the program as a sequence of
   38: @emph{VM instructions}, following each other in memory, similar to real
   39: machine code.  Control flow occurs through VM branch instructions, like
   40: in a real machine.
   42: In this setup, vmgen can generate most of the code dealing with virtual
   43: machine instructions from a simple description of the virtual machine
   44: instructions (@pxref...), in particular:
   46: @table @emph
   48: @item VM instruction execution
   50: @item VM code generation
   51: Useful in the front end.
   53: @item VM code decompiler
   54: Useful for debugging the front end.
   56: @item VM code tracing
   57: Useful for debugging the front end and the VM interpreter.  You will
   58: typically provide other means for debugging the user's programs at the
   59: source level.
   61: @item VM code profiling
   62: Useful for optimizing the VM insterpreter with superinstructions
   63: (@pxref...).
   65: @end table
   67: VMgen supports efficient interpreters though various optimizations, in
   68: particular
   70: @itemize
   72: @item Threaded code
   74: @item Caching the top-of-stack in a register
   76: @item Combining VM instructions into superinstructions
   78: @item
   79: Replicating VM (super)instructions for better BTB prediction accuracy
   80: (not yet in vmgen-ex, but already in Gforth).
   82: @end itemize
   84: As a result, vmgen-based interpreters are only about an order of
   85: magintude slower than native code from an optimizing C compiler on small
   86: benchmarks; on large benchmarks, which spend more time in the run-time
   87: system, the slowdown is often less (e.g., the slowdown over the best JVM
   88: JIT compiler we measured is only a factor of 2-3 for large benchmarks
   89: (and some other JITs were slower than our interpreter).
   91: VMs are usually designed as stack machines (passing data between VM
   92: instructions on a stack), and vmgen supports such designs especially
   93: well; however, you can also use vmgen for implementing a register VM and
   94: still benefit from most of the advantages offered by vmgen.
   96: @section Why interpreters?

FreeBSD-CVSweb <>