ConfigCrusher: Towards White-Box Performance Analysis for Configurable Systems

TL;DR

ConfigCrusher introduces a white-box approach using static and dynamic analysis to more efficiently and accurately determine how configuration options affect system performance, surpassing black-box methods.

Contribution

It presents a novel white-box performance analysis method that leverages static data-flow analysis and code instrumentation to identify performance influences in configurable systems.

Findings

White-box approach achieves comparable or better accuracy than black-box methods.

Method reduces the number of configurations needed for analysis.

Provides detailed insights into performance-influencing code regions.

Abstract

Stakeholders of configurable systems are often interested in knowing how configuration options influence the performance of a system to facilitate, for example, the debugging and optimization processes of these systems. Several black-box approaches can be used to obtain this information, but they either sample a large number of configurations to make accurate predictions or miss important performance-influencing interactions when sampling few configurations. Furthermore, black-box approaches cannot pinpoint the parts of a system that are responsible for performance differences among configurations. This article proposes ConfigCrusher, a white-box performance analysis that inspects the implementation of a system to guide the performance analysis, exploiting several insights of configurable systems in the process. ConfigCrusher employs a static data-flow analysis to identify how configuration options may influence control-flow statements and instruments code regions, corresponding to these statements, to dynamically analyze the influence of configuration options on the regions' performance. Our evaluation on 10 configurable systems shows the feasibility of our white-box approach to more efficiently build performance-influence models that are similar to or more accurate than current state of the art approaches. Overall, we showcase the benefits of white-box performance analyses and their potential to outperform black-box approaches and provide additional information for analyzing configurable systems.

Tables

Table 1. Table 1 : Comparison of the state of the art approaches.

Approach	Sampling	Measuring	Learning
Brute Force	Exhaustive	End-to-end	Not needed
SPLat	Distinct execution paths	End-to-end	Not needed
Sampling and Learning	Strategy based	End-to-end	Algorithm based
Family-Based	One configuration	Region-level	Not needed
ConfigCrusher	Static analysis-based	Region-level	Not needed

Table 2. Table 3 : Configuration performance map of the optimized region of Fig.  2 . For simplicity, the measurement noise was removed.

Configurations					Regions
A	B	C	D		Base (s)	OR1 $\equiv$ {A, C} (s)	OR2 $\equiv$ {A, B} (s)
F	F	F	F		1	0	0
F	T	T	F		1	0	0
T	F	F	F		1	3	0
T	T	T	F		1	6	3

Table 3. Table 4 : Configurable subject systems.

ID	Name	Domain	# SLOC	# Opt.	# Conf.	CID
1	Running Example	Example	69	10	1 024	—
2	Pngtastic Counter	Processing	1 250	5	32	7f96382
3	Pngtastic Optimizer	Optimization	2 553	5	32	7f96382
4	Elevator	SPL–Benchmark	575	6	20	—
5	Grep1	Command line	2152	7	128	ef9eaa7
6	Kanzi	Compression	20 537	7	128	4dae29e
7	Email	SPL–Benchmark	696	9	40	—
8	Prevayler	Database	1 328	9	512	5be1ca4
9	Sort1	Command line	2 163	12	4 096	ef9eaa7
10	Density Converter	Processing	1 359	22	222	2ba8373

Table 4. Table 5 : Cost of building performance-influence models.

S	BF/SA	FW	PW	SAD	FB1	CC2
1	1024 [1.9h]	10 [16.6s]	56 [2.2m]	512 [56.9m]	N/A	8 [33.8s, 4.4s]
2	32 [2.9m]	5 [27.2s]	16 [1.5m]	24 [2.2m]	N/A	4 [21.9s, 7.8s]
3	32 [42.2m]	5 [1.6m]	16 [10.0m]	16 [21.0m]	N/A	10 [10.7m, 30.6s]
4	20 [10.8m]	3 [50.0s]	9 [3.3m]	20 [10.8m]	1 [49.5s]	64 [—]
5	128 [10.6m]	7 [22.1s]	29 [1.9m]	48 [3.5m]	N/A	64 [5.1m, 10.2s]
6	128 [1.2h]	7 [1.5m]	29 [8.8m]	64 [35.4m]	N/A	64 [35.4m, 12.6s]
7	40 [16.9m]	4 [23.5s]	11 [1.7m]	40 [16.9m]	1 [1.1m]	8 [1.5m, 12.8s]
8	512 [3.7h]	9 [2.7m]	46 [16.0m]	144 [1.5h]	N/A	32 [14.5m, 12.6s]
9	1298 [18.4h]	12 [13.1m]	79 [1.4h]	48 [42.8m]	N/A	256 [3.7h, 21.6s]
10	1414 [14.7h]	22 [21.3m]	254 [4.1h]	+24h3	N/A	256 [2.1h, 42.1s]

Table 5. Table 7 : Static and dynamic comparison of instrumented regions before and after optimization for the configuration with the largest dynamic overhead.

	Original		Unoptimized				Optimized
S	Time		R	RC	Time		R	RC	Time
1	12.14s		16	32	12.16s		10	22	12.13s
2	5.40s		36	$>{10}^6$	$>$1h		13	18	5.54s
3	3.68m		397	$>{10}^6$	$>$1h		7	88	3.77m
5	22.87s		46	$>{10}^6$	$>$1h		1	2	21.87s
6	1.04m		128	$>{10}^9$	$>$1h		23	4160	1.04m
7	26.08s		60	8530	25.50s		11	1204	25.49s
8	1.25m		147	$>{10}^9$	$>$1h		28	$>{10}^6$	1.27m
9	4.87m		166	$>{10}^9$	$>$1h		1	2	4.89m
10	6.45m		202	2420	6.53m		10	78	6.45m

Table 6. Table 8 : Influence of options analysis of local performance-influence models.

	PNIO				Performance influenced by options
	NEG		Non-NEG
S	Regions		Regions		Regions	Min ID	Max ID	Structure
1	0		0		10	1	3	Sleep
2	13		2		0	N/A	N/A	Loop, I/O
3	3		1		3	3	3	Loop, I/O
5	0		0		1	6	6	Loop
6	19		2		2	6	6	Loop, I/O
7	7		0		4	2	8	Loop, Sleep
8	22		1		5	2	5	Loop, I/O
9	0		0		1	8	8	Loop
10	8		1		1	8	8	Loop, I/O

Full text

1 Introduction

Most of today’s software systems, such as databases, Web servers, processing libraries, and compilers, provide configuration options to satisfy a large variety of requirements (Siegmund et al., 2015; Apel et al., 2013; Jamshidi et al., 2017b; Xu et al., 2015; Kolesnikov et al., 2018). To this end, stakeholders select specific values for each option to obtain the desired functional properties and quality attributes in the system. However, this configuration process is often a difficult task, especially when lacking knowledge of how the configuration options influence the functionality and qualities of the system (Apel et al., 2013; Siegmund et al., 2015; Xu et al., 2013). For this reason, users, developers, and administrations typically resort to default configurations or change individual options in a trial-and-error fashion without understanding the resulting effect (Xu et al., 2015; Jamshidi and Casale, 2016; Jin et al., 2014; Hubaux et al., 2012).

Performance is one of the many interesting qualities of such systems. Understanding how individual configuration options and their combinations influence the performance of the system would facilitate the reasoning, debugging, adaptation, and optimization processes of these systems (Han et al., 2018; Kolesnikov et al., 2018; Wang et al., 2018; Zhu et al., 2017; Siegmund et al., 2015; Xu et al., 2013; Han and Yu, 2016). For example, users can find the configuration that performs an execution the fastest, and developers can find configuration options that cause excessive execution time when debugging the system.

One research area has focused on understanding the influence of options and their interactions on the performance of a configurable system by building a performance-influence model (Siegmund et al., 2015), which describes the performance of a system in terms of its configuration options for a specific workload and in a specific environment (e.g., on given hardware). Most prior work on deriving performance-influence models uses black-box approaches (Siegmund et al., 2012b, 2015; Hutter et al., 2011; Olaechea et al., 2014), which consider the system as a black box and measure for how long the system executes in different configurations. These approaches sample a subset of the configurations of a system and extrapolate a model based on the corresponding end-to-end measurements. The model’s accuracy and cost depend on the approaches’ sampling strategy (i.e., which configurations to measure) and the algorithm used for learning (Kolesnikov et al., 2018). Sampling is particularly important: The accuracy of a model might be low if the sample set does not capture performance-influencing interactions among options. Several different sampling strategies with different cost-accuracy tradeoffs have been explored (cf. Fig. 1).

