Analysis and Transformation of Configurable Systems
Total Page：16
File Type：pdf, Size：1020Kb
Analysis and Transformation of Configurable Systems Jörg Liebig 2015-04-30 Eingereicht an der Fakultät für Informatik und Mathematik der Universität Passau als Dissertation zur Erlangung des Grades eines Doktors der Naturwissenschaften Submitted to the Department of Informatics and Mathematics of the University of Passau in Partial Fulfillment of Obtaining the Degree of a Doctor in the Domain of Science Betreuer / Advisors: Prof. Dr.-Ing. Sven Apel University of Passau, Germany Prof. Christian Lengauer, Ph.D. University of Passau, Germany Externer Gutachter / External Examiner: Prof. Dr. Paul Grünbacher University of Linz, Austria Abstract Static analysis tools and transformation engines for source code belong to the standard equip- ment of a software developer. Their use simplifies a developer’s everyday work of maintaining and evolving software systems significantly and, hence, accounts for much of a developer’s programming efficiency and programming productivity. This is also beneficial from a financial point of view, as programming errors are early detected and avoided in the the development process, thus the use of static analysis tools reduces the overall software-development costs considerably. In practice, software systems are often developed as configurable systems to account for different requirements of application scenarios and use cases. To implement configurable systems, developers often use compile-time implementation techniques, such as preprocessors, by using #ifdef directives. Configuration options control the inclusion and exclusion of #ifdef-annotated source code and their selection/deselection serve as an input for generating tailor-made system variants on demand. Existing configurable systems, such as the LINUX kernel, often provide thousands of configuration options, forming a huge configuration space with billions of system variants. Unfortunately, existing tool support cannot handle the myriads of system variants that can typically be derived from a configurable system. Analysis and transformation tools are not prepared for variability in source code, and, hence, they may process it incorrectly with the result of an incomplete and often broken tool support. We challenge the way configurable systems are analyzed and transformed by introducing variability-aware static analysis tools and a variability-aware transformation engine for config- urable systems’ development. The main idea of such tool support is to exploit commonalities between system variants, reducing the effort of analyzing and transforming a configurable system. In particular, we develop novel analysis approaches for analyzing the myriads of system variants and compare them to state-of-the-art analysis approaches (namely sampling). The comparison shows that variability-aware analysis is complete (with respect to covering the whole configuration space), efficient (it outperforms some of the sampling heuristics), and scales even to large software systems. We demonstrate that variability-aware analysis is even practical when using it with non-trivial case studies, such as the LINUX kernel. On top of variability-aware analysis, we develop a transformation engine for C, which respects variability induced by the preprocessor. The engine provides three common refac- torings (rename identifier, extract function, and inline function) and overcomes shortcomings (completeness, use of heuristics, and scalability issues) of existing engines, while still being semantics-preserving with respect to all variants and being fast, providing an instantaneous user experience. To validate semantics preservation, we extend a standard testing approach for i refactoring engines with variability and show in real-world case studies the effectiveness and scalability of our engine. In the end, our analysis and transformation techniques show that configurable systems can efficiently be analyzed and transformed (even for large-scale systems), providing the same guarantees for configurable systems as for standard systems in terms of detecting and avoiding programming errors. ii Acknowledgements Pursuing a Ph.D. in computer science is a long and difficult endeavor during which the Ph.D. student is faced with many challenging tasks. Luckily, I could rely on the support of many persons when solving them. First, I would like to thank Sven Apel. After having gotten my diploma from the University of Magdeburg, Sven invited me to Passau and encouraged me to start a Ph.D. Working with Sven was a great pleasure for me because his dedication and enthusiasm to scientific work is contagious and provides a great source of inspiration. During many discussions he helped me to understand the big picture of my work, fostered my way of scientific writing, and directed me towards interesting research questions. To me, Sven is a scientist’s best role model. Second, I’m grateful for the support of Christian Lengauer. Despite the fact that Christian’s research group focuses on a different aspect of programming, he has always given me the freedom to follow my own research direction and has supported me unconditionally in financial and organizational aspects. Coming to Passau and working at his group was a big step for me. But I soon realized that Passau was not only a place to work, but also a place to live and I have always felt welcome. In this context I would like to particularly thank Eva Reichhart. Furthermore, I would like to thank many colleagues and students for their collaboration, for discussions, and for their support regarding different aspects of this thesis: Jens Dörre, Florian Garbe, Armin Größlinger, Claus Hunsen, Andreas Janker, Christian Kästner, Sergiy Kolesnikov, Olaf Leßenich, Christopher Resch, Wolfgang Scholz, Sandro Schulze, Janet Siegmund, Norbert Siegmund, Andreas Simbürger, Reinhard Tartler, and Alexander von Rhein. In particular, I’m grateful to have met Christian Kästner. Christian has been a constant source of support and I highly value his feedback. By challenging my research work down to its foundations, Christian helped me to improve it in a way I could have never imagined. Last but not least, I have to thank Elke, my wife, and my family for their continuous support and love that helped through hard times of my thesis. iii Contents List of Figures vii List of Tables ix List of Acronyms xi 1 Introduction 1 1.1 Contributions . 3 1.2 Outline . 5 2 Background 7 2.1 Software Product Lines and Configurable Software Systems . 7 2.1.1 Configuration Knowledge . 9 2.1.2 Implementing Configurable Systems . 15 2.2 Static Analysis . 18 2.3 Refactoring . 21 3 Understanding Preprocessor Annotations 25 3.1 Methodology . 26 3.1.1 Goals . 26 3.1.2 Questions . 30 3.1.3 Metrics . 34 3.2 Analysis . 39 3.3 Interpretation and Discussion . 42 3.3.1 Answering the Research Questions . 42 3.3.2 Threats to Validity . 52 3.4 Related Work . 54 3.5 Summary . 58 4 Analyzing C Code with Preprocessor Annotations 61 4.1 Sampling-based Analysis and Variability-aware Analysis . 62 4.1.1 Sampling-based Analysis . 62 4.1.2 Variability-aware Analysis . 66 4.2 Analysis Time . 72 4.2.1 Empirical Study . 73 v Contents 4.3 Upfront Investment . 81 4.3.1 Experience with Sampling . 82 4.3.2 Patterns of Variability-aware Analyses . 85 4.3.3 Variability-aware Intra-procedural Data-flow Framework . 86 4.4 Error Detection . 89 4.4.1 Evaluation . 90 4.4.2 Experiment Setup . 94 4.4.3 Results and Discussion . 95 4.5 Perspectives . 96 4.6 Related Work . 97 4.7 Summary . 102 5 Refactoring C Code with #ifdefs 105 5.1 State of the Art . 106 5.2 Variability-aware Refactorings with Morpheus . 110 5.2.1 Specification of Refactorings . 110 5.3 Experiments . 116 5.3.1 Subject Systems . 116 5.3.2 Experiment Setup . 117 5.3.3 Performance Results . 118 5.3.4 Testing the Refactoring Engine . 118 5.3.5 Perspectives of Variability-aware Refactoring . 120 5.3.6 Threats to Validity . 121 5.4 Related Work . 122 5.5 Summary . 124 6 Conclusion and Future Work 125 Bibliography 129 vi List of Figures 2.1 Compile-time configuration in LINUX; adapted from Tartler [2013]. 11 2.2 Definition of HOTPLUG_CPU with KCONFIG in LINUX [Tartler, 2013]. 11 2.3 Examples of configuration-knowledge use in MAKEFILEs in BUSYBOX. 12 2.4 Excerpt of the operating-system configuration with CPP in SQLITE. 13 2.5 Propositional formulae for the configuration knowledge presented in Fig- ures 2.2, 2.3, and 2.4. 14 2.6 Example of configuration knowledge in GLIBC using non-boolean constraints. 15 2.7 A variable list implementation with CPP; taken from Liebig et al. [2010]. 16 2.8 Implementation of the configuration option DLINKED using aspect-oriented and feature-oriented programming. 18 2.9 Code example with its corresponding AST (excerpt) and its CFG representation. 19 2.10 Examples of type errors in C. 20 3.1 Goal Question Metric (GQM) model of our study on preprocessor usage. 27 3.2 Trade-off between expressiveness, comprehension, and replication [Schulze et al., 2013a]. 28 3.3 Excerpt of a CPP-extended ISO/IEC 9899 lexical C grammar; rules for pre- processor directives are highlighted (Line 7 and Line 10 to 14); cppexp is the condition; nl is a newline; cppthenfunc represents the #endif or alternative function definitions. 33 3.4 Examples of disciplined annotations in VIM................... 34 3.5 Examples of undisciplined annotations in VIM. 35 3.6 Example of undisciplined annotations in XTERM. 36 3.7 Example of coarse-grained and fine-grained extensions. 38 3.8 Variability plots: lines of code vs configuration options (LOC/CO), lines of code vs lines of variable code (LOC/LVC), and configuration options vs lines of variable code (CO/LVC). 42 3.9 Complexity plots: configuration options vs scattering degree (CO/SD), con- figuration options vs tangling degree (CO/TD), and configuration options vs nesting depth (CO/ND). 46 3.10 Undisciplined parameter annotation (a) and two disciplined variants of it (b and c).