		    Open Runtime Platform (ORP)

			     Introduction

The URL for ORP is http://intel.com/research/mrl/library/orp

Intel's ORP is an Open Source research platform for investigating
dynamic compilation and garbage collection technologies.  ORP
implements support for executing type-safe bytecode.  This release can
run many of the applications compiled for a Java* Virtual Machine.
The runtime environment is supported by GNU Classpath libraries
(http://www.classpath.org).

ORP contains well-separated modules, Virtual Machine (VM),
Just-In-Time compiler (JIT) and Garbage Collection (GC).  A major
feature of the ORP is the definition of two internal interfaces:
JIT/VM and GC/VM.  These interfaces cleanly separate dynamic
recomplation and also garbage collection modules from the remaining
virtual machine.  This structure allows university and industry
researchers the ability to focus on specific areas of interest without
the overhead of learning the entire system.

The ORP compiles under g++ and runs on Linux.  It also compiles under
Microsoft VC++ 6.0 and runs on Windows 2000/NT4.0.  The initial web
posting contains both Linux makefiles and Windows project files.  ORP
is written in C/C++ and has a small amount of OS portable assembly.
This first posting contains only IA32 code.  At a later date, IA64
code for both Windows and Linux may be posted.

ORP contains two JITs.  The O1 JIT generates code quickly and can
provide dynamic feedback to the O3 JIT which can recompile/reoptimize
a method for faster execution.  Also, several garbage collectors are
provided.  A moving generational collector as well as a non-moving
collector.

More information is provided in the faq.html file included in the ORP
distribution and in the docs directory of the distribution.


			       Feedback

To sign up for a mailing list for ORP, send e-mail to
orp-subscribe@yahoogroups.com.  This list can be used to ask
questions, submit bugs, post patches, and exchange experiences between
ORP users.  Mailing list archives are available at
http://groups.yahoo.com/group/orp.


		      What works/does not work.

- Network: Simple networking works
- GC: multiple collectors work (generational, copying, non-moving).
- Class unloading does not work
- JNI invocation API is not implemented
- No multiplatform configuration utility (only Linux/FreeBSD makefiles
  and Visual C++ project files are provided) 
- Many native methods required to support GNU Classpath have been
  written to support both Linux and NT.


		      How to build ORP on Linux

We have tested our system on, 
	Red Hat Linux 6.1/6.2/7.0/7.1, with 
	kernel 2.2.12/2.2.14/2.4.0/2.4.2/2.4.6-ac2, 
	gcc 2.91.66/2.95.2/2.96.81/3.0, 
	glibc 2.1.3/2.2.2/2.2.3,
    binutils 2.10.91.0/2.9.5.0 .
From the top-level directory,  type: 'make dbg', or 'make opt' 
to build the debug or optimized versions of ORP respectively.  
The resulting executable will be in the file mains/orp/Linux/dbg/orp 
or mains/orp/Linux/opt/orp respectively.

		How to build ORP on Microsoft Windows

We have tested our system on Windows 2000 with Visual C++ (VC++) 6.0
and on Windows NT 4.0 with VC++ 5.0 and 6.0.

Open the file mains/nt_build/nt_builds.dsw with VC++.  Make sure that
"ORP" is the active project (menu: "Project"-->"Set Active Project").
Choose one of supported configurations, "ORP Win32 Debug" or "ORP
Win32 Release" (menu: "Build"-->"Set Active Configuration").  Build
ORP (menu: "Build"-->"Build orp.exe").


			    How to run ORP

You will need the GNU Classpath library.  It can be downloaded from
http://www.classpath.org.  Get a snapshot no older than September 1,
2000. You can also get nightly tarball of Gnu Classpath CVS tree at
http://savannah.gnu.org/cvs.backups/classpath.tar.gz.  

Build GNU Classpath as instructed in INSTALL and HACKING files, it is quite
straightforward if you are in a Linux system with GNU build tools installed.
For people who can't make it as above, please refer to the info in ORP mailling
 list, e.g.,
    http://groups.yahoo.com/group/orp/messages/152;
    http://groups.yahoo.com/group/orp/messages/330;
    http://groups.yahoo.com/group/orp/messages/333.

Be noticed that ORP can run with both its own builtin native library, and
GNU Classpath native library. By default, it is built with builtin library.
For people who want to play with GNU Classpath native library, they can simply
rebuild ORP with NON_ORP_NATIVE_LIBS defined. Of course, the required library
should be built and installed correctly.
 
			   Running on Linux

Assume that the installed Classpath directory is /classpath
You can run applications with the following arguments, '.' means current 
working directory:
orp -classpath /classpath:. <app> <args>
E.g.,
orp -classpath /classpath:. HelloWorld

			  Running on Windows

Assume that the installed Classpath directory is c:\classpath
You can run applications with the following arguments:
orp -classpath c:\classpath;. <app> <args>
E.g.,
orp -classpath  c:\classpath;. HelloWorld

Note that the path separator is ':' on Linux and ';' on Windows.  The
class files must be regular files in a directory tree, not a .zip
archive.

		 Other useful command line arguments

			  Setting heap size
 -Xms<start heap size> -Xmx<max heap size>
 E.g., 
 -Xms40000k -Xmx80m
 -Xms40000000 -Xmx60000000

		     GC related options
 -verbosegc :  printing extra GC information
 -gc fixed  :  switch to a non-moving collector instead of the default
               generational collector.

			 Switching the JIT's
 The standard makefile builds ORP with two JIT's, O3 (optimizing
 compiler) and O1 (fast code generator).  The VM always tries to
 compile a method with O3 first and only if O3 fails to compile a
 method, O1 is used.  None of our JIT's is supposed to fail, so all
 methods end up being compiled with O3.  You can switch the order of
 the JIT's with the following command line option:
 -swapjit 0 1
 That way all methods will be compiled with O1.



* All other names and brands are the property of their respective
  owners.