We argue that a white-box approach that analyzes the system’s source code can provide additional insights and guide the performance analysis to relevant options and interactions. Where black-box approaches are blind to the internals of an implementation, white-box approaches can, for example, identify options interacting in control-flow statements, and thus focus measurements on fewer, but more relevant configurations, thus promising to build more accurate models at lower cost (cf. Fig. 1). In addition, analyzing the implementation and performing measurements with regard to regions of the system rather than black-box end-to-end measurements allows us to pinpoint which regions of a system (e.g., set of statements influenced by the same set of options) are responsible for performance differences among configurations (i.e., more informative models), which can further help in performance debugging and optimization.

In this article, we introduce a novel white-box performance analysis approach for configurable systems, named ConfigCrusher. It combines static and dynamic analyses to identify and efficiently measure configurations that are relevant for accurate performance modeling. Specifically, ConfigCrusher (1) uses static data-flow analysis to trace the effect that configuration options may directly or indirectly have on a system’s control-flow statements (including loops) and (2) instruments the system at configuration-relevant control-flow statements to measure the performance per region in concrete executions in a small set of selected configurations. One key benefit of measuring performance per region is that, in a single executed configuration, we independently measure the influence of multiple options on different regions, a process we call compression. Overall, ConfigCrusher exploits multiple insights about configurable systems, established in several prior studies (Kim et al., 2013; Jamshidi et al., 2017a; Kim et al., 2011; Meinicke et al., 2016; Siegmund et al., 2012a, 2013; Kolesnikov et al., 2018; Lillack et al., 2018; Reisner et al., 2010; Nguyen et al., 2016):

1. (a)

Irrelevance: Not all options influence the performance of a system on a given workload. ConfigCrusher’s data-flow analysis identifies options that do not influence the execution, reducing the number of configurations to sample. 2. (b)

Orthogonality: Not all options interact with each other. ConfigCrusher’s data-flow analysis identifies options that are orthogonal and can thus be measured together in a single execution, reducing the number of configurations to sample. 3. (c)

Low Interaction Degree: Considering interactions is essential for accurate performance-influence models, but most options tend to interact only with few other options. ConfigCrusher’s analysis identifies which interactions can occur, focusing the sampling towards performance-relevant configurations.

Compared to state of the art black-box approaches, ConfigCrusher reduces the cost of performance modeling while preserving or increasing the accuracy of the resulting models. Guided by program analysis, it will often measure fewer performance-relevant configurations, and, with instrumentation and compression, each measurement can provide information about multiple options and interactions. Furthermore, in addition to traditional performance-influence models, ConfigCrusher builds a local performance-influence model for each region of a system. These models can provide additional fine-grained information and insights to developers, for enhanced debugging and understanding of the performance behavior of a system.

To demonstrate the potential of our white-box approach, we implemented ConfigCrusher for Java systems. using the static taint-analysis engine FlowDroid (Arzt et al., 2014) for tracking configuration options. We show that our white-box approach outperforms existing state of the art approaches (i.e., more accurate models at lower cost) on $10$ configurable systems. Due to known scalability issues with precise and accurate static data-flow analyses (Avdiienko et al., 2015; Arzt et al., 2014; Bodden, 2018; Lerch et al., 2015; Do et al., 2017; Qiu et al., 2018; Wang et al., 2016; Pauck et al., 2018), we limit our evaluation to relatively small, but still real-world open-source applications from different domains, including command-line programs, processing libraries, databases, and software product lines. Nevertheless, our evaluation still provides evidence for the feasibility of the underlying ideas. More generally, we show the potential benefits of analyzing the system structure to help in the understanding, debugging, and optimization of configurable systems and provide a foundation for future research to scale white-box performance analyses.

In summary, we make the following contributions:

• •

A white-box program analysis, combining data-flow and control-flow analysis and dynamic instrumentation for fine-grained performance measurement to identify how options affect the execution of configurable systems, exploiting insights about common characteristics of such systems (Sec 3).

• •

A compression technique that allows us to independently infer the influence of options and their interactions on multiple regions of a system’s execution and a corresponding method to build accurate performance-influence models (Sec 3.2).

• •

An optimization to reduce the overhead of the instrumented systems that we analyze (Sec 3.3).

• •

An empirical evaluation of ConfigCrusher on 10 systems demonstrating the feasibility and potential of a white-box approach to reduce the cost and increase the accuracy of performance modeling compared to state of the art performance modeling approaches (Sec 5).

• •

A public open-source implementation of ConfigCrusher and reimplementations and improvements of prior state of the art approaches for Java systems (Velez et al., 2019).

• •

A replication package with technical information of the systems analyzed, environmental setup for experiments, analysis scripts, and data of several months of measurements (Velez et al., 2019).

2 Performance Modeling of Configurable Systems

A system’s performance and, often directly correlated, energy consumption are important concerns for many software systems. While it is possible to design and optimize a system’s implementation for a specific task, much of our modern software is built on top of reusable (open-source) infrastructure software, such as databases, Web servers, video encoders, and so forth. However, a single reusable infrastructure component will rarely ever satisfy all stakeholders equally (“no one size fits all”); for example, developers needing a data-storage component for a write-heavy scenario would likely make different implementation decisions than for a read-heavy scenario, if they would implement such component from scratch. To resolve this tension between a single reusable component and custom implementations for different stakeholders, reusable components often have a large number of configuration options that defer design decisions and allow users to choose between different implementations and different resulting functionality and quality tradeoffs to meet their needs (e.g., workloads and environments).

When reusing such infrastructure components with many options, making suitable configuration decisions can be challenging (Xu et al., 2015; Apel et al., 2013). Users are often unaware of the impact on options on various qualities or have only vague intuitions (Xu et al., 2013; Hubaux et al., 2012), and options may interact, producing surprising behavior (Siegmund et al., 2015). For example, a developer considering whether to enable encryption, would likely expect that encryption may slow down system performance, but may need to perform experiments to identify the severity of the effect, given the concrete system, workload, and other configuration decisions.

In this context, performance-influence models that explain how configuration options and their interactions influence the performance of a system, in a certain context (e.g., requirements and needs), can be helpful when making deliberate configuration decisions (e.g., optimizing performance for given workload or debugging the system’s performance behavior). That is, performance-influence models have a fundamentally different approach and goal than traditional performance models, which typically model and analyze (e.g., using Queuing networks, Petri Nets, and Stochastic Process Algebras) the performance of a system’s architecture under different workloads in the design stage of a project (Harchol-Balter, 2013; Serazzri et al., 2006), possibly also modeling design decisions as configuration options (Esfahani et al., 2013; Becker et al., 2009). In contrast, performance-influence models describe the performance behavior of a given system implementation, with a given workload and environment, in terms of configuration decisions and they are typically learned from observing a specific system execution under different configurations.

Performance-influence models are typically learned by fitting a model to explain the performance in terms of configuration options (Siegmund et al., 2015; Guo et al., 2013; Jamshidi et al., 2017a, 2018; Valov et al., 2017). The models can be used for performance debugging (Siegmund et al., 2015; Wang et al., 2018; Xu et al., 2013), optimization (Oh et al., 2017; Zhu et al., 2017; Guo et al., 2013), and adaptation (Wang et al., 2018; Zhu et al., 2017; Jamshidi et al., 2017b, 2018).

