SAT-based analysis of large real-world feature models is easy

The customer oriented individualization of products is getting more and more important for the production industry. Especially in car manufacturing industry we can observe a dramatically increasing number of product variants not only related to different car concepts but also concerning different functionality as for example in car entertainment. In order to cope with this increasing complexity in terms of product features and their interrelationships, manufacturers more and more build on a formal approach called feature modeling that allows for a formal analysis of the specified variability artifacts with the help of specialized proving engines as for example SAT-solvers. The development of such proving engines and their test is quite complicated also due to the fact that manufacturers do not disclose the real development data for understandable reasons. Thus, a framework is needed that enables the proving engine developers to test their engines on nearly real data and to show the potential and possibilities of their engines without having the real development data at hand. This paper presents a framework for generating especially large parameterized feature models used for load testing and benchmarking feature model analysis tools, as well as two usage scenarios: the first one runs a typical benchmark with large feature models on two versions of the theorem prover SPASS, the second shows the integration of the generator in a client-server environment where its functionality is hosted on a website, i.e. using the browser as a frontend working on tablets and modern smartphones.

Software product lines are able to describe multiple products sharing a common base of features and are commonly described as feature models. For complex software product lines, automatic analyses are required to ensure validity and to improve the interactive configuration process. Modern SAT solvers are vital components for the validation process of feature models. The increasing variability of software product lines implies the need to use more expressive solvers like SMT solvers. To assist the development of feature modeling tools, we compare SAT and SMT solvers for the automated analysis of feature models. During this thesis, we create an abstract data type to formally define analyses for feature model defects and their explanations. The result shows that SAT solvers are more efficient at detecting the defects, while SMT solvers can find explanations for them multiple times faster. Feature models can be further expanded by attaching attributes to features. Such attributes may contain a numerical value. Additionally, one attribute can be defined for multiple features. In this thesis, we aim to support the interactive configuration process, by providing the range of the sum of values for an attribute. Such ranges depend on the remaining choices in a configuration of the product line. We provide an exact computation using SMT and an approximation using a heuristic. The evaluation results show that an SMT solver is not suitable for supporting interactive configuration. However, the approximated ranges of the provided heuristic were very close to the exact ones.

Feature models are widely used for describing the variability of a software product line. A feature model contains a tree of features and a set of constraints over these features, which define valid feature combinations. In the industrial practice, large feature models containing hundreds of features and constraints are common. Furthermore, in a hierarchical product line a feature model can be related to other feature models through inter-model constraints. Due to the model size and complexity, understanding industrial feature models is a challenging task.In this paper, we describe the feature model understanding challenges reported by feature model developers at Robert Bosch GmbH. To support the developers in model understanding, we extend the idea of a feature implication graph to feature relation graph by abstracting groups of implications to feature relations. A transitively closed relation graph shows all modeled and implicit feature relations and spans all related feature models. The graph is also used to identify modeling problems, such as false optional or dead features, and to show the derivation of any implicit relation or problem from the modeled constraints. In a case study at Bosch, we evaluate the use of feature relation graph for model understanding. We propose further use cases of the graph, supporting model maintenance, evolution and configuration.

Feature models (FMs) are a popular formalism for describing the commonality and variability of software product lines (SPLs) in terms of features. SPL development increasingly involves manipulating many large FMs, and thus scalable modular techniques that support compositional development of complex SPLs are required. In this paper, we describe how a set of complementary operators (aggregate, merge, slice) provides practical support for separation of concerns in feature modeling. We show how the combination of these operators can assist in tedious and error prone tasks such as automated correction of FM anomalies, update and extraction of FM views, reconciliation of FMs and reasoning about properties of FMs. For each task, we report on practical applications in different domains. We also present a technique that can efficiently decompose FMs with thousands of features and report our experimental results.

Many real-world problems are encoded into SAT instances and efficiently solved by CDCL (Conflict-Driven Clause Learning) SAT solvers. However, some scenarios require distributed problem solving approaches. Privacy is often the main reason. This motivates the need to solve distributed SAT problems We analyze how this problem can be tacked in an efficient way, and present ABTSAT, a new version of the ABT (Asynchronous Backtracking) algorithm adapted to solve distributed SAT instances. It combines ABT execution with calls to CDCL SAT solvers and clause learning. ABTSAT is sound and complete, properties inherited from ABT, and solves local problems efficiently by using CDCL SAT solvers.

