Butterfly Space: An Architectural Approach for Investigating Performance Issues

Performance issues widely exist in modern software systems. Existing performance optimization approaches, such as dynamic profiling, usually fail to consider the impacts of architectural connections among methods on performance issues. This paper contributes an architectural approach, Butterfly Space modeling, to investigate performance issues. Each Butterfly Space is composed of 1) a seed method; 2) methods in the "upper wing" that call the seed directly or transitively; and 3) methods in the "lower wing" that are called by the seed, directly or transitively. The rationale is that the performance of the seed method impacts and is impacted by all the other methods in the space because of the call relationship. As such, developers can more efficiently investigate groups of connected performance improvement opportunities in Butterfly Spaces. We studied three real-world open source Java projects to evaluate such potential. Our findings are three-fold: 1) If the seed method of a Butterfly Space contains performance problems, up to 60% of the methods in the space also contain performance problems; 2) Butterfly Spaces can potentially help to non-trivially increase the precision/recall and reduce the costs in identifying performance improvement opportunities, compared to dynamic profiling; and 3) Visualizing dynamic profiling metrics with Butterfly Spaces simultaneously help to reveal two typical patterns, namely Expensive Callee and Inefficient Caller, that are responsible for performance problems and provide insights on where to improve next. We believe that Butterfly Space modeling has great potential for investigating performance issues.

[1]  Letha H. Etzkorn,et al.  Recovering traceability links between source code and fixed bugs via patch analysis , 2011, TEFSE '11.

[2]  Qi Luo,et al.  Automating performance bottleneck detection using search-based application profiling , 2015, ISSTA.

[3]  Yuanfang Cai,et al.  Design rule spaces: a new form of architecture insight , 2014, ICSE.

[4]  Atanas Rountev,et al.  Precise memory leak detection for java software using container profiling , 2013, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[5]  Santosh Pande,et al.  Brainy: effective selection of data structures , 2011, PLDI '11.

[6]  J. Larus Whole program paths , 1999, PLDI '99.

[7]  Yuanfang Cai,et al.  Comparing four approaches for technical debt identification , 2014, Software Quality Journal.

[8]  Murali Krishna Ramanathan,et al.  Efficient flow profiling for detecting performance bugs , 2016, ISSTA.

[9]  E. Duesterwald,et al.  Software profiling for hot path prediction: less is more , 2000, SIGP.

[10]  Guoqing Xu,et al.  CoCo: Sound and Adaptive Replacement of Java Collections , 2013, ECOOP.

[11]  Keisuke Yano,et al.  Feature-gathering dependency-based software clustering using Dedication and Modularity , 2012, 2012 28th IEEE International Conference on Software Maintenance (ICSM).

[12]  Isil Dillig,et al.  Static detection of asymptotic performance bugs in collection traversals , 2015, PLDI.

[13]  Matthew Arnold,et al.  Software bloat analysis: finding, removing, and preventing performance problems in modern large-scale object-oriented applications , 2010, FoSER '10.

[14]  Chen Fu,et al.  Automatically finding performance problems with feedback-directed learning software testing , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[15]  Shan Lu,et al.  Statistical debugging for real-world performance problems , 2014, OOPSLA.

[16]  Erik Ruf,et al.  Effective synchronization removal for Java , 2000, PLDI '00.

[17]  André van Hoorn,et al.  Exploiting load testing and profiling for Performance Antipattern Detection , 2017, Inf. Softw. Technol..

[18]  Xin Yao,et al.  Software Module Clustering as a Multi-Objective Search Problem , 2011, IEEE Transactions on Software Engineering.

[19]  Uwe Fink,et al.  Performance Solutions A Practical Guide To Creating Responsive Scalable Software , 2016 .

[20]  Fabian Beck,et al.  Navigate, Understand, Communicate: How Developers Locate Performance Bugs , 2015, 2015 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM).

[21]  Rongxin Wu,et al.  ReLink: recovering links between bugs and changes , 2011, ESEC/FSE '11.

