Inside Java

The Java Software Quality Engineering team partners with the Java feature development teams. Our goal is to have engineers writing well designed, robust, reliable, repeatable, and maintainable open-source tests and tools. Our engineers work on the product source code as well as the test code and automation/tooling to find issues early and provide adequate coverage for the components under test.

This internship is an excellent opportunity to enhance your skills in software development and learn how features are added and updated in a language platform.

Responsibilities

• Design and develop tooling and test frameworks for one of the world’s most popular and influential development platforms.
• Work and communicate well with a wide range of features and component teams to drive quality in the Java security libraries.
• Work closely with other engineering teams to understand new technologies, design, and develop functional tests to ensure the quality of the product.
• Impact the evolution of the JDK platform and the next generation of testing tools, code analysis and test infrastructure.

Skills & Experience

• Motivated and results oriented individual.
• A good OOP programming background (ideally Java or C/C++).
• Experience on Linux/Windows/macOS.
• Some test and troubleshooting experience.
• Excellent oral and written communication skills.
• Ability to thrive and grow in a fast-paced team environment.
• Ability to conceive, plan, implement, and collaborate with distributed teams across geographies.
• A desire to learn new skills.

As experience and research shows, testing optimizing compilers is challenging. While testing our JVM's JIT compilers, we made the following key observations:

• Black box testing such as fuzzing, which generates random programs to feed into the compiler, is useful but does not scale well. Many of the generated tests are not useful and execute slowly.
• Writing efficient tests requires expert knowledge of the compiler.
• Most of our hand-written and targeted regression tests are fairly simple, consisting of only a few lines of Java code.
• Even slight modifications to existing tests often uncover new bugs.
• There are common code patterns, such as synchronized blocks or volatile field accesses, that are beneficial to optionally include in tests as they stress optimizations.
• Hand-written tests do not provide sufficient coverage since they often miss boundary values and conditions.

Based on these observations, we developed a test framework that enables generalization of hand-written tests into templates, significantly enhancing their coverage. The framework is still experimental but the goal is to be able to write tests with "holes" that are then filled in by the framework.

The goal of this project is to extend the framework with new functionality, we have a long list of ideas, and write more tests that cover the major optimization phases of the JITs.

Additionally, we could use code coverage tools to assess the extent of coverage these tests achieve on the targeted optimizations.

Requirements

• Must be able to understand C++ code and work in Java
• Familiarity with the Java ecosystem is a plus but not required
• Compiler design knowledge is a plus but not required

Different JVM components provide information about their activities to help users and developers understand, tune, and debug the JVM. Most components rely on Unified Logging (UL), a logging system available in the JVM, to record and report this information. The Just-In-Time (JIT) compiler components are currently an exception in that they perform most of their logging in a non-standard, ad-hoc manner. This makes them less accessible, particularly to end users, and precludes leveraging the more advanced logging functionality that UL offers.

This internship proposes migrating and possibly restructuring JIT compiler logging to accommodate the constraints of the UL system and the needs of JIT compilers and users. Tasks include requirement gathering, design, implementation, and evaluation of the proposed UL-based logging solution. A particular challenge, which may require extensions to the UL system itself, is to allow users to specify a subset of the methods under compilation for which logging should be performed. A successful internship has the potential to increase the visibility and approachability of the JVM's JIT compilers in the wide Java community, as well as making diagnosing and debugging more efficient for JVM developers.

Requirements

• Must be able to work in C++
• Familiarity with the Java ecosystem is a plus but not required
• Compiler design knowledge is a plus but not required