Tutorials to .com

Tutorials to .com » Jsp » Skills » On the development of JAVA VM

On the development of JAVA VM

Print View , by: iSee ,Total views: 26 ,Word Count: 5384 ,Date: Thu, 20 Aug 2009 Time: 10:03 PM

On the development of java VM
Jim Huang <jimchyun @ ccns.ncku.edu.tw>
<jserv @ kaffe.org>

Slightly finishing is the author of the java VM for the experience, to share with you, in the latter part of this article will focus on a number of
Open Source Java VM of the project, the author is KaffeVM [1] developer, very much hope that this article
Dear reader can help, but also look forward to your letter of advice, through technical exchanges, so that made a better KaffeVM
[1] http://www.kaffe.org/

■ JVM (Java Virtual Machine) and Java firmware

Java VM as a virtual platform, this hardware platform to be implemented, that is, after materialized, that is,
Java chip. To put it simply, it is a real CPU, if we do not need the full CPU complex
Design, it can be to face the same co-processor, so that does not need x86 or Sun Sparc
Java VM used to simulate, but directly to Java bytecode "fed" Java chip run. This
Sun is known as picoJava earlier technology, of course, with the input of the hardware and software vendors, the introduction of more complex
Miscellaneous technical, but in principle the concept is still the same.

"Analog" Since non-real, of course, in terms of efficiency than a disadvantage on, so regular people on the Java implementation of ultra-slow, super-power
Resources to the impression, in fact, that it is referring to the performance of Virtual Machine. In order to improve JVM performance, the use of many
Technology to speed up, the most important of which is the JIT (Just In Time) Compiler (Compiler timely pay attention to:
Not with the "instant" [realtime] mixed) and the HotSpot's dynamic, such as Adaptive Compiler
compilation technology.

Java Chip is Optimized for Java's OOP, exption-handling, memory / garbage
collection of special chip, and x86 (that is, the traditional CPU) and did not compile c + + by the machine
code in the new / exception-handling / memory allocation / late-binding support for hardware
The best of action.

Al VLSI thanks, memory allocation, as well as garabage collection action can be hardware
To implement. In the modem or the TV for the digital-to-analog conversion of the dsp (digital signal processing) chip in terms of
, There are the so-called bit-reverse (for the FFT [fast Fourier transform] used), as if the general x86
This action, at least more than 10 times slower. Another example is the previous floating-point operations, integer operations slower than the 20 to 30 times
, But with the emergence of floating-point accelerator, the speed of floating-point operations for integer operations 1.3 times!

JVM to the above mentioned forms of co-processor for the way it is, you can refer to Nazomi Communica -
tions [2] The company's products, they speed up the introduction of a Java chip, the product code-named JA108
Specifically for 2G/2.5G or 3G mobile phone use. Does not require additional memory, just the JA 208
IC implantation of the original system design can significantly enhance the efficiency of Java applications as much as 15 to 60 times more.
[2] http://www.nazomi.com/

Then, on my Pentium III in the operation of MS-Windows 2000 the following experiments: (source and
control of the machine code)

C++ + + the virtaul method calling:
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
│ 21: testx -> setx (20); / / testx is an indicator of object │
│ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │
│ 00401091 push 00000014 │
│ 00401093 mov eax, dword ptr [testx] │
│ 00401096 mov eax, dword ptr [eax] │
│ 00401098 mov ecx, dword ptr [testx] │
│ 0040109b call dword ptr [eax] │
└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
Instructions is not argument 4

c the general call:
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
│ good () │
│ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │
│ 0040109f call @ ILT +0 (? Good @ @ YAXH @ Z) (00401000) │
│ 004010a4 add esp, 00000004 │
└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
Instructions is not argument 2

java's virtual call:
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
│ my.getData (33); │
│ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │
│ aload_2 │
│ bipush 33 │
│ invokevirtual # 9 <Method my.getData(I)I> │
└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
Instructions is not argument 2.

c + + the constructor:
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
│ test * testx = new test (); │
│ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │
│ 00401056 push 00000008 │
│ 00401058 call?? 2 @ YAPAXI @ Z (00401184) │
│ 0040105d add esp, 00000004 │
│ 00401060 mov dword ptr [ebp-0c], eax │
│ 00401063 cmp dword ptr [ebp-0c], 00000000 │
│ 00401067 je main +00000030 (0040107d) │
│ 0040106d mov ecx, dword ptr [ebp-0c] │
│ 00401070 call @ ILT +15 (?? 0test @ @ QAE @ XZ) (0040100f) │
│ 00401075 mov dword ptr [testx], eax │
│ 00401078 jmp main +00000037 (00401084) │
│ 0040107d mov dword ptr [testx], 00000000 │
└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
11 instructions