[22]  Connie U. Smith,et al.  Performance solutions: a practical guide to creating responsive , 2001 .

[23]  Ahmed E. Hassan,et al.  A qualitative study on performance bugs , 2012, 2012 9th IEEE Working Conference on Mining Software Repositories (MSR).

[24]  Tingting Yu,et al.  SyncProf: detecting, localizing, and optimizing synchronization bottlenecks , 2016, ISSTA.

[25]  Eran Yahav,et al.  Chameleon: adaptive selection of collections , 2009, PLDI '09.

[26]  Yepang Liu,et al.  Characterizing and detecting performance bugs for smartphone applications , 2014, ICSE.

[27]  Guoqing Xu,et al.  Cachetor: detecting cacheable data to remove bloat , 2013, ESEC/FSE 2013.

[28]  Michael McGill,et al.  Introduction to Modern Information Retrieval , 1983 .

[29]  James R. Larus,et al.  Efficient path profiling , 1996, Proceedings of the 29th Annual IEEE/ACM International Symposium on Microarchitecture. MICRO 29.

[30]  David S. Rosenblum,et al.  Mining performance specifications , 2016, SIGSOFT FSE.

[31]  Anne Koziolek,et al.  PerOpteryx: Automated Improvement of Software Architectures , 2019, 2019 IEEE International Conference on Software Architecture Companion (ICSA-C).

[32]  Paola Inverardi,et al.  Model-based performance prediction in software development: a survey , 2004, IEEE Transactions on Software Engineering.

[33]  Shan Lu,et al.  Understanding and detecting real-world performance bugs , 2012, PLDI.

[34]  Shan Lu,et al.  Performance Diagnosis for Inefficient Loops , 2017, 2017 IEEE/ACM 39th International Conference on Software Engineering (ICSE).

[35]  Lixia Liu,et al.  Perflint: A Context Sensitive Performance Advisor for C++ Programs , 2009, 2009 International Symposium on Code Generation and Optimization.

[36]  Yuanfang Cai,et al.  Identifying and Quantifying Architectural Debt , 2016, 2016 IEEE/ACM 38th International Conference on Software Engineering (ICSE).

[37]  Alexander Egyed,et al.  Exploiting Traceability Uncertainty Between Software Architectural Models and Performance Analysis Results , 2015, ECSA.

[38]  Emery D. Berger,et al.  Coz: finding code that counts with causal profiling , 2015, USENIX Annual Technical Conference.

[39]  Guoqing Xu,et al.  Finding reusable data structures , 2012, OOPSLA '12.

[40]  Yuanfang Cai,et al.  A Case Study in Locating the Architectural Roots of Technical Debt , 2015, 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering.

[41]  Yuanfang Cai,et al.  Design Rule Spaces: A New Model for Representing and Analyzing Software Architecture , 2019, IEEE Transactions on Software Engineering.

[42]  Erik R. Altman,et al.  Performance analysis of idle programs , 2010, OOPSLA.

[43]  Lu Fang,et al.  PerfBlower: Quickly Detecting Memory-Related Performance Problems via Amplification , 2015, ECOOP.

[44]  Matthew Arnold,et al.  Jolt: lightweight dynamic analysis and removal of object churn , 2008, OOPSLA.

[45]  Edith Schonberg,et al.  Patterns of Memory Inefficiency , 2011, ECOOP.

[46]  Marco Tulio Valente,et al.  Learning from Source Code History to Identify Performance Failures , 2016, ICPE.

[47]  Wilhelm Hasselbring,et al.  WESSBAS: extraction of probabilistic workload specifications for load testing and performance prediction—a model-driven approach for session-based application systems , 2016, Software & Systems Modeling.

[48]  Genny Tortora,et al.  Recovering traceability links in software artifact management systems using information retrieval methods , 2007, TSEM.

[49]  Paul Clements,et al.  Software architecture in practice , 1999, SEI series in software engineering.

[50]  Camil Demetrescu,et al.  Input-Sensitive Profiling , 2012, IEEE Transactions on Software Engineering.

