web/runtime

   1 * The MonoNet runtime
   2
   3         The MonoNet runtime will implement the JIT engine (and a byte
   4         code interpreter for quickly porting to new systems), the
   5         class loader, the garbage collector, threading system and
   6         metadata access libraries.
   7
   8         Currently the runtime contains the beginning of an image
   9         loader and metadata access entry points.  Since Beta2 has been
  10         now released, it is possible to resume work using the ECMA
  11         specs and testing with Beta2-generated executables.
  12
  13         The runtime core will be implemented in C, in a library
  14         "libMonoVES.so".
  15
  16 ** Executing MSIL/CIL images
  17
  18         The code will load an executable and map the references to
  19         external assemblies to our own version of the assemblies on
  20         GNU/Linux.
  21
  22         Our roadmap looks like this:
  23
  24                 * Milestone 1: Fully read and parse all CIL byte-codes
  25                   and metadata tokens (ie, a disassembler).
  26
  27                 * Milestone 2: Complete an interpreter for CIL byte
  28                   codes.  This interpreter can be used temporarly to
  29                   run CIL byte code on a system where no JIT is
  30                   available.
  31
  32                 * Milestone 3: IA32 translating-JIT engine.
  33
  34                 * Milestone 4: non-Intel port of the JIT engine.
  35
  36                 * Milestone 5: Optimizing JIT engine port for IA32.
  37
  38                 * Milestone 6: non-Intel port of the Optimizing JIT
  39                   engine.
  40
  41         A setup similar to the Kaffe JIT engine can be used to
  42         layout the code to support non-IA32 architectures.  Our work
  43         will be focused on getting a IA32 version running first.
  44
  45         The JIT engine should work on Linux and Win32, although you
  46         might need to install the CygWin32 development tools to get a
  47         Unix-like compilation environment which is what we know how to
  48         use.
  49
  50 ** Garbage Collection
  51
  52         We have decided to implement a tracing garbage collector,
  53         which is very similar to the one being used by .NET.  For an
  54         introduction to the garbage collection system used by
  55         Microsoft's CLR implementation, you can read this book on <a
  56         href="http://www.amazon.com/exec/obidos/ASIN/0471941484/o/qid=992556433/sr=2-1/ref=aps_sr_b_1_1/103-5866388-0492603">Garbage
  57         Collection.</a>
  58
  59         Although using a conservative garbage collector like Bohem's
  60         would work, all the type information is available at runtime,
  61         so we can actually implement a better collector than a
  62         conservative collector.
  63
  64 ** PInvoke
  65
  66         PInvoke will be supported, and will be used to wrap Unix API
  67         calls, these in turn are required for reusing some of the
  68         GNOME libraries that will reduce the work we have to do to
  69         deliver a complete class library
  70