As a running example, the performance-influence model $\Pi=1+3\texttt{A}+3\texttt{AB}+3\texttt{AC}$ for the system in Figure 2 (Lines $1$–$15$) suggests that the measured execution, with a given workload and environment, takes $1$ second by default (Line 12), but $3$ seconds longer if option A (compression) is selected (Lines 4 $+$ 16) and another $3$ seconds extra, each, if option B (page-size, Line 21) or C (encryption, Line 3) are selected together with A. Such model can help with several maintenance and understanding tasks. For example, users can optimize the execution time (e.g., deselect A in this example) or make an informed tradeoff decision, (e.g., whether the functionality of A is worth the $3$ second overhead). Likewise, such models can generally help with system understanding such as identifying the interaction of A with B and C or recognizing that A might be a performance bottleneck. Similarly, we can use this model in a planning algorithm to adapt (i.e., dynamically reconfigure) the system, in response to changing requirements or environment conditions, such as high load or low battery (Aldrich et al., 2019; Weisenburger et al., 2017).

Performance-influence modeling is different from performance tuning approaches that attempt to change a system’s configuration to optimize performance (possibly also considering multiple qualities with a suitable fitness function) for a given workload and environment (Olaechea et al., 2014; Hutter et al., 2011). These approaches search for a good configuration rather than building models of the entire configuration space. Performance tuning approaches for configurable systems conduct some sort of search in the configuration space, with and without building intermediate models to support the search (Jamshidi and Casale, 2016; Oh et al., 2017; Siegmund et al., 2012b), typically measuring the system execution under different configurations. For performance tuning, search is typically more efficient than building performance-influence models, because the focus is only on finding the fastest configuration, not on explaining why it is fast, not modeling the performance of slower configurations, and not characterizing the influence of options and interactions. In contrast, performance-influence models, the focus of this article, are more suited for tasks related to understanding, debugging, prediction, adaptation, and automated reasoning.

2.1 State of the art of building performance-influence models

Performance-influence models are typically created by selecting a set of configurations, measuring the performance of a system for each configuration (given a fixed workload and environment), and then fitting a model (e.g., a linear model) to explain the system’s performance behavior in terms of its configuration options. The accuracy of performance-influence models is measured in terms of how well the models predict the performance of all configurations. The main cost driver for building performance-influence models is the need to execute and measure a potentially large number of sampled configurations – there is typically a tradeoff between accuracy and cost in that models trained on fewer samples are less expensive to build, but also less accurate (e.g., if the sampled configurations do not cover all relevant execution paths, cf. Fig. 1).

Essentially, all existing approaches for building performance-influence models are black box in that they do not consider the implementation of the system. The key differentiators are how configurations are sampled and how (and what kind of) models are fitted. Many combinations have been explored (Siegmund et al., 2013; Guo et al., 2013; Sarkar et al., 2015; Siegmund et al., 2012a, b, 2015), with different tradeoffs among applicability, cost, and accuracy (Kolesnikov et al., 2018).

By contrast, we propose to analyze the system’s implementation (white-box) to guide the sampling to relevant configurations and to instrument the system to perform more fine-grained measurements, mapping performance influence of options to specific code regions. While there has been work on program analysis to identify how configuration options affect the execution of a system (Kim et al., 2013; Lillack et al., 2018; Angerer et al., 2015), usually for testing or system comprehension, beyond our own prior work with very limiting assumptions (e.g., no data-flow interactions, and exclusive to compile-time variability) (Siegmund et al., 2013), we are not aware of any work on using program analysis to inform performance-influence modeling. We conjecture that white-box strategies can achieve higher accuracy at lower cost, if the analysis identifies relevant options and interactions.

The insights on which we build this work are Irrelevance (not all options influence the performance of a system on a given workload), Orthogonality (not all options interact with each other), and Low Interaction Degree (most options tend to interact only with few other options) (Kim et al., 2013; Jamshidi et al., 2017a; Kim et al., 2011; Meinicke et al., 2016; Siegmund et al., 2012a, 2013; Kolesnikov et al., 2018; Lillack et al., 2018; Reisner et al., 2010; Nguyen et al., 2016). Other insights, such as prefix sharing and variational execution (Meinicke et al., 2016), could be exploited to efficiently build accurate models. However, these insights require special dynamic analysis techniques with excessive overhead, even for small systems, which is why we do not consider them in this work.

In the following paragraphs, we describe the state of the art approaches for building performance-influence models in terms of their sampling, measuring, and learning techniques, and to what degree they exploit the insights that we consider in this work. Table 2 summarizes the approaches and Table 2 compares the number of executions and accuracy of each approach when analyzing our running example (Fig. 2, Lines 1–21).

Brute Force is a black-box approach that samples all configurations of a system and measures the execution time of the system for a given workload end-to-end. It is rarely used in practice due to its obvious scalability issues for all but the smallest configuration spaces. Learning a performance-influence model from Brute Force executions is not necessary as we know the execution time of all configurations, although a simplified model could be learned for understanding (Kolesnikov et al., 2018). In our running example, among other inefficiencies, it will execute irrelevant configurations (e.g., all configurations that explore all values of options D – J).

SPLat (Kim et al., 2013) is a white-box testing approach that we repurpose for performance analysis.111Though SPLat was designed for unit testing software product lines, the algorithm can be used to reduce the number of configurations to sample. By instrumenting the system, it dynamically tracks the configurations that produce distinct execution paths. It reexecutes the system until all configurations with distinct paths are explored. While it ignores irrelevant options, since they do not produce different paths, it explores all combinations of options that it encounters during execution; each time an option is reached in a new path, it explores both values for that option. Essentially, it is an improved version of the Brute Force approach. SPLat does infer from control-flow interactions that some options are only reachable when specific values are selected. In our running example, it will explore option C only when option A is enabled. Despite this benefit, it still often produces very large sets of configurations to sample, which can lead to scalability issues. Similar to the Brute Force approach, it measures the execution time end-to-end and learning a performance-influence model is not necessary.

Sampling and Learning approaches are combinations of a sampling technique; such as random sampling, feature-wise, pair-wise (Medeiros et al., 2016), design of experiments (Montgomery, 2006), or combinatorial sampling (Al-Hajjaji et al., 2016; Nie and Leung, 2011; Hervieu et al., 2011, 2016; Halin et al., 2018), to measure the end-to-end execution time of a subset of the configuration space, and a learning technique; such as regression, classification and regression trees (Guo et al., 2013; Sarkar et al., 2015; Siegmund et al., 2012a, b, 2015), or Gaussian Processes (Jamshidi et al., 2017b), to extrapolate a performance-influence model. The number of samples and accuracy of the learned model depend on the sampling strategy and learning algorithm. Although some sampling strategies rely on a coverage criteria to sample specific interaction degrees, such as t-wise sampling (Nie and Leung, 2011; Medeiros et al., 2016), they might miss important interactions leading to inaccurate models. In addition, due to their lack of insight of the internals of the system, none of these approaches recognizes irrelevant options.

Family-Based Performance Measurement (Siegmund et al., 2013), our own prior work, is currently the only white-box performance-influence modeling approach we are aware of. It uses a static mapping between options to code regions and instruments the system to measure the execution time spent in the regions. Subsequently, it executes the system once with all options enabled, tracking how much each option contributes to the execution time. The approach works well when all options only contribute extra behavior, but do not interact. Current implementations, however, derive the static map from compile-time variability mechanisms (preprocessor directives) (Siegmund et al., 2013) and could not handle our running example with load-time variability (i.e., loading and processing options in variables at runtime). Furthermore, the static map only covers direct control-flow interactions from nested preprocessor directives, and can lead to inaccurate models when data-flow interactions occur. In our running example (Fig. 2), data-flow analysis is needed to detect that the second if statement indirectly depends on option A (with implicit data-flow through variable x), leading to inaccurate performance-influence models otherwise.

All the surveyed approaches build performance-influence models with different levels of applicability, cost, and accuracy, but they either overapproximate or underapproximate the interactions in a system and configurations that need to be executed to build an accurate performance-influence model. Furthermore, none of the approaches can associate the resulting performance-influence model with regions in the source code, which can help to understand and debug individual components of a system. The only exception is the family-based approach, but it has severe limitations and assumptions of the systems it can analyze.

2.2 ConfigCrusher

We introduce ConfigCrusher, a new white-box approach that exploits the insights of Irrelevance, Independence, and Low Interaction Degree, which leads to a reduction in the cost to measure performance while also generating accurate and informative performance-influence models. Our approach improves upon the state of the art of performance-influencing modeling by using a static analysis to identify how load-time configuration options may influence regions in the system through control-flow and data-flow dependencies. Then, it derives a set of relevant configurations to measure the execution time of regions and builds local performance-influence models that describe how options influence the execution time of those regions. Subsequently, the local models are aggregated to obtain a global performance-influence model for the system.

