ORP Beginner's Frequently Asked Questions (ORP-FAQ)

1. General Information

1.1 What's ORP?

ORP stands for Open Runtime Platform, which is an Intel’s Open Source research platform for investigating dynamic compilation and memory management technologies. The basic ORP system incorporates a fast code generating JIT (Just-In-Time) as well as an optimizing JIT. It also includes several GC (Garbage Collection) algorithms, ranging from a simple mark-sweep algorithm to an advanced train algorithm.

1.2 What can ORP do?

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 doesn't interpret the bytecode and there is no AWT support.

1.3 Where can I get ORP?

Intel invites the academic and open source communities to participate in the evolution of the mentioned technologies. ORP source code can be downloaded from Intel's web URL: http://intel.com/research/mrl/orp/ . Notice that one must accept "Intel License Agreement For the Open Runtime Platform (ORP)" before the downloading.

1.4 Are there any documents about the ORP?

Limited documentation is distributed with ORP in the docs directory. Included are the GC Writer's Guide and a brief description of the JIT interface.

In addition, Intel Microprocessor Research Labs (MRL) has a list of academic papers (not available online) on these topics at http://www.intel.com/research/mrl/library/java-pubs.htm. Some talks are available at http://intel.com/research/mrl/library/index.htm .

We have three research papers describing the IA32 version of ORP. They are all available through ACM. The papers are:

Michal Cierniak, Guei-Yuan Lueh and James Stichnoth. "Practicing JUDO: Java Under Dynamic Optimizations," In Proceedings of the SIGPLAN'00 Conference on Programming Language Design and Implementation (PLDI), Vancouver B.C., Canada, June, 2000.

James Stichnoth, Guei-Yuan Lueh, and Michal Cierniak. "Support for Garbage Collection at Every Instruction in a Java Compiler," In Proceedings of the SIGPLAN '99 Conference on Programming Language Design and Implementation (PLDI), Atlanta, GA, May 1999.

Ali-Reza Adl-Tabatabai, Michal Cierniak, Guei-Yuan Lueh, Vishesh M. Parikh and James Stichnoth. "Fast, Effective Code Generation in a Just-In-Time Java Compiler," In Proceedings of the SIGPLAN '98 Conference on Programming Language Design and Implementation (PLDI), Montreal, Canada, June 1998.

While the IA64 version of ORP has not been released yet, you may also find a set of slides titled at "Java on IA64" available at http://intel.com/research/mrl/library/index.htm. We have also published the following paper about implementing GC on IA64:

Richard L. Hudson, J. Eliot B. Moss, Sreenivas Subramoney and Weldon Washburn. "Cycles To Recycle: Garbage Collection On the IA-64". In Proceedings of the International Symposium on Memory Management, Minneapolis, MN, October 2000.

1.5 Where to get more information?

There is a ORP mailing-list at “Yahoo! Groups”. To subscribe, please send a blank mail to orp-subscribe@yahoogroups.com. To read the list archive, click: http://groups.yahoo.com/group/orp. You can also get information at ORP’s official web URL: http://intel.com/research/mrl/orp.

1.6 How does ORP compare to other JVMs like Japhar, or Kaffe?

We have not looked at other open source JIT's, so we can't comment on differences. Here are some interesting preliminary performance result posted by ORP users: http://groups.yahoo.com/group/orp/message/96, http://www.egroups.com/message/orp/23, and http://www.egroups.com/message/orp/18. Kazuyuki Shudo has compared performance of many systems for a wide range of benchmarks, his results are available at http://www.shudo.net/jit/perf.

2. Building and running ORP

2.1 What platforms does ORP support?

Now ORP can be built and running on two platforms: Linux with gcc and Microsoft Windows 2000/NT with VC++ 5.0/6.0, both for IA-32 and IA-64. There is no current active XScale port, however the vast majority of machine dependent issues have already been addressed in an ia64 port that we intend to release shortly. Porting ORP to XScale should be fairly straightforward.

ORP user is trying to port it to any POSIX compliant OS that has gcc and GNU make. Please see detail at .

2.2 How to build ORP on Linux?

ORP has been tested on Red Hat Linux 6.1/6.2/7.0/7.1 with various versions of linux kernel, glibc/linuxthreads, gcc and binutils.

After you get the ORP source code, extract it into a working directory. In that directory, type "make". That will build two running versions of ‘ORP’, the one under mains/orp/Linux/dbg/ is the debug version (compiled with –g –O0 options), and under mains/orp/Linux/opt/ is the optimized version (compiled with –O). You can also use ‘make dbg’ or ’make opt’ to get the respective version.

If you want the debug version to dump the JIT process, please add -DDUMP_JIT definition for variable DBG_CPPFLAGS in file mains/orp/Makefile and mains/orp/MakeInclude. And you can add -DORP_STATS in the same places to make a debug version that prints runtime statistic information when you run orp with "-stats 1" option.

Please notice that ORP version 1.0.6 and above supports unmodified latest GNU Classpath(see 2.4 How to run ORP) from their website. On the other hand, the default ORP build does not support previous GNU Classpath binaries provided by ORP users. But you can build ORP with OLD_VERSION_CLASSPATH defined to support the old binaries.

2.3 How to build ORP on Microsoft Windows?

