Projects - Fall 2021
Fall 2021 Projects
We have some exciting projects lined up for Fall 2021:
- Automated JIT Compiler Debugging Agent
- Eclipse Adoptium and Eclipse AQAvit
- Language Server for Eclipse Jakarta EE
- Review Board
Automated JIT Compiler Debugging Agent
The JIT compiler, and hence the JVM, is a non-deterministic program. While the output of a Java program is predictable each time the JVM executes it, the manner in which the JVM executes that program is not. There are a variety of reasons for this, including memory/CPU resource availability at execution time, timing of triggering JIT compilation, varying profiling metrics between runs, hardware support, and environmental settings.
Because the JVM is a non-deterministic program, it is often found that defects in the JVM are intermittent. Intermittent defects are software defects that do not occur 100% of the time that the program/test is run. The reasons for intermittency are the same reasons outline above, i.e. the JIT is a non-deterministic program and hence compilations can look different in different environment settings.
Testing of dynamic runtimes typically involves running a testing bucket consisting of unit tests written using a testing framework. When test failures are encountered they may fail intermittently, and when JIT compilation is part of the dynamic runtime, debugging such failures becomes a difficult task due to the non-deterministic nature of JIT compilation. Systematically reducing the problem space of both identifying which JIT method is responsible for a test failure, and which transformation performed by the JIT compiler within the identified method is the cause of the test case failure is difficult when trying to brute force through repeatedly executing the test in distinct invocations of the dynamic runtime.
Our realization is that this problem can be tackled reactively, within the same process (invocation of the dynamic runtime) that first exhibited the test case failure. Our realization is that if the JIT compiler is asked to recompile methods after the test failure in the same process, most likely it will generate the same erroneous code, and re-running the same test would still reproduce the same test failure. A further extension of this realization is that dynamic runtimes such as the JVM have an oracle in the form of an interpreter for which JIT methods can fall back on to execute a particular method. Our novel idea is that we can use these two realizations to build a process which automates the reduction of the problem space of which JIT compiled method is responsible for a test case failure, and using a greedy approach narrows down to the transformation performed by the JIT compiler which causes the test to fail and provides developer required diagnostic information to identify root cause of the failure, thus saving valuable developer time.
- Filip Jeremic
- Rahil Shah
Number of Students
- 1 to 2
- Some understanding of Java Virtual Machines at a high level
- Some understanding of how JIT compilers work
- Exposure to C++ and Java
- Debugging skills (gdb, etc.)
- Prior exposure to compilers
- Some understanding of POSIX signal handlers
- An understanding of threads, synchronization, mutexes, and deadlocks
- Ability to work remotely over an SSH connection
- Exposure to JNI and JVMTI agents
Eclipse Adoptium and Eclipse AQAvit
Adoptium is a community-driven, open-source project dedicated to building, testing and distributing high-quality, fully-testing OpenJDK binaries to the Java community. AQAvit (Adoptium Quality Assurance vitality project) is an ever-evolving program to “make quality certain to happen”. We create tools and innovate in the area of software verification, bringing research and prototypes to production grade solutions as part of our mission to provide high-quality OpenJDK binaries.
- Shelley Lambert
- Lan Xia
- Sophia Guo
- Red Hat
- Alibaba, Azul, Huawei, Karakun and others
Number of Students
- 2 to 6
- Communication and organization skills
Language Server for Eclipse Jakarta EE
Develop a language server and the associated Eclipse client for the set of open cloud-native Java APIs in Eclipse Jakarta EE to boost developer productivity.
Eclipse Jakarta EE is an open source community-driven collaboration on defining and innovating on the next generation of cloud-native Java APIs.
The Language Server Protocol (LSP) enables language-specific assistance for IDEs and editors such as validations, auto-complete etc to be built in a common reusable way.
This project looks to develop a common Language Server using the Language Server Protocol for Jakarta EE APIs and the associated client for the Eclipse IDE.
- Yee-Kang (YK) Chang
- Kevin Sutter
- Kathryn Kodama
- Eric Lau
- Eclipse Foundation
Number of Students
- 3 to 6
- Experience with Java development
- Familiarity and experience with agile software development and typical software development tools.
- Experience with cloud-native Java APIs and Eclipse plugin development will be nice to have but not mandatory
Review Board is a powerful web-based code review tool that helps developers do peer review as they write code. Code review is a standard industry practice used to find bugs, improve quality, and mentor junior engineers.
Review Board is used by thousands of software companies including Yelp, LinkedIn, and VMware, as well as many open-source projects like Apache.
- David Trowbridge
- Christian Hammond
- Mike Conley
- Beanbag, Inc.
Number of Students
- 3 to 12
- Review Board is built using the Django framework on the backend, and jQuery/Backbone/HTML/CSS on the frontend. While Review Board sometimes uses those in advanced and unusual ways, some experience with those will give you a head start.
- We highly recommend having some familiarity with git.