In our running example, ConfigCrusher will identify $3$ regions affected by configuration options (Fig. 2) and use the options that influence the regions to compress the configuration space into a set of $4$ configurations to be sampled (Table 3). Next, it will instrument the system’s regions, reducing the instrumentation overhead through additional optimization (Sec. 3.3). Finally, it will build local performance-influence models (Sec. 3.5) for each region based on the performance observed when executing the instrumented system with the compressed set of configurations (Table 3) and, subsequently, aggregate them to produce an accurate global performance-influence model.

3 ConfigCrusher

The general idea of ConfigCrusher is to identify the regions (sets of statements influenced by a set of options from control-flow and data-flow dependencies) in the system that depend on configuration options, and use these options to generate a compressed set of configurations. The set is then used to measure the regions’ performance to build an accurate performance-influence model. We proceed in five steps:

• •

Identify Configuration-Dependent Regions (Sec. 3.1): We perform a data-flow analysis that identifies the control-flow statements that depend on configuration options and the code regions affected by these statements.

• •

Compress Configuration Set (Sec. 3.2): We identify the smallest set of configurations that cover all relevant executions of all regions.

• •

Instrument Regions with Optimizations (Sec. 3.3): We instrument the regions in the system to track their execution time in different configurations and optimize the instrumentation to reduce measurement overhead.

• •

Execute the Instrumented System (Sec. 3.4): We execute the instrumented system to measure the performance of regions.

• •

Build the Performance-Influence Model (Sec. 3.5): We individually build local performance-influence models based on the measured code regions’ performance and, subsequently, aggregate them to obtain a global performance-influence model.

3.1 Identifying Configuration-Dependent Regions

As first step, we identify the control-flow statements that depend on configuration options and the regions affected by these statements. To this end, we create the statement influence map $SI$ from statements $S$ to the set of options $O$ that influence the execution of these statements $(\mathit{SI:S\rightarrow\mathcal{P}(O)})$. We use this map later to compress a set of configurations (Sec. 3.2) and to instrument the system (Sec. 3.3).

To obtain the statement influence map, we use a data-flow analysis to track how options are used in control-flow statements. That is, we track variables at API calls that load configuration options and then propagate them along control-flow and data-flow dependencies (including implicit flows). By tracking how each option flows through the system, we can identify, for each control-flow statement, the set of options that may influence this statement. Finally, we produce the map, mapping all statements in the branches of a control-flow statement to all influencing options.

Example:

The options in our running example in Fig. 2 (Lines 1–21) are the fields A – J. Lines 6–13 are not influenced by any options, Lines 3–4 are influenced by the set of options $\{\texttt{A},\texttt{C}\}$, Lines 15–18 by $\{\texttt{A}\}$, and Line 21 by $\{\texttt{A},\texttt{B}\}$.

We can reason about Irrelevance, Orthogonality, and Low Interaction Degree with this data-flow analysis: Options that influence no control-flow statements are irrelevant and never appear in the resulting map. Likewise, we can identify which set of options interact on which control-flow statements and detect both orthogonality and low interaction degree. For example, in our running example, we learn that option A interacts with B and C separately, but not together, and that options D – J are irrelevant in the system.

3.2 Compressing Configuration Set

Based on the statement influence map, we now calculate the compressed set of configurations ($\mathit{CC\subseteq\mathcal{P}(O)}$) that will be executed to measure the performance of the regions in the system. We use the set of all interactions (image of SI from Sec. 3.1, $IO:\mathit{\mathcal{P}(\mathcal{P}(O))}$) to generate this set of configurations and use it later to execute the instrumented system (Sec. 3.4).

Intuitively, our goal is to execute the system such that each region is executed for every combination of options involved in that region, while minimizing the overall number of configurations to execute. Since different regions may be influenced by different options (orthogonality), we can execute them in the same configurations, in a process we call compression. The challenge is similar to finding covering arrays in combinatorial interaction testing, such as covering all combinations of pairs of options (Kuhn et al., 2013; Al-Hajjaji et al., 2016; Hervieu et al., 2011, 2016; Halin et al., 2018). However, we need to cover different interaction strengths for different sets of options depending on which combinations of options have been detected in our statement influence map.

We developed a heuristic compression algorithm (Algorithm 1) to find and compress a set of configurations that we use to measure the performance of the system. First, we select all unique sets of options that are not subsets of other sets (Lines 1–1) and calculate all combinations of each set (Lines 1–1)—these are the minimum combinations we need to cover. Next, we compress the set of configurations (Lines 1–1) by iteratively merging the partial configurations around the options that are common between two sets of options (i.e., the pivot).

Example:

In our running example (Lines $1$–$15$), the regions are influenced by the sets of options $\{A\}$, $\{A,B\}$, and $\{A,C\}$. That is, we need to cover two combinations for $\{A\}$ (with A enabled and disabled), four combinations of $\{A,B\}$, and four combinations of $\{A,C\}$. The four combinations of $\{A,B\}$ already subsume the two configurations of $\{A\}$. Furthermore, based on the pivot $\{A\}$ of the remaining sets, we can create a merged compressed set of four configurations that still cover all interactions of A with B and A with C: \bigl{\{}\{\},\{B,C\},\{A\},\{A,B,C\}\bigr{\}}.

Note how compression exploits Irrelevance and Orthogonality: It does not consider irrelevant options (e.g., D) and does not consider the combinations of options that do not interact (e.g., B and C). The size of the compressed set is dominated by the size of the largest interaction (at least $2^{n}$ configurations for an interaction among $n$ options; $n=2$ in our running example), which is often moderate due to Low Interaction Degree. At the same time, independent interactions of the same size can often be merged effectively.

3.3 Instrumenting Regions with Optimizations

Next, we instrument the system to measure its performance broken down by code regions. As part of the instrumentation, we identify and optimize the actual regions used for measurement, derived from the statement influence map (Sec. 3.1). We subsequently execute the instrumented system (Sec. 3.4) with the compressed set of configurations (Sec. 3.2) to build the performance-influence model (Sec. 3.5).

A region is a set of statements influenced by the same set of options, identified by a set of control-flow edges that start the region and another set of edges that end it. Algorithm 2 calculates the regions and their start (Line 2) and end edges (Lines 2–2) in a method. A region starts before the first statement influenced by a set of options (indicated by the statement influence map) and ends after the last statement influenced by the same set of options. One task of the algorithm is to find the end of a region where all the paths originating from a control-flow statement meet again (i.e., the immediate post-dominator) (Lines 2–2). The algorithm obtains the immediate post-dominator and continuously searches for the next one until it finds the last statement with the same influence as the current control-flow statement.

After identifying all regions, we instrument the start and end edges of these regions with statements to log their execution time and measure their influence on performance. We also instrument the entry point of the system to measure the performance of code not influenced by any options. The result of executing an instrumented system is the total time spent in each region.

Example:

Fig. 4a shows the three regions that we instrument in the control-flow graphs of our running example in Fig. 2. One region contains statements $\{12,14,15\}$ since statement 15 is influenced by $\{A\}$ and its last post-dominator without that influence is 21.

Optimization.

Although Algorithm 2 can identify regions in a system, we observed excessive overhead in execution even in small systems (see Sec. 5.3). We found that the overhead arose from redundant, nested regions (i.e., regions with the same set of influencing options), and regions executed repeatedly in loops. Subsequently, we identified optimizations to reduce measurement overhead through instrumenting different regions without altering the performance-influence model that we produce. Specifically, we perform optimizations that preserve the following two invariants.

Invariant 1 (Expand regions): Statements not influenced by options can be added to a region without altering the performance-influence model that is generated and without increasing measurement effort. Statements not influenced by options contribute the same execution time to all configurations. Therefore, including these statements in a region increases the execution time of the region equally for all configurations, but does not affect the performance difference among configurations used to build the performance-influence model.

Example:

