Results 1 - 10 of 11

Characterizing and Detecting Performance Bugs for Smartphone Applications

by Yepang Liu, Chang Xu, Shing-chi Cheung
"... Smartphone applications ’ performance has a vital impact on user experience. However, many smartphone applications suffer from bugs that cause significant performance degradation, thereby los-ing their competitive edge. Unfortunately, people have little un-derstanding of these performance bugs. They ..."
Abstract - Cited by 13 (1 self) - Add to MetaCart
Smartphone applications ’ performance has a vital impact on user experience. However, many smartphone applications suffer from bugs that cause significant performance degradation, thereby los-ing their competitive edge. Unfortunately, people have little un-derstanding of these performance bugs. They also lack effective techniques to fight with such bugs. To bridge this gap, we con-ducted a study of 70 real-world performance bugs collected from eight large-scale and popular Android applications. We studied the characteristics (e.g., bug types and how they manifested) of these bugs and identified their common patterns. These findings can support follow-up research on performance bug avoidance, testing, debugging and analysis for smartphone applications. To demonstrate the usefulness of our findings, we implemented a static code analyzer, PerfChecker, to detect our identified perfor-mance bug patterns. We experimentally evaluated PerfChecker by applying it to 29 popular Android applications, which comprise 1.1 million lines of Java code. PerfChecker successfully detected 126 matching instances of our performance bug patterns. Among them, 68 were quickly confirmed by developers as previously-unknown issues that affect application performance, and 20 were fixed soon afterwards by following our optimization suggestions.
(Show Context)

EventBreak: Analyzing the Responsiveness of User Interfaces through Performance-Guided Test Generation

by Michael Pradel, Parker Schuh, George Necula, Koushik Sen
"... Event-driven user interface applications typically have a sin-gle thread of execution that processes event handlers in re-sponse to input events triggered by the user, the network, or other applications. Programmers must ensure that event handlers terminate after a short amount of time because oth-e ..."
Abstract - Cited by 7 (4 self) - Add to MetaCart
Event-driven user interface applications typically have a sin-gle thread of execution that processes event handlers in re-sponse to input events triggered by the user, the network, or other applications. Programmers must ensure that event handlers terminate after a short amount of time because oth-erwise, the application may become unresponsive. This pa-per presents EventBreak, a performance-guided test genera-tion technique to identify and analyze event handlers whose execution time may gradually increase while using the ap-plication. The key idea is to systematically search for pairs of events where triggering one event increases the execution time of the other event. For example, this situation may hap-pen because one event accumulates data that is processed by the other event. We implement the approach for JavaScript-based web applications and apply it to three real-world appli-cations. EventBreak discovers events with an execution time that gradually increases in an unbounded way, which makes the application unresponsive, and events that, if triggered re-peatedly, reveal a severe scalability problem, which makes the application unusable. The approach reveals two known bugs and four previously unknown responsiveness problems. Furthermore, we show that EventBreak helps in testing that event handlers avoid such problems by bounding a handler’s execution time.
(Show Context)

Statistical debugging for real-world performance problems

