Annotation of gforth/doc/vmgen.texi, revision 1.1
1.1 ! anton 1: @include version.texi
! 2:
! 3: @c @ifnottex
! 4: This file documents vmgen (Gforth @value{VERSION}).
! 5:
! 6: @section Introduction
! 7:
! 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.
! 14:
! 15: The interpreter design strategy supported by vmgen is to divide the
! 16: interpreter into two parts:
! 17:
! 18: @itemize @bullet
! 19:
! 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.
! 25:
! 26: @item The @emph{virtual machine interpreter} executes the virtual
! 27: machine code.
! 28:
! 29: @end itemize
! 30:
! 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.
! 36:
! 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.
! 41:
! 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:
! 45:
! 46: @table @emph
! 47:
! 48: @item VM instruction execution
! 49:
! 50: @item VM code generation
! 51: Useful in the front end.
! 52:
! 53: @item VM code decompiler
! 54: Useful for debugging the front end.
! 55:
! 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.
! 60:
! 61: @item VM code profiling
! 62: Useful for optimizing the VM insterpreter with superinstructions
! 63: (@pxref...).
! 64:
! 65: @end table
! 66:
! 67: VMgen supports efficient interpreters though various optimizations, in
! 68: particular
! 69:
! 70: @itemize
! 71:
! 72: @item Threaded code
! 73:
! 74: @item Caching the top-of-stack in a register
! 75:
! 76: @item Combining VM instructions into superinstructions
! 77:
! 78: @item
! 79: Replicating VM (super)instructions for better BTB prediction accuracy
! 80: (not yet in vmgen-ex, but already in Gforth).
! 81:
! 82: @end itemize
! 83:
! 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).
! 90:
! 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.
! 95:
! 96: @section Why interpreters?
! 97:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>