Consider the statement in Line 12 and Region $R_{2}$ in our running example. The statement takes $1$ second to execute and Region $R_{2}$ takes $2$ seconds to execute when option A is enabled, from which we can derive the partial performance-influence model $\Pi_{R_{2}}=1+2\texttt{A}$. Since the statement is not influenced by any options, we can include it in the region, now observing $1$ or $3$ seconds executions depending on whether A is enabled, preserving the same $2$ seconds difference and resulting in the same model.

Invariant 2 (Merge regions): $\mathit{GI:\mathcal{P}(\mathcal{P}(O))}$ is the set of all interactions in the system. Two consecutive regions or an outer and an inner region influenced by interactions $\mathit{i_{1}\in GI}$ and $\mathit{i_{2}\in GI}$ can be merged if $\mathit{i_{1}\cup i_{2}\in GI}$ without altering the performance-influence model that is generated and without increasing measurement effort. Merging two consecutive regions or an outer and an inner region forms an interaction between the options that influence both regions. Therefore, we have to sample all combinations of the interaction to obtain their influence on the region. If that interaction is already present in the system, we already sample all these configurations anyway. Therefore, we can merge these regions into one that is influenced by the interaction of the two regions. As stated in invariant $1$, merging does not affect the absolute performance difference used to build the performance-influence model. By merging regions, especially nested regions within loops, we significantly reduce the number of regions that are executed, which significantly reduces the overhead of measuring the instrumented system.

Example:

Consider regions $R_{2}$ and $R_{3}$ in our running example. Region $R_{2}$ is influenced by $\{A\}$ and region $R_{3}$ by $\{A,B\}$. We sample all $4$ combinations of A and B to conclude that Region $R_{2}$ takes $2$ seconds to execute when option A is enabled and Region $R_{3}$ takes $3$ seconds when both A and B are enabled, resulting in the partial performance-influence model $\Pi_{R_{2}+R_{3}}=2\texttt{A}+3\texttt{AB}$. Since we already sample all configurations for interaction $\{A,B\}$ and since $\{A\}\cup\{A,B\}$ does not create a new interaction, we can merge both regions into one that is influenced by interaction $\{A,B\}$ without having to sample more configurations. In this case, the merged region would take $2$ seconds when A is enabled and $5$ seconds when both A and B are enabled, resulting in the same performance-influence model when we calculate the actual influence of enabling both A and B (i.e., $+3$ seconds). With the same reasoning, we can also merge regions $1$ and $2$ in our running example.

We developed two algorithms (Algorithm 3 and Algorithm 4) that use the invariants to propagate the options that influence statements up and down a control-flow graph (i.e., intraprocedually), as well as across graphs (i.e., interprocedually), to expand, merge, and pull out regions. The propagation in Algorithm 3 merges consecutive regions (Lines 3–3) and expands where regions end. The propagation in Algorithm 4 pulls out nested regions and expands where regions start. Obeying our invariants, both algorithms never create new interactions nor do they alter the performance-influence model that we generate, but significantly reduce the overhead of measuring the instrumented system. After propagation, we identify the regions and instrument them as before (Algorithm 2).

The propagation algorithms are non-deterministic (i.e., different results are obtained depending on the order in which regions are merged). In fact, different orderings can be used to optimize for different goals. Assuming that most of the overhead occurs in nested regions, especially those inside loops, we prioritize pulling regions out of loops. (We experimented with other orderings and the results were similar to Table 7). Fig. 4b presents an optimized instrumentation that prioritizes our goal, in which we pulled out the region in the callee.

3.4 Executing the Instrumented System

After instrumentation, we can now execute the system with the compressed set of configurations ($CC$, Sec. 3.2) and track execution times for each region. We produce a configuration performance map $CP$, which maps each region $R$ in each executed configuration to a corresponding execution time $T$ ($\mathit{CP:CC\rightarrow(R\rightarrow T)}$).

At the start and end of every region, we record the current time and log the difference as the execution time of the region. Since regions might be nested during execution, we also keep a stack of regions at runtime and subtract the time of nested regions from the time of outer regions. This additional step can become a source of overhead for deeply nested regions, which is what we observed in the unoptimized instrumented systems. We tried building a trace of regions and processing the execution times after the system finished executing. However, due to the large number of regions that were executed, the systems ran out of memory. Our evaluation shows that the dynamic processing incurs low overhead (Sec. 5.3).

Example:

Table 3 presents a configuration performance map for the two optimized regions and compressed set of four configurations of our running example.

3.5 Building the Performance-Influence Model

Our final step is to build the performance-influence model $\Pi$ that predicts the performance of each configuration $(\Pi:\mathit{C\rightarrow T})$, based on the configuration performance map ($\mathit{CP:CC\rightarrow(R\rightarrow T)}$, Sec. 3.4) and the region influence map ($\mathit{RI:R\rightarrow\mathcal{P}(O)}$, Sec. 3.3).

To build the global performance-influence model, we first build local models for each region separately and subsequently aggregate them. A local model contains performance terms for all combinations of options that are associated with the region (using $RI$), in the form $\Pi_{r}=t_{1}XY+t_{2}X\neg Y+t_{3}\neg XY+t_{4}\neg X\neg Y$ for a region $r$ with options X and Y (or $\Pi_{r}=t_{4}+(t_{2}-t_{4})X+(t_{3}-t_{4})Y+(t_{1}-t_{2}-t_{3}+t_{4})XY$ to highlight the influence of options and avoid negated terms) (Siegmund et al., 2012a). If a region has been executed multiple times for the same combination of options in one configuration, the execution time $t_{i}$ should not differ beyond usual measurement noise (since other options should not influence the region), thus we average the execution time.

The global performance-influence model $\Pi$ is obtained by aggregating all local performance-influence models. Note that local models can be useful for understanding and debugging the individual regions in the system.

Example:

With the measurement times in Table 3, we build the local models of the base region as $\Pi_{\texttt{Base}}$ = 1 (averaged over 4 executions) and of the other two regions as $\Pi_{\texttt{OR}_{1}}$ = 3A$\neg$C + 6AC = 3A + 3AC and $\Pi_{\texttt{OR}_{2}}$ = 3AB, resulting in the overall model $\Pi=1+3\texttt{A}+3\texttt{AB}+3\texttt{AC}$.

4 Implementation

To show the feasibility of our white-box approach, we implemented ConfigCrusher for Java systems and made it publicly available (Velez et al., 2019). Its modular design allows ConfigCrusher to analyze systems in any programming language; only the data-flow analysis (Sec. 3.1) and instrumentation (Sec. 3.3) components have to target the specific language (Fig. 3).

There are several strategies to track data-flow in a system: manual tracking, static analysis (Rabkin and Katz, 2011; Arzt et al., 2014; Lillack et al., 2018; Enck et al., 2010; Qiu et al., 2018; Dong et al., 2016), and dynamic analysis (Bell and Kaiser, 2014; Meinicke et al., 2016; Nguyen et al., 2016; Reisner et al., 2010; Yang et al., 2016; Austin and Flanagan, 2012, 2009). We used the state of the art (Do et al., 2017; Qiu et al., 2018; Wang et al., 2016; Pauck et al., 2018) object-, field-, context-, and flow-sensitive static taint analysis engine FlowDroid (Arzt et al., 2014). A taint analysis, typically used in the security domain, tracks what variables have been affected by selected inputs (sources) and are used in specific locations (sinks). We annotated the API calls to load configurations options as sources and control-flow statements as sinks.

We used the ASM library (Bruneton et al., 2002) to add bytecode instructions to measure the execution time of regions. We used the Soot framework (Vallée-Rai et al., 1999) to build the call graph of a system to optimize the instrumentation of regions.

Limitations.

Our ConfigCrusher implementation is limited to analyzing single-threaded systems, as we dynamically process the execution time of regions, keeping a stack of regions at runtime to subtract the time of nested regions from the time of outer regions. Having one region executing at a time facilitates the processing and calculations that we perform. Other measurement strategies could be used, such as using a performance profiler, to measure the execution time of regions in multi-threaded systems.