ORP has been tested on Windows 2000 with Visual C++ (VC++) 6.0 and on Windows NT 4.0 with VC++ 5.0 and 6.0.

After you get the ORP source code, extract it into a working directory, which we use $ORP to represent. Open the file $ORP/mains/nt_build/nt_builds.dsw within 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"), then build ORP (menu: "Build"-->"Build orp.exe").

Please notice that ORP version 1.0.6 and above supports unmodified latest GNU Classpath(see 2.4 How to run ORP) from their website. On the other hand, the default ORP build does not support previous GNU Classpath binaries provided by ORP users. But you can build ORP with OLD_VERSION_CLASSPATH defined to support the old binaries.

2.4 How to run ORP?

ORP needs GNU Classpath library to run, which can be downloaded from http://www.classpath.org, both 0.01 and 0.02 releases are supported. But we recommend you get the latest snapshot from their CVS tree; or simply download the nightly tarball of their CVS tree at http://savannah.gnu.org/cvs.backups/classpath.tar.gz, then checkout the classpath module with cvs commands.

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 some helpful 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(by uncommenting the definition mains/orp/Makefile and mains/orp/MakeInclude). Of course, the required GNU native library should be built and installed correctly.
With ORP version 1.0.5 or earlier versions, you need extra steps to make the Classpath work with it. That is, before compiling Classpath, you should modify java/lang/Thread.java to add one extra field. ORP those versions relies on the existence of that field. That field must be the first field in the class definition, i.e.:

		public class Thread {
		    private Object data; //added for ORP 1.0.5 or before
		    ...  //orginal 
		}

Pre-compiled binaries for ORP 1.0.5 and earlier versions is available, see http://groups.yahoo.com/group/orp/messages/73 for more information.

2.5 How to run ORP on Linux?

Assume that you have read the question “How to run ORP”, the installed Gnu Classpath directory is $CLASSPATH, and your java application’s path is $APP_PATH, you can run it with the following arguments:

orp -classpath $CLASSPATH:$APP_PATH <app> <args>
E.g., when $CLASSPATH is /Classpath, and $APP_PATH is the current path,

2.6 How to run ORP on Windows?

Assume that you have read the question “How to run ORP”, the installed Gnu Classpath directory is %CLASSPATH%, and your java application’s path is %APP%, you can run it with the following arguments in command prompt:

E.g., when %CLASSPATH% is c:\classpath, and %APP% is the current path,

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.

2.7 What are the command options?

ORP has some command options, they are:

-classpath <classpath> : to specify your installation path of GNU Classpath

-ms <initial heap size> -mx <max heap size> : to specify the heap size

-verbosegc : print extra GC information

-gc fixed : switch to a non-moving collector instead of the default generational one

-swapjit 0 1 : to swap the order of JITs to be used.

3. ORP Internals

3.1 What are the major optimization strategies used in the O3 JIT compiler?

O3 performs the following optimizations,

Local CSE (extended basic block)

Copy and type propagation

Constant folding

Dead code elimination

Bounds checking elimination

Loop invariants hoisting

Inlining

Floating-point stack optimization

Tail-recursion elimination

Some local optimizations are also used, but not listed here.

3.2 Does the ORP take advantage of IA-32 architectural optimizations such as automatic vectorization, SSE, and SSE-2?

The optimizations built into ORP are decided by the benchmarks. It was our opinion that current Java benchmarks would not benefit from all the multimedia instructions. That will certainly change over time and then adding support for SSE will make sense. One problem is that GNU Classpath doesn't currently support AWT. That presumably rules out most of the multimedia oriented benchmarks.

3.3 How does the O3 JIT compare to other optimizing compilers like Microsoft Visual C++, or GCC?

We don't compare the O3 JIT with C++ or GCC compilers. It is not a fair comparison because programmers tend to write different style programs, e.g., object-oriented vs. c-style, using different languages. The O3 JIT does not do expensive (in terms of compilation time) optimizations:

Code scheduling: we rely on the hardware (Out-Of-Order) to take care of it

Common Subexpression: tend to increase register pressure

Partial Redundancy Elimination: tend to increase register pressure

Vectorization

4. License Issue

4.1 What is the license that ORP uses? Is it GPL?

No, ORP uses a BPL-like license(FreeBSD uses BPL), which gives much freedom to its users. For the license official text, see http://intel.com/research/mrl/orp/orplicense3.htm.

4.2 Can ORP or ORP-based product be sold for money ?

ORP has a BPL-like license. Please consult your attorney for legal advice.

4.3 Can modified ORP binary be distributed without providing any sources ?

Yes.

5. Misc Questions

5.1 How about the history of ORP?

ORP project was started in 1997. The bulk of the code was completed by the end of 1999. Since then main efforts have been focused on the IA64 implementation, but the IA32 version is still being actively maintained.

5.2 Does ORP support Microsoft .NET?

Not at this time.

5.3 Why size of the executable of ORP is so big?

It’s quite natural since the standard ORP binary includes the complete system with both JIT's and all our native methods for standard libraries.

5.4 How far away is ORP from being a commercial grade JVM?

What we have distributed is only tested in a research environment. You should not expect to run mission-critical apps on it today. The research lab roots are one of the reasons, because we don't have an army of testers running regressions on it. On the other hand, we have no opinion on using ORP in a commercial product.

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