Factors affecting scalability of multithreaded Java applications on manycore systems

Abstract

Abstract-Modern Java applications employ multithreading to improve performance by harnessing execution parallelism available in today's multicore processors. However, as the numbers of threads and processing cores are scaled up, many applications do not achieve the desired level of performance improvement. In this paper, we explore two factors, lock contention and garbage collection performance that can affect scalability of Java applications. Our initial result reveals two new observations. First, applications that are highly scalable may experience more instances of lock contention than those experienced by applications that are less scalable. Second, efficient multithreading can make garbage collection less effective, and therefore, negatively impacting garbage collection performance. I. INTRODUCTIONDevelopers of Java applications adopt multithreading to achieve higher performance by utilizing multiple processing cores. As such, it is important that these applications scale well; that is, the performance of an application should increase as more threads and more processing cores are employed. This performance improvement continues to occur until the time spent on sequential portion of the program outweighs the improvement achieved through parallelism. Because Java is a managed programming language, the performance of a Java application is determined by two performance factors: the time spent in application execution (mutator time) and the time spent in execution of runtime systems such as garbage collection (GC time). Furthermore, these two factors can also affect the scalability of a Java application.In this paper, we conduct an investigation to reveal factors that can affect scalability of Java applications. Our study simultaneously considers both mutator and GC times to reveal insights on how each can contribute to the overall scalability of an application. First, we measured the application level lock contention with different numbers of threads. The results show that for scalable applications, lock contention increases with the number of threads but for poorly scalable applications, lock contention remains essentially constant as the number of threads increases. This implies that performance improvement achieved through parallelism in scalable applications outweighs the overhead due to higher instances of lock contention. Second, we characterized object lifespans and uncovered that higher execution parallelism can cause objects to live longer. Longer object lifespans degrade GC performance because most of the current GC techniques, including those based on the notion of generations, are most effective when objects die young.

rmcfs: An R Package for Monte Carlo Feature Selection and Interdependency Discovery

“…We profiled the application to find possible concurrency between threads and locks for critical section execution but it has proved not to be the case. There are many other issues that can affect a Java multithreading program such as: memory bandwidth, L3 cache size limitation, or frequent garbage collector execution (see Qian, Li, Srisa-an, Jiang, and Seth 2015). However multithreading allows to run a calculation 7 times faster by using 8 threads vs. 1 on a 14 cores CPU (49 sec vs. 340 sec respectively).…”