@techreport{TR-IC-01-03,
  number = {IC-01-03},
  author = {R. Ferreira and G. Araújo},
  title = {Context-Based {JIT} Compilation: {The} Design \& Implementation of a Distributed {JVM}},
  month = {March},
  year = {2001}, 
  institution = {Institute of Computing, University of Campinas},
  note = {In English, 193 pages.
    \par\selectlanguage{english}\textbf{Abstract}
      \emph{Just-In-Time} (JIT) compilation is a well-known technique
      used to improve the execution time in the \emph{Java Virtual
      Machine} (JVM). However, the amount of time used by the JIT
      internals degrades, in many cases, the application execution
      time. Some techniques have been used to decrease the JIT
      overhead, while still keeping its effectiveness. However, the
      trade-off between the JIT running time and its object code
      execution time will always exist. From our observation, an
      end-user Java Virtual Machine deals with the same code most of
      its time. Users always launch the same applications which are
      typically composed of the same set of classes. On the other
      hand, in big companies, dozens, or even hundreds of employees
      share the same application or application suite. Usually, they
      are connected under the same fast and secure \emph{Intranet}. In
      this scenario, the per-user JIT effort is repetitive and largely
      greater than the strictly required. The goal of our work is to
      detach linking activities from the JVM to a shared server, on a
      distributed fashion. By doing that, the client JVM turns to be a
      very simple piece of software that runs Java code natively, not
      requiring a JIT or interpreter. All complex linking activities
      --- like link-time error checking, \emph{class file}
      verification and JIT compilation --- are done by the server
      which caches its responses. This document is a description of an
      alternate implementation of the Java Virtual Machine that
      inovates. It covers specially: techniques for detecting and
      caching repetitive link-time contexts; an alternate, off-line,
      bytecode verification procedure; the design and implementation
      of a Java specific intermediate representation; and the detailed
      description of many JVM implementation issues.
  }
}