At its core, the used static taint analysis is unsound and can lead to overtainting (Qiu et al., 2018; Wang et al., 2016), which can affect the results of our approach. For instance, at the one extreme, if the analysis misses all interactions, we will fail to produce a performance-influence model. At the other extreme, if the analysis indicates that all options interact, our approach results in the Brute Force approach. In addition, despite the high precision of FlowDroid (Arzt et al., 2014), the analysis is challenged by the size of the call graph, which restricts the size of the systems that our implementation of ConfigCrusher can analyze (Avdiienko et al., 2015; Arzt et al., 2014; Bodden, 2018; Lerch et al., 2015; Do et al., 2017; Qiu et al., 2018; Wang et al., 2016; Pauck et al., 2018). Similar to other approaches (Avdiienko et al., 2015; Qiu et al., 2018; Lillack et al., 2018), we reduced the precision of some FlowDroid specific settings (e.g., used an unexceptional control-flow graph) for a faster analysis (the analysis ran out of memory for systems $3$ – $10$ in Table 4 using the default settings). Despite running the static analysis on a server with $512$ GB of RAM and $32$ CPU cores, we were forced to exclude some systems from our evaluation since the server either used all of its memory or did not finish the analysis after $4$ hours. Avdiienko et al. (Avdiienko et al., 2015) experienced similar results on a server with more RAM and CPU cores. Nevertheless, our evaluation demonstrates the feasibility of our implementation to produce accurate and informative performance-influence models, signifying that our approach is robust despite the levels of unsoundness and overtainting of FlowDroid. We expect that incorporating advancements in scaling taint analyses (Do et al., 2017; Bodden, 2018; Lerch et al., 2015; Christakis and Bird, 2016; Barros et al., 2015; Andreasen et al., 2017; Späth et al., 2017; Garbervetsky et al., 2017; Zhang and Su, 2017), the results in this article and the benefits of our approach will generalize to larger systems. We conjecture that similarly accurate results can be achieved with other taint analysis implementations.

5 Evaluation

To demonstrate the feasibility and potential of our white-box approach, we evaluate ConfigCrusher against state of the art approaches to build performance-influence models, for a specific workload, input size, and underlying hardware, in terms of the cost (i.e., number of configurations to sample and time to execute those configurations) to generate performance-influence models and their accuracy. Subsequently, we explore the usefulness of ConfigCrusher’s local performance-influence models to identify the local influence of options on performance. Specifically, we address the following research questions:

RQ1: How does ConfigCrusher compare to other performance-influence modeling approaches in terms of cost and accuracy? We compare the effectiveness of ConfigCrusher regarding the cost of generating models and their accuracy to state of the art black-box and white-box approaches.

RQ2: How much overhead is induced by instrumentation? One of the goals of ConfigCrusher is to build performance-influence models efficiently. As discussed in Sec. 3.3, we observed an excessive amount of overhead when executing our unoptimized instrumented systems. We evaluate the effectiveness of our optimization by exploring how much overhead the instrumented regions induce and how it affects the performance that we measure.

RQ3: To how many regions can the influence of options on performance be localized? One of the benefits of ConfigCrusher over state of the art approaches is that it builds local performance-influence models, which indicate whether and how the options locally influence the performance of a system. In an exploratory analysis, we examine the local performance-influence models to determine the local influence of options on performance. Subsequently, we analyze the source code regions corresponding to the local models to further investigate how they are influenced by options. We conjecture that this type of information, derived from the local models, can provide insights to developers and maintainers for enhanced analysis of individual components of a system.

5.1 Subject Systems

The subject systems are summarized in Table 4. We selected a representative set of configurable systems that satisfy the following criteria: (a) systems from a variety of domains to increase external validity, (b) systems with at least $5$ options (the Brute Force approach would produce results cheaply for systems with few options), (c) systems with characteristics representative of large-scale configurable systems (e.g., systems with binary and non-binary options), (d) single-threaded systems with deterministic execution time (we sampled each system multiple times with different approaches and observed execution times within usual measurement noise), and (e) systems for which the static taint analysis terminated. We included systems that have been used in previous studies, for comparability of results (systems $4$, $7$, $8$) (Kim et al., 2013; Siegmund et al., 2013; Souto et al., 2017), and new configurable systems with a total of $860$+ stars and $155$+ forks on GitHub, and used by $160$+ open-source projects, at the time of writing, to showcase the applicability of our approach ($2$, $3$, $5$, $6$, $8$, $9$, $10$). In the following sections, we consider the entire system of Fig. 2 (Lines 1–32) as the Running Example (system $1$ in Table 4) to showcase the potential of our approach.

Due to their novelty, white-box approaches impose strict limitations on the systems they can analyze (Siegmund et al., 2013; Kim et al., 2013; Souto et al., 2017). ConfigCrusher lifts some of these limitations; we consider data-flow interactions and do not limit the analysis to specific system implementations, which expands the types of systems that can be analyzed and increases the accuracy of the results. Still, the used implementation of static code analysis imposes limitations on the size of systems and their number of configuration options. We acknowledge the size of the real-world systems used in the evaluation and that black-box approaches can analyze larger systems. However, at this stage, we want to showcase the feasibility, benefits, and potential of white-box analyses and expect that, with improvements to the used data-flow analysis (Do et al., 2017; Bodden, 2018; Lerch et al., 2015; Christakis and Bird, 2016; Barros et al., 2015; Andreasen et al., 2017; Späth et al., 2017; Garbervetsky et al., 2017; Zhang and Su, 2017), our implementation will analyze larger systems. Nevertheless, we selected systems for our evaluation with representative characteristics of larger configurable systems (i.e., we observed the insights of Irrelevance, Orthogonality, and Low-Interaction Degree of configurable systems). Hence, the systems that we selected are suitable to answer our research questions and we conjecture that we can obtain similar results (Sec. 5.2) in larger systems with a more scalable implementation of the static taint analysis. Note the general trend in the results (Sec. 5.2): all other state of the art white-box approaches have the same scalability problem. Still, ConfigCrusher was able to analyze real-world systems which the other approaches could not; SPLat did not scale to Density Converter (system $10$ in Table 4) and the family-based approach could not analyze any system besides the software product lines.

Although our static analysis correctly identified that all options interact in Elevator ($4$), since it was purposely built with such behavior (Meinicke et al., 2016; Kim et al., 2013; Souto et al., 2017) (i.e., our approach equals the Brute Force approach), we included the system in the evaluation since it is one of the two systems that the family-based approach can analyze.

5.2 RQ1: Comparison to State of the Art

With RQ1, we evaluate the cost and accuracy of the performance-influence models generated by ConfigCrusher and how it compares to state of the art black-box and white-box approaches. To answer this question, we measured the cost and prediction error of ConfigCrusher and all other approaches and compared them to the ground truth.

Procedure:

We established ground truth by measuring the performance of the entire configuration space four times and averaged the performance of each configuration. Due to the high number of configurations and execution time of Sort ($9$) and Density Converter ($10$), we randomly sampled a large number of configurations each to act as the ground truth. We observed no variation in the errors of the results presented in Table 6 and Table 6 when using more than $1000$ configurations.

Specifically, we compared ConfigCrusher to feature-wise sampling (i.e., enable one option at a time) and pair-wise sampling (i.e., cover all combinations of all pairs of options) (Medeiros et al., 2016) with stepwise linear regression (Sarkar et al., 2015; Siegmund et al., 2012a, b, 2015), Brute Force, SPLat (Kim et al., 2013), and the family-based approach (Siegmund et al., 2013). We excluded random sampling since research (Jamshidi et al., 2017b, a; Medeiros et al., 2016; Siegmund et al., 2015) has shown that it requires numerous samples to make accurate predictions and it is not clear how many configurations to sample for a specific system.

We conjectured that SPLat behaves essentially like the Brute Force approach in all but software product lines, since all configuration options are read at the start of the system. We included a SPLat variant, called SPLatDelayed (SAD), for which we modified the source code of the systems to delay the evaluation of options in control-flow statements (Saumont, 2017). The source code refactoring allowed us to evaluate how SPLat would operate in systems if it could detect when options are actually evaluated in control-flow decisions.

