Just in time compilation for high performance computing

Prabhu, Tarun

Permalink

https://hdl.handle.net/2142/115354 Copy

Description

Title

Just in time compilation for high performance computing

Author(s)

Prabhu, Tarun

Issue Date

2022-03-31

Director of Research (if dissertation) or Advisor (if thesis)

Gropp, William D

Doctoral Committee Chair(s)

Gropp, William D

Committee Member(s)

• Adve, Vikram
• Hoefler, Torsten
• Fischer, Paul

Department of Study

Computer Science

Discipline

Computer Science

Degree Granting Institution

University of Illinois at Urbana-Champaign

Degree Name

Ph.D.

Degree Level

Dissertation

Keyword(s)

Compilers, JIT, Just In Time, static analysis, optimization, dynamic recompilation, HPC

Abstract

Application developers seeking to improve the performance of their code while retaining its portability and maintainability are heavily reliant on the compiler determining the appropriate sequence of code transformations that will maximize performance on a given platform. However, the parameters that the compiler requires to determine the safety and profitability of these transformations, such as array bounds, are often only known at run-time. To mitigate this problem, many compilers provide an annotation language that can be used to force the compiler to perform certain transformations. However, these annotations are not always portable and must be kept in sync with the underlying code. Failure to do so can lead to subtle and hard-to-diagnose bugs. One approach to address this issue is Just In Time (JIT) compilation. This is a technique where all or part of the code is recompiled at run-time just before it (the code) is executed. The compiler at this stage can use the run-time data to guide its optimization decisions. In this dissertation, we explore the use of JIT compilation in HPC applications. We seek to determine whether JIT compilation can be profitable for real-world applications written in compiled languages like C/C++ and Fortran and if existing applications can be retrofitted with little to no programmer intervention. To this end, we first retrofit a JIT compiler into the MPI runtime to dynamically compile code for MPI's derived datatypes. We then build a JIT compiler, Moya, to semi-automatically add JIT compilation capabilities to entire applications. We show that through a combination of carefully designed annotations and aggressive static analyses, a JIT compiler can improve application performance with minimal programmer intervention.

Graduation Semester

2022-05

Type of Resource

Thesis

Copyright and License Information

Copyright 2022, Tarun Prabhu

Owning Collections