How to build java vm in mixed mode instead of interpreter mode

[Andrew Dinn]

Hi Srinivas,

On 20/02/17 07:14, Srinivasa Rao Ragolu wrote:
> My requirement is performance. If I build openjdk 8 with zero
> vm interpreted mode. it is very slow in performance. But in openjdk 7,
> zero vm with mixed mode give quite good performance. What is the
> difference between mixed mode and interpreted mode of zero vm? If mixed
> mode gives good performance, how can I achieve it?

Before recommending how to proceed I think it might help to provide some
background to establish what is normal vs a special case in OpenJDK and
also to explain the standard terminology to describe those cases.

Up to (and including) JDK8 a port of OpenJDK would normally implement
one of the two alternative interpreters, the template interpreter or the
C++ interpreter. It would also include either one or both the the two
available JIT compilers, the C1 (or client) JIT and the C2 (or server)
JIT. These 3 components are all implemented as part of the JVM core
library. They mostly consist of plain C/C++ code.

The JITs and template interpreter improve performance but they need to
employ a machine code generator (assembler) to generate target
hardware-specific code. So, porting them requires implementing a lot of
CPU specific-code. The C++ interpreter also normally relies either on
the assembler or on a small amount of target hardware-specific assembly
code. As a consequence not all ports implemented the template
interpreter or both JIT compilers -- or at least not in the first release.

This allows three different major modes of operation

  interpreter only mode i.e. the JIT compilers are disabled (or missing)

  compiler only mode i.e. all methods are JIT compiled

  mixed mode i.e. methods are interpreted until the call count reaches a
threshold at which point they are compiled in the background and
execution switches to use the compiled code when it is ready

As the JITs may be used in isolation or in tandem, compiled and mixed
mode also have 3 possible sub-variants

  client mode i.e. compile using only the C1 compiler
  server mode i.e. compile using only the C2 compiler
  tiered mode i.e. compile first using the C1 compiler and when the call
count reaches a threshold recompile using the C2 compiler

The two JITs differ essentially in that one takes a lot longer to
compile code but does more optimization. For most programs, tiered mode
gives the best performance.

Zero was developed as a way to implement an interpreter-only port
implemented using only C/C++ i.e. without the need to provide target-cpu
specific assembler or assembly code routines. Zero allowed OpenJDK to be
ported to any machine which provided a C++ compiler and the relevant OS
libraries. For JDK6 and early JDK7 releases this was all that was
available on 32-bit ARM hardware.

The old JDK7 (32-bit) ARM port was eventually supplemented with a 3rd
JIT implemented by Ed Nevill. This JIT is unrelated to the C1 and C2 JIT
code. Ed's JIT was integrated into Red Hat's Icedtea releases but was
not upstreamed into the code base maintained by the OpenJDK project.
This JIT provides a non-standard form of mixed mode execution for JDK7
on ARM32. It does not do most of the optimization done by the C1 JIT
(never mind C2)

Subsequently, upstream OpenJDK started the AArch32 project whose goal
was to implement a full 32 bit ARM port of JDK8 including the template
interpreter and both C1 and C2 JIT compilers. The first two components
are now available in the code included in the OpenJDK AArch32 project
repo. The C2 port is still a work in progress. Oracle recently donated
their proprietary 32-bit ARM OpenJDK code to the AArch32 project and
this newly open-sourced code is still being integrated in order to
provide both C1 and C2.

So, if you want to be able to use JDK8 with both an interpreter and JIT
compiler on 32-bit ARM then your best bet is to try to build the AArch32
code using the C1 JIT compiler. You can configure that by passing flag

  --with-jvm-variants=client

configure run in the top-level of a check-out.

You will note that I have not mentioned anything so far about the target
OS only about the target hardware. The AArch32 port builds on various
standard Linux distributions. However, it requires the presence of
certain packages at a minimum level and may need other configure options
to be specified rather than auto-configured. I notice that you are
building on your own Linux distribution. So, you may well find that you
need to tweak the configure options and ensure you have certain packages
(or libs) installed in order to get the configure and build stages to
complete.

I suggest you try configuring with only the above --with-jvm-variants
option and see what happens during the configure and compile processes.
Try to tweak the configure process by setting what look like better
alternatives (configure --help will list what is available). Similarly,
inspect the compile output and see what you can do to fix any residual
compile errors. Note that there are specific configure options to
provide extra compile flags for C and C++ compiles which you may well
need. If you get stuck post the output from configure or the
compile/build and people here may well be able to help you.

regards,


Andrew Dinn
-----------
Senior Principal Software Engineer
Red Hat UK Ltd
Registered in England and Wales under Company Registration No. 03798903
Directors: Michael Cunningham, Michael ("Mike") O'Neill, Eric Shander