The static taint analysis and the performance measurements were executed on a $2.2$ GHz Intel Core i$7$ MacBook Pro with $16$ GB of RAM running OS X $10.13$ (i.e., fixed underlying hardware). For each configuration, we initiated one VM invocation and ran the configuration (Georges et al., 2007). We used the JVM options "-Xms10G -Xmx10G --XX:+UseConcMarkSweepGC" to reduce the overhead of garbage collection. To control for measurement noise, we measured each configuration five times and averaged the performance of each configuration. For each system, we extracted the configuration options from the projects’ documentation and executed a representative test scenario and workload provided by the system (i.e., fixed workload and input size) (Velez et al., 2019). Following the evaluation of state of the art approaches (Lillack et al., 2018; Meinicke et al., 2016; Siegmund et al., 2013; Guo et al., 2013; Sarkar et al., 2015; Siegmund et al., 2012a, b, 2015; Medeiros et al., 2016; Al-Hajjaji et al., 2016; Halin et al., 2018; Kim et al., 2013), we discretized the non-binary options (e.g., pick either the lowest or highest value) to reduce the number of samples to execute.

Cost Metric.

We measured the number of configurations and sampling time to generate a model. For ConfigCrusher, we also measured the one-time overhead of the static analysis.

Error Metric.

We used the Mean Absolute Percentage Error (MAPE) to measure the mean difference between the values predicted by a model and the values actually observed (i.e., ground truth). For each approach, we calculate the prediction error on the configurations that the approach did not sample. We also calculated the error across all configurations (Velez et al., 2019). We used the multiple comparison T̃-procedure (Konietschke et al., 2012) with $95\%$ confidence to compare statistical differences between ConfigCrusher’s prediction error to the prediction error of each of the other approaches.

Results:

We show the cost results in Table 6 and the error results in Table 6. ConfigCrusher’s prediction error is statistically indistinguishable or lower than other approaches. Furthermore, ConfigCrusher’s high accuracy is usually achieved with lower cost compared to the other accurate approaches. Our results support our conjecture on the cost and prediction error comparison of Fig. 1.

Though feature-wise and pair-wise sampling tended to have lower costs than ConfigCrusher, when their errors are taken into account, we can conclude that more configurations had to be sampled to make accurate predictions. By comparison, for those systems, ConfigCrusher sampled more configurations, but attained significantly lower errors.

As we conjectured, SPLat behaves essentially like the Brute Force approach in all but software product lines. We also conjectured that SPLatDelayed would produce the lowest error since it uses a heuristic to perform a more efficient Brute Force approach. For the Running Example ($1$), Pngtastic Counter ($2$), Pngtastic Optimizer ($3$), and Sort ($9$), in which other approaches besides SPLatDelayed produced lower errors, but statistically indistinguishable, we can attribute the results to measurement noise. Interestingly, SPLatDelayed did not finish analyzing Density Converter ($10$) within $24$ hours. In this case, most options are read sequentially (similar to reading all options at the beginning of the system), thus indicating the limitations of the approach.

Only for Elevator ($4$) and Email ($7$), the family-based approach remains the most efficient and accurate approach, but, at the same time, the most limited one in terms of applicability.

Characteristics of interactions discussion:

Thanks to ConfigCrusher, we observed and confirmed the insights of Irrelevance, Orthogonality, and Low Interaction Degree of configurable systems. In $9$ out of $10$ systems, it significantly reduced the configuration space to sample, thus reducing the cost to build accurate models. For example, our analysis identified the irrelevant options in our running example ($1$), Grep ($5$), and Sort ($9$), which is not leveraged by the black-box approaches before sampling. Similarly, ConfigCrusher identified orthogonal interactions and leveraged low interaction degree to sample fewer configurations, which was not exploited by the white-box approaches.

For Pngtastic Counter ($2$), Pngtastic Optimizer ($3$), and Kanzi ($6$), the black-box approaches produced accurate models with low cost. Upon inspection of the results, we discovered that (a) in Pngtastic Counter, the options did not affect the performance of the system; the execution time was essentially the same for all configurations, and (b) in Pngtastic Optimizer and Kanzi, the options did affect the performance, but the execution times were clustered in a few groups. For example, the performance of Kanzi under all configurations was either ${\sim}4$ seconds or ${\sim}61$ seconds. We consider these three systems as outliers since previous empirical studies (Siegmund et al., 2015; Apel et al., 2013; Jamshidi et al., 2017b; Kolesnikov et al., 2018) have shown that the performance of most configurable systems changes based on the selected configurations.

Source of prediction error discussion:

Regarding ConfigCrusher’s prediction error of Email ($7$), the system has a feature model (Apel et al., 2013) that describes its valid configurations. Since the invalid configurations were not executed, ConfigCrusher did not have all the information for each region to generate an accurate model. Despite missing information, ConfigCrusher was able to produce more accurate results than the other approaches, except the family-based approach. We hope to incorporate information from a feature model to produce more accurate models for this type of systems.

Regarding ConfigCrusher’s prediction error of Prevayler ($8$), we observed that the execution time of certain regions differed beyond usual measurement noise. This behavior occurs when the correct interaction in the regions was not captured by the static analysis (a possible consequence of the unsoundness of the used taint analysis). We were unable to manually determine the correct interaction of the problematic regions. We conjecture that, since the system writes to disk, there might be some interactions in system calls, which we do not analyze. Despite this imprecision, ConfigCrusher was able to produce more accurate results than the other approaches. We hope to overcome this issue by analyzing system calls to obtain even more accurate results.

RQ1: ConfigCrusher’s prediction error is statistically indistinguishable or lower than other approaches. ConfigCrusher’s high accuracy is usually achieved with lower cost compared to the other accurate approaches.

5.3 RQ2: Instrumentation Overhead

As explained in Sec. 3.3, we observed excessive overhead when executing our instrumented systems. With RQ2, we investigate how much overhead is induced by instrumenting regions. To answer this question, we compared the instrumentation overhead and execution times of uninstrumented systems with systems instrumented with the unoptimized Algorithm 2 and with systems instrumented with the optimized Algorithm 2 and the propagation Algorithms 3 and 4.

Procedure:

We used the execution time of the uninstrumented systems as ground truth and executed the configuration that triggered the most number of regions in the optimized systems. We executed the configuration with the highest execution time in case of multiple configurations with the same number of executed regions.

Static and Dynamic Overhead Metric.

We measured the number of instrumented regions as the static overhead and the number of times the regions were entered and exited as the dynamic overhead.

Time Metric.

We measured the execution times of the unoptimized and optimized instrumentations.

Results:

Table 7 shows the results of our analysis. ConfigCrusher’s optimized instrumentation with Algorithm 2,  3, and 4 reduced the number of regions and overhead by several orders of magnitude. By contrast, the unoptimized instrumentation, Algorithm 2, created an excessive amount of overhead, preventing running systems in a reasonable amount of time.

Only the systems Running Example ($1$), Email ($7$), and Density Converter ($10$) had a low unoptimized dynamic overhead and executed in similar time compared to the original systems. These systems do not have deeply nested regions, which does not increase the overhead of the dynamic analysis. Prevayler ($8$), which has similar structure to the previous systems, executed a large number of optimized instrumented regions with low overhead.

We can attribute the lower execution times of the instrumented systems compared to the original systems of the Running Example ($1$), Grep ($5$), and Email ($7$) to measurement noise.

RQ2: ConfigCrusher’s optimized instrumentation incurs orders of magnitude less overhead compared to the unoptimized instrumentation.

5.4 RQ3: Performance Influence of Options in Regions

One of the benefits of ConfigCrusher over black-box approaches is that it builds local performance-influence models, which indicate whether and how options locally influence the performance of a system. With RQ3, we investigate to how many regions the influence of options on performance can be localized. To answer this question, we analyzed all local performance-influence models to determine the local influence of options on performance. Subsequently, we manually examined the source code regions corresponding to the local models to further understand how they are influenced by options. We conjecture that this type of information, derived from the local models, can provide insights for enhanced analysis of individual components of a system.

Procedure:

We classified all local performance-influence models into two categories according to how options influence their performance. Then, we manually analyzed all corresponding source code regions to understand how they are influenced by options. For example, we classified the following models from Pngtastic Optimizer ($3$):

• •

$\Pi_{\texttt{9cb}}$ = 0.0

• •

$\Pi_{\texttt{b15}}$ = 1.5

