PARACAS - PARallelization tuning using ACcurate and efficient dynamic Analyses on managed runtime Systems
Nowadays, applications running on the Java Virtual Machine (JVM) use a varied combination of data-processing frameworks and concurrent data structures, such as parallel streams, reactive streams, and thread-safe collections, which are offered by the Java class library and by many third-party libraries. Thanks to such an extensive support, the JVM has become a preferred execution platform for parallel applications written in different programming languages (e.g., Java, Scala, Kotlin). However, the availability of a large ecosystem supporting shared-memory, multi-threaded, parallel programming exacerbates the complexity of understanding the performance of a parallel application, detecting performance inefficiencies, and identifying useful optimizations. While each framework or data structure may be optimized for different scenarios, choosing the best one suitable for specific needs is a hard task, as the best choice may depend on the actual level of contention experienced in production settings, which often cannot be well estimated in the design phase. Moreover, a thorough analysis of contention requires the collection, correlation, and analysis of metrics on different application and system attributes at different layers of the system stack, which is often beyond the expertise of a developer. This project tackles this issue by proposing parallelization tuning, an approach to provide actionable profiles to developers that convey an easy-to-understand diagnosis of performance problems that would be otherwise hard to discover, their root causes, and concrete optimization suggestions at the source-code or framework level that can be applied also by non-experts. To achieve our challenging goal, we will explore novel profiling techniques across the whole system stack to gather a comprehensive set of dynamic metrics characterizing application performance. We will collect static and dynamic information to identify the code portions, framework settings, or system configurations that should be modified to solve the performance issues found, recommending concrete optimizations. To maximize the impact of our work, we will apply parallelization tuning to executable workloads in large open-source code repositories, such that our approach can be beneficial to many developers. From our experience, we will highlight common anti-patterns leading to performance problems and derive guidelines for developers to prevent such issues.