<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  <link rel="stylesheet" href="http://llvm.org/llvm.css" type="text/css" media="screen" />
  <title>Fostering Systems Research with Managed Runtimes</title>
</head>
<body>

<div class="pub_title">
  Fostering Systems Research with Managed Runtimes
</div>
<div class="pub_author">
  Nicolas Geoffray
</div>

<h2>Abstract:</h2>
<blockquote>
Many systems research projects now target managed runtime environments (MRE)
because they provide better productivity and safety compared to native
environments. Still, developing and optimizing an MRE is a tedious
task that requires many years of development. Although MREs share some common
functionalities, such as a Just In Time Compiler or a Garbage Collector, this
opportunity for sharing has not been yet exploited in implementing MREs.
This thesis describes and evaluates VMKit, a first attempt to build a common
substrate that eases the development and experimentation of high-level MREs and 
systems mechanisms. VMKit has been successfully used to build two MREs,
a Java Virtual Machine and a Common Language Runtime, as well as a a new system
mechanism that provides better security in the context of service-oriented
architectures.

We describe the lessons learnt in implementing such a common
infrastructure from a performance and an ease of development standpoint.
The performance of VMKit are reasonable compared to industrial MREs, and 
the high-level MREs are only 20,000 lines of code. Our new system
mechanism only requires the addition of 600 lines of code in VMKit, and 
is a significant step towards better dependable systems.

</blockquote>

<h2>Bibtex:</h2>
<pre>
@PhdThesis{geoffray:phd,
        author = {N. Geoffray},
        title = { Fostering Systems Research with Managed Runtimes },
        schoold = {Universit\'e Pierre et Marie Curie},
        year = {2009},
        address = {Paris, France},
        month = {September},
}
</pre>

<h2>Download:</h2>
<ul>
  <li><a href="http://pagesperso-systeme.lip6.fr/Nicolas.Geoffray/these-geoffray.pdf">Fostering Systems Research with Managed Runtimes</a> (PDF)</li>
</ul>

</body>
</html>