• •

$\Pi_{\texttt{b1a}}$ = 0.2 + 82.5Compress + 142.1CompressIter + ...,

as "Not influenced by options" (e.g., $\Pi_{\texttt{9cb}}$ and $\Pi_{\texttt{b15}}$) and "Influenced by options" (e.g., $\Pi_{\texttt{b1a}}$).

Results:

Table 8 shows the results of our analysis. ConfigCrusher helped us to identify that the influence of options on performance can be localized to a few regions in a system. In these regions only subsets of all options interact. The local performance-influence models helped us to easily locate these regions in the source code to further analyze this performance behavior. In all such regions (e.g., Region b1a above), the options influenced a loop or a control-flow statement within a loop, which either manipulated data structures or performed I/O operations. These structures were sometimes located in the method where the region was instrumented, but other times we performed manual probing to find them in other methods called from the instrumented method.

Local models discussion.

The local performance-influence models indicate the options that interact in the corresponding regions and whether and how they locally influence the performance of the system. The exploratory analysis of the corresponding source code regions yielded some interesting findings of how options are implemented in these systems, which cannot be found with black-box approaches.

In a few regions, the control-flow statements with non-negligible execution time depended on options, yet the same branch of the control-flow statement was executed for all configurations. This behavior was surprising since we selected, based on the systems’ documentation, configuration values for each option that should behave differently. In fact, we discovered that two options of Pngtastic Counter ($2$) were not used in the source code as they were described in the documentation. For example, the valid range of an option was $0.0-1.0$, and we conjecture that the system would behave differently by picking different values. However, the control-flow statement where this option was used always executed the same branch if the value was $>0$. Finding these inconsistensies, common in configurable systems (Xu et al., 2013; Rabkin and Katz, 2011; Han and Yu, 2016; Cashman et al., 2018), might be useful for developers and maintainers to debug these type of systems.

Interestingly, some options influenced only regions with negligible execution time. This behavior was surprising since we expected, based on the systems’ documentation, that the options would influence the performance of the systems; for example, how the options that influence Region 9cb above drastically change its execution time. We manually confirmed that they involve either a few statements or did not contain expensive loops nor calls. While black-box approaches also found that these options do not influence the performance, ConfigCrusher helped us to pinpoint the regions where these options are used to understand this potentially unexpected behavior.

We conjecture that developers can potentially discern similar findings in other configurable systems to make more informative decisions during debugging and optimization of these systems.

RQ3: ConfigCrusher helped us to identify that the influence of options on performance is localized to a few regions in a system. The options influence loops or control-flow statements within loops.

5.5 Threats to Validity

The primary threat to external validity is the selection of subject systems. As discussed in Sec. 5.1, we were limited by the overhead and precision of the static analysis. This limitation is due to the novelty of our approach and shared with other white-box approaches, though we lift some of their limitations. While we selected a set of widely-used open-source Java configurable systems from different domains, readers should be careful when generalizing results to other types of systems. For instance, we analyzed single-threaded systems with deterministic execution time. Additionally, we analyzed and built a performance-influence model for a single configurable system. Systems composed of numerous configurable systems, deployed in distributed environments, and implemented in different languages are beyond the scope of this article.

Another threat to validity is the subset of options that we selected for analysis in the subject systems. We selected options for which the systems’ documentation or the options’ functionality indicated that they would affect performance and observed a wide range of execution times for the configurations that we measured.

Another threat to validity is the selection of the data-flow analysis. As discussed in Sec. 4, we selected the state of the art static taint analysis, but reduced its precision in favor for an analysis that terminates. This strategy has been used in previous work and, as demonstrated in our evaluation, our approach is robust and produces accurate results with the settings that we selected.

Measurement noise cannot be excluded and may affect the results we obtained. We reduced this threat by repeating measurements several times on a dedicated machine and averaging the results.

6 Related Work

In Sec. 2, we described performance modeling in general and closely related state of the art black-box and white-box approach for performance-influence modeling and compared them to ConfigCrusher. In this section, we discuss additional research to position ConfigCrusher and white-box analyses in the context of prior work.

Analysis of configurable systems: Similar to our work, several researchers have leveraged some kind of program analysis to explore various properties of configuration options (Hoffmann et al., 2011; Nguyen et al., 2016; Dong et al., 2016; Rabkin and Katz, 2011; Wang et al., 2013; Souto and d’Amorim, 2018; Reisner et al., 2010; Meinicke et al., 2016). Thüm et al. (Thüm et al., 2014) presented a comprehensive survey of analyses for software product lines also applicable to configurable systems.

Similar to our approach, Lillack et al. (Lillack et al., 2018) used taint analysis to identify, for each code fragment, in which configurations it may be executed. However, they do not track information about individual options. Instead, our taint analysis tracks how options influence code fragments due to control-flow and data-flow interactions to track how options influence the performance of the system.

Hoffmann et al. (Hoffmann et al., 2011) used dynamic influence tracing to convert static parameters into dynamic control variables to adapt properties of an application. However, they do not consider interactions beyond two parameters. By contrast, our approach tracks control-flow and data-flow interactions among options, without a limit on the interaction degree, and how they influence the performance of the system.

Reisner et al. (Reisner et al., 2010) and Meinicke et al. (Meinicke et al., 2016) used symbolic execution and variational execution, respectively, to analyze the behavior of interactions in configurable systems and found the insights of Irrelevance, Independence, and Low Interaction Degree that we consider in this work . We leverage those insights to create a novel white-box performance analysis that efficiently generates accurate performance-influence models.

Testing configurable systems: Combinatorial Testing (Kuhn et al., 2013; Nie and Leung, 2011; Hervieu et al., 2011, 2016; Halin et al., 2018) is an approach to reduce the number of samples to test a system by satisfying a certain coverage criterion. Similarly, Souto et al. (Souto et al., 2017) improved SPLat (Kim et al., 2013) to use sampling heuristics (Medeiros et al., 2016) to select what configurations to sample. While both these approaches scale to large systems, they make assumptions on how options interact in the system and can potentially miss relevant interactions. Instead, our sampling is guided by white-box information on how options are used and interact in the systems.

Performance profiling: Several profiling techniques, including sampling and instrumentation, can be used to identify performance hot spots (Mostafa et al., 2017; Yu and Pradel, 2018; Cito et al., 2018; Gregg, 2016). For example, Castro et al. (Castro et al., 2015) used both techniques to identify hot spots that can be isolated and replayed as standalone systems for further performance analysis and optimization. Our approach is complementary to this line of work, assisting in potentially narrowing down the performance-intensive components for more comprehensive profiling.

Energy measurement: Modeling power or energy consumption is closely related to performance and employs similar techniques (Jabbarvand et al., 2016; Gupta et al., 2014; Gui et al., 2016). For example, Hao et al. (Hao et al., 2013) used program analysis to estimate the energy consumption of instructions of Android apps. This line of work, however, does not address configurability, but could benefit from our approach to understand how the configuration of the system influences its energy consumption.

7 Conclusion

This article presents ConfigCrusher, a white-box performance analysis approach for configurable systems. ConfigCrusher employs a data-flow analysis to identify how configuration options may influence control-flow statements and instruments regions corresponding to those statements for performance measurement. Our evaluation on $10$ real-word systems shows the potential of our white-box approach to builds similar or more accurate performance-influence models than other approaches with lower cost. In contrast to state of the art approaches, our white-box approach provides additional information of the components of a system, which can aid stakeholders to analyze, optimize, and debug them. Our work can provide a foundation for future research on white-box analysis for configurable systems, such as understanding the performance of larger and distributed systems, explaining causes for performance differences, and combining white-box and black-box approaches for more accurate and efficient performance analysis.

8 Acknowledgments

This work has been supported in part by the NSF (awards 1318808, 1552944, and 1717022), AFRL, DARPA (FA8750-16-2-0042), and the German Research Foundation (AP 206/7-2, AP 206/11-1, SI 2171/2, SI 2171/3-1). We thank Chu-Pan Wong and Jens Meinicke for their comments during the development of this work. We thank the FOSD 2017 and 2018 meeting participants for their feedback on the central idea of this work. We thank Steven Artz for his help with FlowDroid.