Motivation

Foster the collaboration between Java implementers in the OpenJDK
Community

Description

The PowerPC/AIX Porting Project has ported the JDK source base to
two new platforms: Linux/PowerPC64 and AIX/PowerPC64. It has implemented
the C++ interpreter (which is also used by the Zero port) and the C2
Server JIT compiler on the new platforms. Notice that these two new ports
are actually back-ports of commercial Java offerings by IBM and SAP and
as such the code base can be considered stable and production ready.

The focus of this JEP is not the porting effort itself, which has been
mostly completed, but rather the integration of the ports into the OpenJDK
master repositories.

A high level plan for the integration could look as follows:

The first step would be to integrate the HotSpot changes:

Currently we have about 80 changesets on top of the HotSpot
repository. A good estimation for the integration of our changes into
the HotSpot tree would be to tailor several bigger changesets
(i.e. 20-30) which can be reviewed and committed one by one. Most of
these "bigger" changes will not affect current platforms at all,
because they only contain ppc64/AIX relevant code in the new
platform-dependent files and subdirectories.

The second step would be the class-library changes:

After the HotSpot VM can successfully build on the new platforms, we
can start with the integration of the class-library changes. There
will be fewer changes with lower complexity compared to the HotSpot
changes, and the changes will be much more independent of each other
so the review process should be easier and easier to parallelize
(e.g., AWT changes are independent of NIO changes and can be done in
arbitrary order). We expect the overall complexity of the changes in
the class libraries to be less than that of the MacOS port (e.g., we
don't need a complete new graphics stack).

Oracle will create a staging repository which is owned by the PowerPC/AIX
Project and will contain the fixes that have been reviewed and approved. The
PowerPC/AIX Project is responsible for ensuring that the forest is uptodate
with the latest changes from the master repository. Oracle will create a
private hudson instance for the staging repository, which will build and test
the changes. Oracle will periodically test the changes in the staging
repository and give feedback to the PowerPC/AIX Project as appropriate. Oracle,
SAP and IBM will jointly determine when the staging forest is ready for
integration. Once that point is reached all changes from the staging repository
will be integrated via a bulk integration into the master repository.

Testing

IBM and SAP regularly build and test the ports on the porting
platforms as well as on the currently-supported JDK 8 platforms to ensure
that no regressions are being introduced which break the existing
platforms.

IBM and SAP are committed to fully support (i.e., regularly update,
enhance, and test) the code for the new platforms introduced by this
effort.

Risks and Assumptions

We don't expect any major risks, since all the code we propose for
integration was backported from commercial Java offerings by IBM and SAP
which have run in production environments for years on both the new
proposed platforms as well as on the platforms already supported by the
OpenJDK source base.

Dependences

The only dependences are in fact the resources and the commitment
provided by Oracle. Considering the current infrastructure deficiencies
we really need support from Oracle colleagues for everything, starting
with the creation of bug reports through the reviewing of changes up to
the Oracle-internal testing (JPRT) and final committing. We therefore
think this JEP needs funding not only from IBM and SAP but also from
Oracle, in particular so that Oracle engineers in the HotSpot and Core
Libraries Groups can assist in this effort.

Impact

Most of the changes to be integrated won't affect the current OpenJDK
platforms in any way because they are only active on the new platforms.
Although the Project tried to minimize changes in shared code, it was
nevertheless necessary to make selective changes in common code sections
if it was not otherwise possible to support features or to workaround
restrictions of the new platforms.

Most of the shared code changes are within the HotSpot forest due to the
need to:

Support features in the C++ Interpreter which were not yet
implemented there (method handles, profiling, compressed oops, etc.),

Support the weak memory model of the PowerPC architecture,

Support new processor requirements in the C2 server compiler
(calling conventions, memory ordering, assembler peculiarities), and
to

Support new OS-specific features on AIX (e.g., memory management)

The shared changes in the JDK (class libraries) forest are mostly due to
AIX-specific adaptions in the various native implementations of the class
libraries.

Of course there are also minor changes in the build system but they
shouldn't cause too much trouble.