by Linhai Song, Shan Lu - In ACM SIGPLAN Conference on ObjectOriented Programming, Systems, Languages and Applications (OOPSLA , 2014
"... Design and implementation defects that lead to inefficient computation widely exist in software. These defects are dif-ficult to avoid and discover. They lead to severe performance degradation and energy waste during production runs, and are becoming increasingly critical with the meager increase of ..."
Abstract - Cited by 7 (1 self) - Add to MetaCart
Design and implementation defects that lead to inefficient computation widely exist in software. These defects are dif-ficult to avoid and discover. They lead to severe performance degradation and energy waste during production runs, and are becoming increasingly critical with the meager increase of single-core hardware performance and the increasing con-cerns about energy constraints. Effective tools that diagnose performance problems and point out the inefficiency root cause are sorely needed. The state of the art of performance diagnosis is pre-liminary. Profiling can identify the functions that consume the most computation resources, but can neither identify the ones that waste the most resources nor explain why. Performance-bug detectors can identify specific type of in-
(Show Context)

Caramel: Detecting and fixing performance problems that have nonintrusive fixes

by Adrian Nistor, Po-chun Chang, Cosmin Radoi, Shan Lu - In ICSE , 2015
"... Abstract—Performance bugs are programming errors that slow down program execution. While existing techniques can detect various types of performance bugs, a crucial and practical aspect of performance bugs has not received the attention it deserves: how likely are developers to fix a performance bug ..."
Abstract - Cited by 6 (1 self) - Add to MetaCart
Abstract—Performance bugs are programming errors that slow down program execution. While existing techniques can detect various types of performance bugs, a crucial and practical aspect of performance bugs has not received the attention it deserves: how likely are developers to fix a performance bug? In practice, fixing a performance bug can have both benefits and drawbacks, and developers fix a performance bug only when the benefits outweigh the drawbacks. Unfortunately, for many performance bugs, the benefits and drawbacks are difficult to assess accurately. This paper presents CARAMEL, a novel static technique that detects and fixes performance bugs that have non-intrusive fixes likely to be adopted by developers. Each performance bug detected by CARAMEL is associated with a loop and a condition. When the condition becomes true during the loop execution, all the remaining computation performed by the loop is wasted. Developers typically fix such performance bugs because these bugs waste computation in loops and have non-intrusive fixes: when some condition becomes true dynamically, just break out of the loop. Given a program, CARAMEL detects such bugs statically and gives developers a potential source-level fix for each bug. We evaluate CARAMEL on real-world applications, including 11 popular Java applications (e.g., Groovy, Log4J, Lucene, Struts, Tomcat, etc) and 4 widely used C/C++
(Show Context)

Detecting Performance Anti-patterns for Applications Developed using Object-Relational Mapping

by Tse-hsun Chen, Weiyi Shang, Zhen Ming Jiang, Ahmed E. Hassan, Mohamed Nasser, Parminder Flora , 2014
"... Object-Relational Mapping (ORM) provides developers a conceptual abstraction for mapping the application code to the underlying databases. ORM is widely used in industry due to its convenience; permitting developers to focus on de-veloping the business logic without worrying too much about the datab ..."
Abstract - Cited by 6 (1 self) - Add to MetaCart
Object-Relational Mapping (ORM) provides developers a conceptual abstraction for mapping the application code to the underlying databases. ORM is widely used in industry due to its convenience; permitting developers to focus on de-veloping the business logic without worrying too much about the database access details. However, developers often write ORM code without considering the impact of such code on database performance, leading to cause transactions with timeouts or hangs in large-scale systems. Unfortunately, there is little support to help developers automatically de-tect suboptimal database accesses. In this paper, we propose an automated framework to de-tect ORM performance anti-patterns. Our framework auto-matically flags performance anti-patterns in the source code. Furthermore, as there could be hundreds or even thousands of instances of anti-patterns, our framework provides sup-port to prioritize performance bug fixes based on a statis-tically rigorous performance assessment. We have success-fully evaluated our framework on two open source and one large-scale industrial systems. Our case studies show that our framework can detect new and known real-world perfor-mance bugs and that fixing the detected performance anti-patterns can improve the system response time by up to
(Show Context)

Introperf: Transparent context-sensitive multilayer performance inference using system stack traces

by Chung Hwan Kim , 2014
"... Performance bugs are frequently observed in commodity soft-ware. While profilers or source code-based tools can be used at development stage where a program is diagnosed in a well-defined environment, many performance bugs survive such a stage and affect production runs. OS kernel-level tracers are ..."
Abstract - Cited by 3 (1 self) - Add to MetaCart
Performance bugs are frequently observed in commodity soft-ware. While profilers or source code-based tools can be used at development stage where a program is diagnosed in a well-defined environment, many performance bugs survive such a stage and affect production runs. OS kernel-level tracers are commonly used in post-development diagnosis due to their independence from programs and libraries; however, they lack detailed program-specific metrics to reason about performance problems such as function latencies and pro-gram contexts. In this paper, we propose a novel perfor-mance inference system, called IntroPerf, that generates fine-grained performance information – like that from ap-plication profiling tools – transparently by leveraging OS tracers that are widely available in most commodity operat-ing systems. With system stack traces as input, IntroPerf enables transparent context-sensitive performance inference, and diagnoses application performance in a multi-layered scope ranging from user functions to the kernel. Evalu-ated with various performance bugs in multiple open source software projects, IntroPerf automatically ranks poten-tial internal and external root causes of performance bugs with high accuracy without any prior knowledge about or instrumentation on the subject software. Our results show IntroPerf’s effectiveness as a lightweight performance in-trospection tool for post-development diagnosis.
(Show Context)

Automating Performance Bottleneck Detection using Search-Based Application Profiling

by Du Shen, Qi Luo, Denys Poshyvanyk, Mark Grechanik
"... Application profiling is an important performance analysis tech-nique, when an application under test is analyzed dynamically to determine its space and time complexities and the usage of its in-structions. A big and important challenge is to profile nontrivial web applications with large numbers of ..."
Abstract - Cited by 2 (1 self) - Add to MetaCart
Application profiling is an important performance analysis tech-nique, when an application under test is analyzed dynamically to determine its space and time complexities and the usage of its in-structions. A big and important challenge is to profile nontrivial web applications with large numbers of combinations of their input parameter values. Identifying and understanding particular subset-s of inputs leading to performance bottlenecks is mostly manual, intellectually intensive and laborious procedure. We propose a novel approach for automating performance bottle-neck detection using search-based input-sensitive application profil-ing. Our key idea is to use a genetic algorithm as a search heuristic for obtaining combinations of input parameter values that maxi-mizes a fitness function that represents the elapsed execution time of the application. We implemented our approach, coined as Genetic Algorithm-driven Profiler (GA-Prof) that combines a search-based heuristic with contrast data mining of execution traces to accurate-ly determine performance bottlenecks. We evaluated GA-Prof to determine how effectively and efficiently it can detect injected performance bottlenecks into three popular open source web appli-cations. Our results demonstrate that GA-Prof efficiently explores a large space of input value combinations while automatically and accurately detecting performance bottlenecks, thus suggesting that it is effective for automatic profiling.
(Show Context)

PERFBLOWER: Quickly Detecting Memory-Related Performance Problems via Amplification

by Lu Fang, Liang Dou, Guoqing Xu
"... Performance problems in managed languages are extremely difficult to find. Despite many ef-forts to find those problems, most existing work focuses on how to debug a user-provided test execution in which performance problems already manifest. It remains largely unknown how to effectively find perfor ..."
Abstract - Cited by 1 (0 self) - Add to MetaCart
Performance problems in managed languages are extremely difficult to find. Despite many ef-forts to find those problems, most existing work focuses on how to debug a user-provided test execution in which performance problems already manifest. It remains largely unknown how to effectively find performance bugs before software release. As a result, performance bugs often escape to production runs, hurting software reliability and user experience. This paper describes PerfBlower, a general performance testing framework that allows developers to quickly test Java programs to find memory-related performance problems. PerfBlower provides (1) a novel specification language ISL to describe a general class of performance problems that have observable symptoms; (2) an automated test oracle via virtual amplification; and (3) precise reference-path-based diagnostic information via object mirroring. Using this framework, we have amplified three different types of problems. Our experimental results demonstrate that (1) ISL is expressive enough to describe various memory-related performance problems; (2) PerfBlower successfully distinguishes executions with and without problems; 8 unknown problems are quickly discovered under small workloads; and (3) PerfBlower outperforms existing detectors and does not miss any bugs studied before in the literature.

Slope-based Sequencing Yardstick for Analyzing Unsatisfactory performance of multithreaded programs An SSYAU Trend Estimation Approach to Performance Bug Localization*

by W. K. Chan, T. H. Tse, Shangru Wu, Y. T. Yu, Zhenyu Zhang
"... Abstract—As users are increasingly concerned about energy efficiency, they are also increasingly intolerant of performance anomalies of programs that may cause significant energy waste. Bug localization is a bottleneck in the development of multi-threaded programs. Although both static and dynamic p ..."
Abstract - Add to MetaCart
Abstract—As users are increasingly concerned about energy efficiency, they are also increasingly intolerant of performance anomalies of programs that may cause significant energy waste. Bug localization is a bottleneck in the development of multi-threaded programs. Although both static and dynamic perfor-mance bug localization techniques have been proposed, they cannot handle performance anomalies with unforeseen patterns, and cannot work well if the concept of performance anomaly is fuzzy or evolves over time for the same program. We propose a novel model-based approach to performance bug localization. The approach is based on curve fitting and trend estimation over program executions with performance data. We describe our trend estimation model and illustrate it with the result of a case study on locating three real-world performance bugs in MySQL. Keywords—performance bug, model-based approach, multi-threaded program, bug localization I.
(Show Context)

Towards an Automated Approach to Use Expert Systems in Performance Testing

by A. Omar, Portillo-dominguez Miao, Wang John Murphy, Damien Magoni, Nick Mitchell Peter F
"... Performance testing in highly distributed environments is very challenging. Specifically, the identification of perfor-mance issues and the diagnosis of their root causes are time-consuming and complex tasks which usually require multi-ple tools and heavily rely on expertise. To simplify these tasks ..."
Abstract - Add to MetaCart
Performance testing in highly distributed environments is very challenging. Specifically, the identification of perfor-mance issues and the diagnosis of their root causes are time-consuming and complex tasks which usually require multi-ple tools and heavily rely on expertise. To simplify these tasks, hence increasing the productivity and reducing the dependency on human experts, many researchers have been developing tools with built-in expertise for non-expert users. However various limitations exist in these tools, such as managing huge volumes of generated data, that prevent their efficient usage in the performance testing of highly distributed environments. To address these limitations, this paper pre-sents an adaptive framework to automate the usage of expert tools in performance testing. In this paper, we use a tool named Whole-system Analysis of Idle Time to demonstrate how our research work solves this problem. The validation involved two experiments which assessed the accuracy of the proposed adaptive framework and the time savings that it can bring to the analysis of performance issues. The results proved the benefits of the framework by achieving a signifi-cant decrease in the time invested in performance analysis.
(Show Context)