The Boolean Satisfiability Problem (SAT) is well known in computational complexity, representing the first decision problem to be proved NP-complete. SAT is also often the subject of work in proof complexity. Besides its theoretical interest, SAT finds a wide range of practical applications. Moreover, SAT solvers have been the subject of remarkable efficiency improvements since the mid-1990s, motivating their widespread use in many practical applications including Bounded and Unbounded Model Checking. The success of SAT solvers has also motivated the development of algorithms for natural extensions of SAT, including Quantified Boolean Formulas (QBF), Pseudo-Boolean constraints (PB), Maximum Satisfiability (MaxSAT) and Satisfiability Modulo Theories (SMT) which also see application in the model-checking context. This chapter first covers the organization of modern conflict-driven clause learning (CDCL) SAT solvers, which are used in the vast majority of practical applications of SAT. It then reviews the techniques shown to be effective in modern SAT solvers.

Recent research on software product line engineering has led to several search-based frameworks for reverse engineering feature models. The most common fitness function utilized maximizes the number of matched products with an oracle set of products. However, to calculate this fitness each product defined by the chromosome has to be enumerated using a SAT solver and this limits scalability to product lines with fewer than 30 features. In this paper we propose \(\textit{SAT}_{\textit{ff}}\), a fitness function that simulates validity by computing the difference between constraints in the chromosome and oracle. In an empirical study on 101 feature models comparing \(\textit{SAT}_{\textit{ff}}\) with two existing fitness functions that use the enumeration technique we find that \(\textit{SAT}_{\textit{ff}}\) shows a significant improvement over one, and no significant difference with the other one. We also find that \(\textit{SAT}_{\textit{ff}}\) requires only 7 % of the runtime on average scaling to feature models with as many as 97 features.

Conflict-Driven Clause Learning (CDCL) SAT solvers can automatically solve very large real-world problems. IntSat is a new technique extending CDCL to Integer Linear Programming (ILP). For some conflicts, IntSat generates no strong enough ILP constraint, and the backjump has to be done based on the conflicting set of bounds. The techniques given in this article precisely analyze how and when that set can be translated into the required new ILP constraint. Moreover, this can be done efficiently. This obviously strengthens learning and significantly improves the performance of IntSat (as confirmed by our experiments). We also briefly discuss extensions and other applications.

Research on features has received much attention in the domain engineering community. Feature modeling plays an important role in the design and implementation of complex software systems. However, the presentation and analysis of feature models are still largely informal. There is also an increasing need for methods and tools that can support automated feature model analysis. This paper presents a formal engineering approach to the specification and verification of feature models. A formal semantics for the feature modeling language is defined using first-order logic. It provides a precise and rigorous formal interpretation for the graphical notation. In addition, further validation of the semantics using the Z/EVES theorem prover is presented. Finally, we demonstrate that the consistency of a feature model and its configurations can be automatically verified by encoding the semantics into the Alloy Analyzer. A case study of the Key Word in Context (KWIC) index systems feature model is presented to illustrate the verification process.

In mainstream conflict driven clause learning (CDCL) solvers, because of frequent restarts and phase saving, there exists a large proportion of duplicate assignment trails before and after restarts, resulting in unnecessary time wastage during solving. This paper proposes a new strategy—identifying those duplicate assignments trails and dealing with them by changing the sort order. This approach’s performance is compared with that of the Luby static restart scheme and a dynamic Glucose-restart strategy. We show that the number of solved instances is increased by 3.2% and 4.6%. We also make a compassion with the MapleCOMSPS solver by testing against application benchmarks from the SAT Competitions 2015 to 2017. These empirical results provide further evidence of the benefits of the proposed heuristic, having the advantage of managing duplicate assignments trails and choosing appropriate decision variables adaptively.

