Oracle, a global provider of enterprise cloud computing, is empowering businesses of all sizes on their journey of digital transformation. Oracle Cloud provides leading-edge capabilities in software as a service, platform as a service, infrastructure as a service, and data as a service.

Oracle's application suites, platforms, and infrastructure leverage both the latest technologies and emerging ones - including artificial intelligence, machine learning, blockchain, and Internet of Things - in ways that create business differentiation and advantage for customers. Continued technological advances are always on the horizon.

Java Platform Group
The Java Platform Group (JPG) is the team primarily responsible for building and advancing the Java platform, developing the Java language, and stewarding the OpenJDK ecosystem forward. For many years, JPG has ensured that Java remains relevant in the technology universe by developing new features and addressing the problems and opportunities of tomorrow. With over 60 billion active JVMs globally, much of the world relies on the work of this team - Java innovation starts here.

While we act with the speed and attitude of a start-up, we operate with the scale and customer-focus expected as the leading enterprise software company in the world. We strive for equity, inclusion, and respect for all, ensuring our unique individuality is harmonious in a team environment. As an intern, you will be part of a team of uniquely smart, motivated, and diverse people who are offered the autonomy and support to do their best work, while also being given the opportunity to learn.

JVM Compiler Team
The Java Virtual Machine is a core component of the Java SE platform. It implements the Java Virtual Machine Specification, and is delivered as a shared library in the Java Runtime Environment. As the Java bytecode execution engine, it provides Java runtime facilities, such as thread and object synchronization, on a variety of operating systems and architectures. It efficiently manages the Java heap using garbage collectors, optimized for both low pause time and throughput. It provides data and information to profiling, monitoring and debugging tools and applications.

The Compiler Team is responsible for development and maintenance of the Virtual Machine's just-in-time (JIT) compilers that adaptively compile Java bytecodes into optimized machine instructions. The team works hard to ensure high performance on all supported platforms and stays up-to-date on current and future hardware. Feature development projects to take advantage of new hardware features and to increase stability and performance are always part of the team's focus. The team is also deeply involved in work for ongoing and future key JDK projects including Projects Valhalla, Loom, Panama and ZGC.

Internship Details
This is a six-month internship position in the JVM Compiler Team in Zurich, Switzerland. We offer you to participate in the development of optimizing compiler technology for Oracle's Java Virtual Machine and work on interesting and challenging projects in various phases of JVM bytecode compilation.

We have various topics depending on your skills and interests. Below is an incomplete list.

Project Valhalla
This is a large ongoing project to introduce value objects and user-defined primitives to the Java language (see https://openjdk.org/projects/valhalla/). Given the significant impact this project has on the JIT compilers, there is a plethora of tasks available, spanning all phases of compilation. From writing tests and microbenchmarks to evaluate the stability and performance of the prototype, over improving the implementation of new bytecodes, to adding new optimizations such as vectorization of accesses to flat data.

C++ code performance profiling
There are opportunities for more optimizations of the C++ code of the JIT compilers (i.e., the compilation time and footprint). The goal of this project is to profile the code, find bottlenecks and fix them. Other ideas include the introduction of a compilation timeout, a memory consumption limit and additional logging to catch compilations consuming extreme amounts of time and/or memory.

Multiple versions of compiled methods
The compilation system of the JVM compiles code at different optimization levels and throws away the less optimized code once a higher optimization level is reached. There are scenarios where it is beneficial to keep a less optimized version of the compiled code (for example, see use case "A" and "B" of https://bugs.openjdk.java.net/browse/JDK-8038356). The goal of this project is to implement and evaluate a prototype supporting multiple versions of compiled code.

Improve default compiler parameters
The JIT compilers support a large number of parameters configurable via command line flags. The goal of this project is to re-evaluate the default values of these flags and also check the benefit of having some of these fine-tuning options available as user settable flags in the first place.

Handling irreducibility in the compiler
Irreducibility is a major source of bugs in our highly optimizing JIT compiler and complicates its learnability and maintainability, particularly in the loop optimization phases. Furthermore, initial results suggest that handling irreducible methods has no measurable performance benefit, as these are very rare in practice. We should explore the impact and feasibility of alternative ways to eliminate irreducibility.

Ideal Graph Visualizer
The Ideal Graph Visualizer is a tool to visualize and debug the intermediate representation of our highly optimizing JIT compiler, written in Java. We have a long list of smaller and larger tasks that you could work on, such as improvements of the layout algorithm and support for incremental graphs.

IR verification framework
A test framework written in Java that we use to verify the intermediate representation of our highly optimizing JIT compiler (and therefore the generated code) with respect to optimizations. Potential tasks include improving the framework itself or adding new tests for existing optimizations using the framework.

Testing
As experience and research shows, testing optimizing compilers is difficult. Besides good old hand-written tests, we already apply common techniques such as fuzzing (which generates random programs to feed into the compiler) and test case reduction. There are several proposals for improving our testing further that could be evaluated. For example, based on the observation that most of our tests are fairly simple (only a few methods/loops/instructions) and slight changes to targeted regression tests often trigger new bugs, we could analyze them and use that information to guide a test generator to generate more variants of these tests. We should also evaluate the benefit of code coverage and static code analysis tools.

Preferred Qualifications
- Good communication and presentation skills in English.
- Experience in computer science fundamentals (data structures, algorithms and complexity analysis).
- Experience with modern IDEs and version control (Git).
- C++ programming skills. Experience with assembly and/or Java is a plus.
- Good problem-solving skills.
- Experience with the Java Virtual Machine (Specification) is a plus.
- Compiler development expertise is a plus.

As part of Oracle's employment process candidates will be required to successfully complete a pre-employment screening process. This will involve identity and employment verification, professional references, education verification and professional qualifications and memberships (if applicable).

 

This job code is utilized for the majority of our temporary hires. The individual is performing hourly job duties as defined under the Fair Labor Standards Act.