C + + destructor:
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
│ delete testx; │
│ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │
│ 004010a7 mov eax, dword ptr [testx] │
│ 004010aa mov dword ptr [ebp-10], eax │
│ 004010ad mov eax, dword ptr [ebp-10] │
│ 004010b0 mov dword ptr [ebp-14], eax │
│ 004010b3 mov eax, dword ptr [ebp-14] │
│ 004010b6 push eax │
│ 004010b7 call?? 3 @ YAXPAX @ Z (00401194) │
│ 004010bc add esp, 00000004 │
└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
8 instructions

java's constructor:
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
│ my my1 = new my (); │
│ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │
│ new # 2 <Class my> │
│ invokenonvirtual # 11 <Method my. <init> () V> │
└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
2 instructions

This can be found on the dynamic allocation of objects in terms of the operation, Java an as long as a method call
machine code, but the need for x86 relative 4, which is Java in the instruction set level, the result of direct support.
We have a clear advantage of Java - ─ object code is very small, can easily be placed in the home appliance equipment resources embarrassment
China, along with many ready-made APIs available for calls, the use of inheritance, the code can be simple to play a strong

■ Execution Engine

Java VM is the implementation of the core engine, based on their Patterns of behavior of the definition of instruction set, JLS (Java Language
Specification) in detail when standardized bytecode instructions for the implementation of any action, but did not regulate how
Implementation, because this is really the responsibility of the author. Implementation period, implementation of the engine to the thread (thread) of the form
, So the thread can be literally translated bytecode or indirectly through the JIT Compiler to generate native code
Related actions, and then removed an opcode, or to return until the method threw exception. This part of
I do not intend to put too much because the market has been quite a lot of excellent books available for reference, included titles are as follows:

Explore the generality of the operating mechanism of Java VM:
1. "Java Virtual Machine" O'Reilly Publishing
Author: Jon Meyer & Troy Dwning
There is the Chinese translation: "Java Virtual Machine", by the authority of the domestic Java translation by Cai Yong Xue
2. "Inside the Java 2 Virtual Machine" McGraw-Hill Publishing
Author: Bill Venners
If you feel that on a too abstract, it Venners wrote this book, your appetite should be together, please read
Enclosed CD with the book, there is an interactive Java Applet's JVM to explain the concept of the book, the author's website [3]
Very rich data. Although the Chinese translation of this book this, but is strongly recommended not to spend the money wrongly, because the fallacy
[3] http://www.artima.com/insidejvm/resources/

Focus on the design of embedded JVM:
"In-depth embedded Java virtual machine-Inside KVM"
Author: Hu Wei Yue (Mango Hu)
Is almost the only face of the world to explore the implementation of the Java KVM books, is indeed a very valuable reference. But
Need to be borne in mind that the author dug directly in the source code of KVM, whether full delegation of authority, it is worth
Open to question.

■ Java VM to explore the effectiveness of