[51]  Thomas R. Gross,et al.  Performance problems you can fix: a dynamic analysis of memoization opportunities , 2015, OOPSLA.

[52]  Yang Liu,et al.  Generating Performance Distributions via Probabilistic Symbolic Execution , 2016, 2016 IEEE/ACM 38th International Conference on Software Engineering (ICSE).

[53]  K. M. Annervaz,et al.  Software Clustering: Unifying Syntactic and Semantic Features , 2012, 2012 19th Working Conference on Reverse Engineering.

[54]  Shan Lu,et al.  CARAMEL: Detecting and Fixing Performance Problems That Have Non-Intrusive Fixes , 2015, 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering.

[55]  Lu Xiao Bridging the Gap between Software Architecture and Maintenance Quality , 2016 .

[56]  Barbara Hayes-Roth,et al.  Overview of Teknowledge's domain-specific software architecture program , 1994, SOEN.

[57]  Michael Pradel,et al.  Performance Issues and Optimizations in JavaScript: An Empirical Study , 2016, 2016 IEEE/ACM 38th International Conference on Software Engineering (ICSE).

[58]  Premkumar T. Devanbu,et al.  The missing links: bugs and bug-fix commits , 2010, FSE '10.

[59]  Shan Lu,et al.  Toddler: Detecting performance problems via similar memory-access patterns , 2013, 2013 35th International Conference on Software Engineering (ICSE).

[60]  Wilhelm Hasselbring,et al.  Kieker: a framework for application performance monitoring and dynamic software analysis , 2012, ICPE '12.

[61]  David Notkin,et al.  ArchJava: connecting software architecture to implementation , 2002, ICSE '02.

[62]  Urs Hölzle,et al.  Removing unnecessary synchronization in Java , 1999, OOPSLA '99.

[63]  Mary Shaw,et al.  Abstractions for Software Architecture and Tools to Support Them , 1995, IEEE Trans. Software Eng..

[64]  Thomas R. Gross,et al.  Performance regression testing of concurrent classes , 2014, ISSTA 2014.

[65]  Baowen Xu,et al.  Speedoo: Prioritizing Performance Optimization Opportunities , 2018, 2018 IEEE/ACM 40th International Conference on Software Engineering (ICSE).

[66]  Murali Krishna Ramanathan,et al.  Directed test generation to detect loop inefficiencies , 2016, SIGSOFT FSE.

[67]  Yuanfang Cai,et al.  Titan: a toolset that connects software architecture with quality analysis , 2014, SIGSOFT FSE.

[68]  Yuanfang Cai,et al.  Hotspot Patterns: The Formal Definition and Automatic Detection of Architecture Smells , 2015, 2015 12th Working IEEE/IFIP Conference on Software Architecture.

[69]  Yuanfang Cai,et al.  Detecting software modularity violations , 2011, 2011 33rd International Conference on Software Engineering (ICSE).

[70]  Atanas Rountev,et al.  Detecting inefficiently-used containers to avoid bloat , 2010, PLDI '10.

[71]  Giuseppe Scanniello,et al.  Investigating the use of lexical information for software system clustering , 2011, 2011 15th European Conference on Software Maintenance and Reengineering.

[72]  Gordon Fraser,et al.  EvoSuite: automatic test suite generation for object-oriented software , 2011, ESEC/FSE '11.

[73]  Iman Keivanloo,et al.  A Linked Data platform for mining software repositories , 2012, 2012 9th IEEE Working Conference on Mining Software Repositories (MSR).

[74]  Edith Schonberg,et al.  Finding low-utility data structures , 2010, PLDI '10.

[75]  Tian Jiang,et al.  Discovering, reporting, and fixing performance bugs , 2013, 2013 10th Working Conference on Mining Software Repositories (MSR).

[76]  Feza Buzluca,et al.  Object Oriented Software Clustering Based on Community Structure , 2011, 2011 18th Asia-Pacific Software Engineering Conference.