Given a CNF formula F on n variables, the problem of model counting, also referred to as #SAT, is to compute the number of models or satisfying assignments of F. Recent years have witnessed a surge of effort towards developing efficient algorithmic techniques that combine the classical strongly 2-universal hash functions (from [Stockmeyer 1983]) with the remarkable progress in SAT solving over the past decade. These techniques augment the CNF formula F with random XOR constraints and invoke an NP oracle repeatedly on the resultant CNF-XOR formulas. In practice, the NP oracle calls are replaced by calls to a SAT solver and it is observed that runtime performance of modern SAT solvers (based on conflict-driven clause learning) on CNF-XOR formulas is adversely affected by the size of XOR constraints. The standard construction of 2-universal hash functions chooses every variable with probability p = 1/2 leading to XOR constraints of size n/2 in expectation. Consequently, the main challenge is to design sparse hash functions, where variables can be chosen with smaller probability and lead to smaller sized XOR constraints, which can then replace strongly 2-universal hash functions. In this paper, our goal is to address this challenge both from a theoretical and a practical perspective. First, we formalize a relaxation of universal hashing, called concentrated hashing, a notion implicit in prior works to design sparse hash functions. We then establish a novel and beautiful connection between concentration measures of these hash functions and isoperimetric inequalities on boolean hypercubes. This allows us to obtain tight bounds on variance as well as the dispersion index and show that p = O(log2 m/m) suffices for the design of sparse hash functions from {0, 1}n to {0, 1}m belonging to the concentrated hash family. Finally, we use sparse hash functions belonging to this concentrated hash family to develop new approximate counting algorithms. A comprehensive experimental evaluation of our algorithm on 1893 benchmarks demonstrates that the usage of sparse hash functions can lead to significant speedups. To the best of our knowledge, this work is the first study to demonstrate runtime improvement of approximate model counting algorithms through the usage of sparse hash functions, while still retaining strong theoretical guarantees (a la 2-universal hash functions).

The dramatic improvements in Boolean satisfiability (SAT) solving since the turn of the millennium have made it possible to leverage state-of-the-art conflict-driven clause learning (CDCL) solvers for many combinatorial problems in academia and industry, and the use of proof logging has played a crucial role in increasing the confidence that the results these solvers produce are correct. However, the fact that SAT proof logging is performed in conjunctive normal form (CNF) clausal format means that it has not been possible to extend guarantees of correctness to the use of SAT solvers for more expressive combinatorial paradigms, where the first step is an unverified translation of the input to CNF. In this work, we show how cutting-planes-based reasoning can provide proof logging for solvers that translate pseudo-Boolean (a.k.a. 0-1 integer linear) decision problems to CNF and then run CDCL. To support a wide range of encodings, we provide a uniform and easily extensible framework for proof logging of CNF translations. We are hopeful that this is just a first step towards providing a unified proof logging approach that will also extend to maximum satisfiability (MaxSAT) solving and pseudo-Boolean optimization in general.

A software product line (SPL) uses a variability model, such as a feature model (FM), to describe the configuration options for a set of closely related software systems. Context-aware SPLs also consider possible environment conditions for their configuration options. Errors in modeling the FM and its context may lead to anomalies, such as dead features or a void feature model, which reduce if not negate the usefulness of the SPL. Detecting these anomalies is usually done by using Boolean satisfiability (SAT) that however are not expressive enough to detect anomalies when context is considered. In this paper, we describe HyVarRec: a tool that relies on Satisfiability Modulo Theory (SMT) to detect and explain anomalies for context-aware SPLs.

Feature modeling has become one of the most popular methods for representing variabilities and commonalities in software product families. In this paper we describe the feature model for e- government systems. In addition, we present a first approach to integrate formal specifications with feature models in order to produce guidelines to be used in the context of specifications reuse. We show that RSL language can adequately capture relations introducing semantics to the feature model of a system.

In this paper, we present a Bayesian Moment Matching (BMM) in-processing technique for Conflict-Driven Clause-Learning (CDCL) SAT solvers. BMM is a probabilistic algorithm which takes as input a Boolean formula in conjunctive normal form and a prior on a possible satisfying assignment, and outputs a posterior for a new assignment most likely to maximize the number of satisfied clauses. We invoke this BMM method, as an in-processing technique, with the goal of updating the polarity and branching activity scores. The key insight underpinning our method is that Bayesian reasoning is a powerful way to guide the CDCL search procedure away from fruitless parts of the search space of a satisfiable Boolean formula, and towards those regions that are likely to contain satisfying assignments.