Commercial Java VM is currently the most outstanding performance of the BEA products are JRockit [4]. JRockit mainly
server-side application to do a lot of improvement, and Intel to assist the IA32 and IA64 platform the best, and
Thus, in the benchmark on a number of (SPECjbb and SPECjAppServer) on, JRockit lead
Warlords. BEA is a leading heavyweight j2ee technology vendors in the area of Enterprise In addition to superior technology
Operation, the course requires a strong high-performance Java VM, then bought BEA on JRockit, and in many high-end
Applications can see traces of JRockit VM. BEA Web site an article written by Joakim Dahlstedt text
Chapter on the Java VM performance can in fact be many people to break the glasses: [Java - A Slow
Language? It Depends on What You're Talking About] [5].
[4] http://www.jrockit.com/
[5] http://dev2dev.bea.com/products/wljrockit81/articles/Dahlstedt.jsp

Joakim Dahlstedt the background from time to time small, the JRockit VM is the main designer, the current BEA System
Inside of the Java Runtime Group chief technology officer, this article is not Pharaohcontrary, Joakim to
We understand that, to judge the Java VM "benchmark" (performance evaluation) approach needs to be adjusted, mainly based on
Under a few:

1. The general benchmark of comparison is only micro-benchmark level, can not be extended to system -
2. The way the software industry to develop a lot of changes, large-scale use of class library, framework,
application server, as well as Web services. Benchmark can only be invoked against the old one
Individual software stack, it can not carry out a comprehensive system-level analysis, such a measure of the
There are issues.
3.Java VM's own Dynamic Optimization, can be based on the most real data profiling adjustment
Components for the performance of its reorganization.
4. Finally, the new CPU architecture, such as Intel EPIC may be more suitable for Dynamic Optimization
Rather than the traditional static compiler. In the EPIC framework, compiler of the impact of the performance of
When, compiler has the responsibility to select the instruction set of parallel processing, rather than the traditional Pentium like to introduce an automatic
The out-of-order Out-of-order implementation of support, which means that the software dominates the performance of EPIC, which is
static compiler is detrimental, as can only be made from fixed bytecode Statistics and symbols, but
Failure of the real planning profiling.

Joakim conclusions give us a good source of inspiration:

"In conclusion, ..., but I hope I've convinced you that using runtime
systems like Sun Microsystems' HotSpot or BEA WebLogic JRockit Java
is not slow or inefficient, and that the performance of a large-scale
system built with Java may be superior to that of the same system
built using C. "

IBM was once the JDK is the best performance of the Java VM, but the Sun JDK 1. 4 performance with IBM JDK
1.3 considerable, and its server version of a more active use of JIT and the GC (Garbage Collection) technology, especially
Its application for the SMP to provide the most suitable for the hardware architecture and processing multi-threaded GC.

On the other hand, IBM internal research project of the Jalapeno JVM [6] to the results of Open Source award
The right to release JikesRVM program [7], provide a chance to test a number of technologies such as JIT and the GC parameters and algorithms
Test platform implementations. IBM Rearch as JIT will JikesRVM a research infrastru -
cture, listed on the site a wide range of papers can be found. I made reference to the direction of the research JikesRVM
That the development trend of JIT Compiler could be listed in the following:
1. Similar to Hotspot [8] integrated base interpreter, profiling, and adaptive
three compiler technology.
2. Dynamic profiling technology, from the simple evolution of counter-based algorithm to
performance monitoring event.
3. The application of more aggressive static compiler compiler technology (JIT Compiler to run,
Compile-time is a minor problem), resulting in the best of native code (native code).
4. The application of inter-procedural analysis, such as escape analysis can remove synchro -
nization and implementation of stack allocation.
5. Reference information obtained Runtime (primarily metadata and dynamic allocation), the middle class
Health optimized native code.

[6] http://www.research.ibm.com/jalapeno/
[7] http://www-124.ibm.com/developerworks/oss/jikesrvm/
[8] http://java.sun.com/products/hotspot/

Next, we take a look at Sun's Hotspot technology. Hotspot mentioned I can not help mentioning Henry Massalin
The pioneer, Henry's doctoral dissertation in the Java Glossary explanation HotSpot [9] as
"the mother of all self-modifying code", at the same time, HotSpot is also "builds heavily
on work done in a PhD thesis by Henry Massalin ".

[9] http://mindprod.com/jgloss/hotspot.html

Java implementation of the first through the interpreter (interpreter), but Java does not mean that they must be interpreted
Line. Early Java VM is the interpretation of each instruction, so performance is far from being satisfactory, so the introduction of
JIT and other key technologies, and HotSpot can be said that the next generation of JIT. Sun pointed out that, according to official literature, the use of
HotSpot in the Java VM has been difficult to distinguish between Runtime period Java bytecode has been JVM Solution
Address the implementation, because HotSpot is actually compiled to Java's bytecode into native code implementation.

In fact, the design of the HotSpot, there are two technologies is very important, that is, the so-called dynamic
compilation and profiling. HotSpot compiler for bytecode, not in advance of program implementation
Compiled (the traditional way as relatively static compilation), On the other hand, in the executive program
Line process, to the built-in compiler HotSpot dynamic compiler so early JIT (Just In Time) its
The same is true of the concept of it, but there is no more comprehensive HotSpot.

Then, HotSpot is how this dynamic Java bytecode compiler? HotSpot using a highly flexible
Design, the internal maintenance of the Profile Monitor, specifically the implementation of surveillance programs to determine the use of the program fragment of
Few high-frequency and basis of the degree of impact on performance, delivered in a number of algorithms to deal with. For those who HotSpot
Run a greater impact when the efficiency of the code fragments, called hot spot (particularly in lower-case writing, to avoid
HotSpot confused with), HotSpot will be the dynamic of these fragments into a native code compiler, at the same time, will be based on prior
the results of profiling of these native code optimization, so as to enhance efficiency in the implementation. On the other hand, if they
Low frequency line code snippet, HotSpot do not need to spend time dynamic compiler, interpreter only needs to be enforcement
Line can be.

Overall terms, in the HotSpot under, Java bytecode is interpreted to be loaded into the JavaVM way, the
HotSpot immediately but will be based on some code snippet to implement the state, informed them the greatest impact on performance
Part of a dynamic compiler and the best treatment, the establishment of native code, therefore, followed by the implementation of the process can be
A considerable degree of performance increase. We know, HotSpot implementation of bytecode Department has the following three
The rationale for the way:
- Literal (not dynamic compiler)
- Part of the dynamic compiler
- Based on results of dynamic compilation, profiling and optimization to deal with
As part of the program which only literal translation, some of the dynamic compiler, and which part to do what the best treatment, then the entire process from
Profile Monitor decision.

The use of dynamic compilation than traditional static compilation of what the advantages of it? Write
Whether the demand to open cross-platform, dynamic compilation in many ways superior to traditional methods, in particular
profiling capabilities. Static compilation over the past difficult to predict the precise implementation of what the program where
The ones most in need of dealing with some of the best, only through the built-in template to construct the micro-level
Optimized code. The contrary, dynamic compilation may be true that most of the profiling performance,
Dynamically adjusted based on demand, which gradually processor software in the future development trend of the run, even more important because
The work of the past gradually hardware to software to do the transfer, compiler optimization especially heavy responsibility on the
, Such as the aforementioned Intel EPIC architecture.

Another typical example, as method inlining. Both in C + + or Java, the call
(invoke) method is the consumption of system resources, the system stack operations must be maintained to meet anticipated
calling convention. Thus, it was suggested that the original needs to be done to deal with the method invocation,
Way to use inline "embedding" to place the original call, so that on the background of a gradual implementation simply
Line, there will not be stacking operation. However, method inlining way C + + and Java for a class of objects
Case-oriented languages, the compiler is very difficult to make a very good way, because of the need to take into account the characteristics of object-oriented, especially
Its nature is to maintain the dynamic binding. In fact, the static compiler to C + + / Java in the attribute
Private and static for the method to do the method inlinng, but once or overridden
dynamic binding when, static compiler can not know the status of implementation in practice, it will not be conservative
To the implementation of inlining. This problem happens to be a class of HotSpot for the dynamic compilation
Of solved because method invocation on the Profiling Monitor can get hold of the situation, when
Likelihood that the Runtime can be accurate in, RTTI (Run-Time Type Identification) can help
HotSpot processing method inlining, therefore, such a server-side application of a repeated item
Implementation, the performance increase will be considerable.

Sun also pointed out that the literature, in some circumstances, Java applications and even the C than traditional programs faster.

The current development, JIT Compiler is mainly the cost of profiling and dynamic compila -
tion two. Ideally, these two costs should be regarded as constantant time, so many research papers
Have been put forward as to improve performance. JIT Compiler for the use of specially designed, high precision without Java
Runtime profiling may refer to <A Portable Samplling-Based Profiler for Java
Virtual Machines> [10], the paper presents a way to make use of similar sampling analysis. As
Dynamic compilation of the overhead can be gradual best way to reduce, in the Sun
The White Paper has been HotSpot detail.

[10] http://www.stanford.edu/ ~ jwhaley/papers/javagrande00.pdf

To sum up, Java performance level and that mainly explore the following:

- General
VM with JIT interaction, bytecode to IR translation, IR to machine IR
translation, and code generation / formatting

- Has nothing to do with the platform architecture (machine-independent) of the best
CSE, loop invariant code motion, inlining, speculative inlining,
method specialization, as well as multiversion code

- Associated with the platform architecture (machine-dependent) optimization
Local / Global register allocation, instruction selection, instruction
scheduling, as well as code / data alignment

- Java language level optimization
Rangecheck elimination, checkcast / instanceof removal, type propagation
, Optimizations enabled due to strong typing

- Garbage Collection
Precise / imprecise / copying / generational / incremental

- Parallel to the quantification of (vectorization)
Application of RISC workstations parallel processing instructions, or such as Intel's MMX and SSE proposed instruction set

Linux platform Java VM

In the early implementation of Sun Java VM, the thread of the Green Thread support, mainly through the light -
weight thread implementations, which can ensure that the Java VM in the heterogeneity of the operating system they can still be limited
Line-threaded support, however, resulting in low efficiency, is not the operating system direct access to the Multi-thread -
ing mechanism.

At present, Sun Linux JDK has been rewritten to use native thread, and Linux's multi-threadded
IBM and other manufacturers the ability to improve the investment mainly in the following two forms:

1. NGPT ─ Next Generation Posix Threads
More than one Java thread mapping (mapping) to less kernael thread

2. NPTL ─ Native Posix Thread Library
Java thread for each mapping (mapping) to a kernel thread, to the best of
kernel thread

Which, NGPT [11] is an IBM's Open Source program, derived from the GNU Pth program [12],
NGPT through patch Linux Kernel 2.4 and glibc way to provide support. NPTL is
Linux Kernel 2.6 key design, can be found <The Native POSIX Thread Library for
Linux> [13] and <Linux: Native POSIX Threading Library (NPTL)> [14] these two
Classic literature.

[11] http://www-124.ibm.com/developerworks/oss/pthreads/
[12] http://www.gnu.org/software/pth/
[13] http://people.redhat.com/drepper/nptl-design.pdf
[14] http://kerneltrap.org/node/view/422

The length of the next, I will present have come into contact with the Open Source JavaVM implementation.

- Kaffe (http://www.kaffe.org/)

Kaffe in this area is the old ad, Tim Wilkinson from 1996 to the completion of the initial structure
It has been seven years old. Kaffe beginning in the United Kingdom Tim Wilkinson is the development of clean-room
JavaVM implementations, the so-called cleanroom, is not a reference implementation of Sun JDK under the premise of the other self-developed
A compatible real work, then the Kaffe is a BSD-like license released. In 1997, Tim
Wilkinson and Peter Mehlitz focus on the creation of a company JavaVM implementation, Transvirtual
Technologies (TVT), the successful commercialization of the Kaffe, Since then, Kaffe There are two versions of
: A GPL licensed implementation of Open Source, that is, Kaffe.org, the other is the internal TVT
Maintenance of Custom Edition, laid the Open Source development and business model.

Kaffe VM concept design is a high degree of transplantation as well as opening up (clean-room implementation, should not confine ourselves to
Sun authorize the issuance of) the development of Transvirtual Kaffe as a result of the success of many KaffeVM-based
The basis of research projects have been proposed, so that many of the new concept has the potential to achieve by Kaffe. Transplant can KaffeVM
How power is good? Support has proved to be more than 70 kinds of platforms, even JIT engine.

Transvirtual Technologies since its establishment in 1997, has been active in the field of embedded devices
, And in 2000 the development will integrate Kaffe VM of Debian Linux, called the design a
PocketLinux platform, the core structure is the Linux and Kaffe VM (says Language Engine
), Run the above can be are real Java programs. PocketLinux is a very special operation of the Department of
EC to GNU Debian / Linux-based framework for the Kaffe VM running with 3rd-party open source
the integration of library environment, the provision of handheld devices for the Web Browser, Synchronization, Media
Player, as well as peer-to-peer solutions, in addition, PocketLinux Another feature is that through the
xml to Kaffe and packaging services for Linux systems, developers need only be able to call the Department of xml
EC to provide the function.

Though for handheld devices, Kaffe VM is the closest full-featured Java VM, almost with JDK
1.2 compatible, also supports Personal Java specifications, but does not support J2ME's Profiles. Kaffe VM
Positioning is not only a small footprint Java VM, is a full-featured embedded JavaVM, take full
Java to play in the power of distributed environment.

Unfortunately, in 2001 and 2002 between, Transvirtual companies facing tremendous changes. First
Is the main Kaffe.org defenders Edouard Parmelan died in 2001, the mid-tail, Tim
Wilkinson, the CEO is Transvirtual decided to leave the company. Faced with technical staff and funds blink
Between a shortage, Peter Mehlitz successor CEO, the decision to abandon the development of Open Source line, change the net
Performances of the commercial companies, they will PocketLinux renamed XOE, and not Open Source,
All of a sudden become one Kaffe.org adoption of orphans, the halt in Kaffe 1.0.6 version. However, Peter
Mehlitz can not move or save the company's financial position.

On the eve of the dissolution of Transvirtual, Jim Pick <jim@kaffe.org> employees in the March 12, 2002
Announced that it would take over the maintenance of Kaffe.org, and will strive to carry out Kaffe Custom Edition (also known as Kaffe
Pro) and the Open Source version of the integration, called on developers to help the next release, which is 1.0.7
Emergence. 2002, Transvirtual the end of trading, but the decline does not mean that Kaffe, on the contrary
, In, under the leadership of Jim Pick's, Kaffe.org the rebirth of success, and with other Open source
java VM to share the development of ad hoc resources, such as GNU Classpath and GCJ.

As of today, many heavyweight applications KaffeVM has been in operation, such as JBoss, Tomcat,
Jetty, as well as the Eclipse IDE.

- Japhar (http://www.japhar.org/)

Japher implement most of the JDK 1.1 features, but does not include the JIT Compiler. Since June 19, 2002
After the release of version 0.11, there will be no development, the original developers to switch to the GNU Classpath project.

- GNU Classpath (http://www.classpath.org)

Launched in 1998, in the GNU Classpath many today has become the ad hoc Open Source JavaVM
Standards. GNU Classpath is not the Java VM, but to provide the Java VM is required for API
To make, GNU Classpath on the status of the Java VM, like the libc in the C program. Before 2000
, GNU Classpath the beginning (0.00 version) only supports Japhar, and the development of a very slow, almost the same
Time, RedHat / Cygnus launched GCJ (GCC for Java) project, the efforts of many developers to start
Integration. Mark Wielaard defenders then took over after the heavy, GNU Classpath's mature approach
, Classpath:: JVM [13] who present the results of the adoption of the GNU Classpath project list.

[13] http://www.gnu.org/software/classpath/stories.html

- GNU GCJ (GCC for Java, http://gcc.gnu.org/java/)
- ORP (Open Runtime Platform, http://orp.sourceforge.net/)
- Wonka (http://www.acunia.com/wonka/)
- IBM JikesRVM (http://www-124.ibm.com/developerworks/oss/jikesrvm/)

IBM JikesRVM is derived from internal research programs, Jalapeno. Jalapeno is to build on aix / PowerPC
, Linux / PowerPC, os X / PowerPC, and so on Linux/IA-32 experimental platform is Java VM
For, then, IBM will be Jalapeno JVM within the results of research projects to authorize the release of Open Source,
And the establishment of JikesRVM plan to provide a test of many technologies such as JIT and the GC and the reference algorithm is
For the platform. JikesRVM in its architecture has always been a unique, traditional implementations of the Java VM, the core
Main is still C / C + + based, but the core of JikesRVM dependent part of the platform in addition to other must most
Few have implemented Java language, that is to say, JikesRVM can be self-contained, as
FAQ mentioned:

"Jikes RVM is unique in that it is the first self-bootstrapped virtual
machine written entirely in the Java programming language, ie, its
Java code runs on itself, without requiring a second virtual machine. "

Early in the development, JikesRVM still using IBM's internal core Java APIs class library, this
Open Source is not the points, it also criticized IBM's open-minded half. However, since the JikesRVM
2.2.1 started (April 7, 2003), JikesRVM direct results of the use of GNU Classpath, which
Change is that a fully Open Source research project of the Java VM. However, due to the vast JikesRVM
Construction of part of the core, the still need a Java Runtime, so developers need to install the Sun JDK
A class of non-Open Source Java VM, but have improved recently. Since the 2.3.2 version (March 17,
2004) began, we can use the GPL as KaffeVM authorized JikesRVM the boot-straping
Java VM, this is the Open Source Java VM to another display of the accumulated results, we can make reference JikesRVM
User Guide [14].

[14] http://www-124.ibm.com/developerworks/oss/jikesrvm/userguide/HTML/

- JamVm (http://jamvm.sourceforge.net/)
- JC VM (http://jcvm.sourceforge.net/)

(... Unfinished ...)

Java skills and code Articles

Can't Find What You're Looking For?

Rating: Not yet rated


No comments posted.