Platinum: Reusing Constraint Solutions in Bounded Analysis of Relational Logic

Alloy is a lightweight specification language based on relational logic, with an analysis engine that relies on SAT solvers to automate bounded verification of specifications. In spite of its strengths, the reliance of the Alloy Analyzer on computationally heavy solvers means that it can take a significant amount of time to verify software properties, even within limited bounds. This challenge is exacerbated by the ever-evolving nature of complex software systems. This paper presents Platinum, a technique for efficient analysis of evolving Alloy specifications, that recognizes opportunities for constraint reduction and reuse of previously identified constraint solutions. The insight behind Platinum is that formula constraints recur often during the analysis of a single specification and across its revisions, and constraint solutions can be reused over sequences of analyses performed on evolving specifications. Our empirical results show that Platinum substantially reduces (by 66.4% on average) the analysis time required on specifications extracted from real-world software systems.


Introduction
The growing reliance of society on software and software-intensive systems drives a continued demand for increased software dependability.Software verification provides the highest degree of software assurance, with its strengths residing in the mathematical concepts that can be leveraged to prove correctness with respect to specific properties.Most notably, bounded verification techniques, such as Alloy [23], have recently received a great deal of attention in the software engineering community (e.g., [15,21,29,32,37,40,42,46,48,54,58]), due to the strength of their automated, yet formally precise, analysis capabilities.The basic idea behind these techniques is to construct a formula that encodes the behavior of a system and examine it up to a userspecified bound.They thus enable analyses of partial models that represent key aspects of a system.
Bounded verification techniques often transform a software specification to be analyzed into a satisfiability problem, and delegate the task of solving this to a constraint solver.In the past decade, constraint solving technologies have made spectacular progress (e.g., [14,17,36]).Despite these advances, however, constraint solving continues to be a bottleneck in analyses that rely on it [51].This is because the magnitude of formulas tends to increase exponentially with the size of the system being analyzed, making it impractical to employ constraint solving on complex systems.Further, despite the many optimizations applied to constraint solvers, they are still unable to detect many instances of subformula recurrence that are generated by Alloy.
The foregoing challenges are exacerbated when considering the ever-evolving nature of complex software systems and their corresponding specifications.Formal specifications are developed iteratively, and each iteration involves repeated runs of the analyzer for assessment of their semantics [26,30].In online analyses, where specifications are kept in sync with the evolving software and analyses are performed at runtime, the time required to verify the properties of software is of even greater significance.This calls for techniques that assist constraint solvers in dealing with large corpus' of formulas, many of which contain tens of thousands of clauses.
In this paper, we introduce PLATINUM, an extension of the Alloy Analyzer that supports efficient analysis of evolving Alloy specifications, by recognizing opportunities for constraint reduction and reuse of previously identified constraint solutions.Unlike the Alloy Analyzer and its other variants, e.g., Aluminum [39], that dispose of prior results in response to changes in the system specification, PLATINUM stores solved constraints incrementally, and retrieves them when they are needed again within the analysis of the revised specification.PLATINUM further improves analysis efficiency by omitting redundant constraints from a specification before translating them into propositional formulas to be solved by expensive constraint solvers, thereby greatly reducing the required computational effort.Although techniques for storing the results of satisfiability checking and reusing them later have been considered in the context of symbolic execution [7,8,24,43,55], these techniques cannot be directly applied to Alloy due to the specifics of its core logic, which consolidates the quantifiers of first-order logic with the operators of the relational calculus [23].(Section 5 provides details.) We evaluate the performance of PLATINUM in several scenarios.First, we apply PLATINUM to several pairs of specifications in which the second contains a small but non-trivial set of changes relative to the first.Second, we apply PLATINUM to several sequences of specifications that model evolution scenarios.Our empirical results show that PLATINUM is able to support reuse of constraint solutions both within a single analysis run as well as across a sequence of analyses of evolving specifications, while achieving speed-up over the Alloy Analyzer.Third, we show that as the scope of the analysis increases, PLATINUM achieves even greater improvements.Fourth, we show that the overhead associated with PLATINUM is a fraction of that required by the Alloy Analyzer.Finally, we show that PLATINUM substantially reduces (by 66.4% on average) the analysis time required on specifications extracted from real-world software systems.
This paper makes the following contributions: -Efficient analysis of evolving relational logic specifications.We present a novel approach to improve the bounded analysis of relational logic specifications by transforming constraints into more concise forms and enabling substantial reuse of solutions, which in turn substantially reduces analysis costs.-Tool implementation.We implement PLATINUM as an extension to Alloy and its underlying relational logic analyzer, Kodkod [50].We make PLATINUM available to the research and education community [6].-Empirical evaluation.We evaluate PLATINUM in the context of Alloy specifications found in prior work and specifications automatically extracted from real-world systems, corroborating PLATINUM's ability to substantially outperform the Alloy Analyzer without sacrificing soundness or completeness.

Illustrative Example
To motivate this research and illustrate our approach, we provide a simple Alloy specification and describe the analysis process followed by the Alloy Analyzer and PLAT- Consider snippets of the Alloy specification for a simple customer-order class diagram, shown in Listing 1.1 (adapted from [11]).Each Alloy specification consists of data types and formulas that define constraints over those data types.A signature (sig) paragraph introduces a basic data type and a set of its relations, called fields, accompanied by the type of each field.The running example defines seven signatures (Lines 2-21).The Customer class (Lines 2-7) has two attributes, customerID and customerName, that are assigned to the attrSet field of the Customer class.The id field specifies that customerID is the identifier of this class.The last two lines of the Customer signature specification indicate that Customer is not an abstract class and that it has no parent.Similarly, the code in Lines 10-15 represents the Order signature specification, and CustOrder (Lines 18-21) specifies an association relationship between Customer and Order.
Facts (fact) are formulas that take no arguments, and define constraints that each instance of a specification must satisfy, restricting the specification's solution space.The formulas can be further structured using predicates (pred) and functions (fun), which are parameterized formulas that can be invoked.The associationMultiplicity fact paragraph (Lines 22-24) states multiplicities of source and destination classes in the CustOrder association relationship.To analyze such a relational specification, both the Alloy Analyzer and PLATINUM translate it into a corresponding finite relational model in a language called Kodkod [49].Listing 1.2 shows a partial Kodkod translation of Listing 1.1(a).A specification in Kodkod's relational logic is a triple consisting of a universe of elements (a.k.a.atoms), a set of relation declarations including lower and upper bounds specified over the model's universe, and a relational formula in which the declared relations appear as free variables [49].
The first line of Listing 1.2 declares a universe of two uninterpreted atoms.(Due to space limitations, the listing omits some of the relations and atoms.)While in Kodkod all relations are untyped, in the interest of readability we assume an interpretation of atoms in which C1 represents a Customer element and O1 represents an Order element.
Lines 3-6 of Listing 1.2 declare relational variables.Similar to Alloy, formulas in Kodkod are constraints defined over relational variables.Whereas in Alloy these relational variables are separated into signatures that represent unary relations establishing a type system, and fields that represent non-unary relations, in Kodkod all relations are untyped, with no difference made between unary and non-unary variables.
Listing 1.3: Excerpt of the boolean encoding for the Kodkod specification shown in Listing 1.2.
Kodkod also allows scope to be specified from above and below each relational variable by two relational constants; these sets are called upper and lower bounds, respectively.In principle, a relational constant is a prespecified set of tuples drawn from a universe of atoms.Each relation in a specification solution must contain all tuples that appear in the lower bound, and no tuple that does not appear in the upper bound.That is, the upper bound represents the entire set of tuples that a relational variable may contain, and the lower bound represents a partial solution for a specification.
Consider the Customer declaration (Listing 1.2, Line 3).Both its upper and lower bounds contain just one atom, C1, given that it is defined as a singleton set in Listing 1.1.The upper bound for the variable parent ⊆ Class ×Class (Lines 5-6) is a product of the upper bound set for its corresponding domain and co-domain relations, here (Customer ∪ Order) → (Customer ∪ Order), taking every combination of an element from both and concatenating them.
To transform such a finite relational model into a boolean logic formula, Kodkod renders each relation as a boolean matrix, in which any tuple in the upper bound of the given relation that is not in the lower bound maps to a unique boolean variable [49].Relational constraints are then captured as boolean constraints over the translated boolean variables.
To render this idea concrete, consider the parent relation along with the next constraint defined over it (Listing 1.2, Lines 5-8).Each of the four tuples in the upper bound of the parent relation is allocated a fresh boolean variable (v1 to v4) in the boolean encoding.The relational constraint (no Customer.parent)&& (no Order.parent) is then translated as a boolean constraint over those boolean variables, as shown in Listing 1.3, Line 1.
Expressions and constraints in relational specifications typically contain equivalent slices in their boolean representations.PLATINUM detects such semantically redundant slices by refining the specification in its boolean logic form into its essential, indepen-dently analyzable slices, and then rendering them in a canonical form.The boolean encoding of the constraints defined over the parent relation, for example, embodies two slices with equivalent but syntactically distinct formulas (Listing 1.3, Lines 4-5).Line 8 represents the result of restructuring the slices into a canonical form, suggesting that the two slices are in fact equivalent.The slicing technique we use to determine the sets of clauses, the satisfiability of which can be analyzed independent of other clauses in the formula, is presented in Section 3.
PLATINUM prevents redundant slices from being propagated to the CNF formula to be solved by the underlying SAT solver, substantially reducing computational effort.In the case of our example specification (Listing 1.1(a)), PLATINUM partitions the original relational specification into 30 slices, with only seven distinct canonical slices.As such, PLATINUM is faster at finding a solution instance, requiring 19 ms to do so compared to the 26 ms that the Alloy Analyzer requires to produce the first solution instance.The time required to compute the entire instance set also improves, from 6481 ms to 246 ms, in this simple example.
PLATINUM also reuses results produced for specification slices to further improve the analysis of evolving specifications.Consider Listing 1.1(b), for example, in which two new signature paragraphs are added, stating that the PreferredCustomer class inherits from the Customer class.Given the updated specification, PLATINUM reuses the results from the prior run and solves a smaller problem.Specifically, after slicing and canonicalizing the formula, the results for 29 slices, out of the total of 30 slices, are already available.As a result, PLATINUM requires only one millisecond to find the first solution for the revised specification, whereas the Alloy Analyzer requires 27 milliseconds to produce the first solution.PLATINUM also produces speed-ups in computing the whole solution space.In the case of this particular example, PLATINUM reduces the time required to produce the entire solution set from 768 milliseconds to two milliseconds.

Approach
Fig. 1 provides an architectural overview that shows how PLATINUM fits in with Alloy.As the figure shows (left), the Alloy Analyzer reads in an Alloy specification and translates it into a relational model, then passes that to Kodkod.Kodkod translates the relational model into a boolean formula, then to CNF, and passes the CNF to off-theshelf SAT solvers to obtain a solution.Last, the Alloy interpreter translates the SAT result into a solution instance.
PLATINUM is inserted between Kodkod and the Alloy interpreter, as shown in the figure.At the highest level, PLATINUM takes in the boolean formula from Kodkod and outputs SAT results to the Alloy interpreter.The box at right shows the steps PLATINUM follows to do this.PLATINUM first decomposes the boolean formula into independent slices.Then, for each slice, PLATINUM canonicalizes it into a normalized format and searches the storage for a previously existing equivalent slice.If such a slice exists, the previous results will be reused.Otherwise, the slice is translated to CNF and assigned to an independent SAT solver for processing.Both the slice and the results of processing it Next, we describe each step taken by PLATINUM in detail.

3:
for each variable v ∈ f do 4: In PLATINUM, the slicing operation takes in the boolean formula generated from Kodkod and decomposes it into a set of independently analyzable subformulas.Formally, given a boolean formula ϕ, slicing decomposes it into subformulas ϕ 1 , ϕ 2 , ..., ϕ n , such that the following equations hold: - where var(ϕ) is the set of boolean variables of ϕ.Subformulas ϕ 1 to ϕ n can be solved independently.Thus, ϕ is satisfiable if and only if each slice ϕ i is satisfiable individually.
A boolean formula can be sliced either logically (based on semantics) or algebraically (based on syntax).In the interest of efficiency, PLATINUM applies a syntactic slicing algorithm.There are two types of boolean formulas in Alloy: a propositional formula that Kodkod translates from the relational model and the conjunctive normal form generated from the propositional formula.PLATINUM applies slicing on the propositional formula level for two reasons.First, translating a propositional formula to CNF introduces many auxiliary variables [16].For example, when the Cus-tomerOrder specification in Section 2, with 81 variables in its propositional formula, is translated to a CNF formula containing 352 variables, 271 auxiliary variables are introduced.The explosion in the number of variables affects the performance of slicing and canonicalization.Second, in certain cases, auxiliary variables connect two independent formulas together.Given the boolean formula v 1 &v 2 , its CNF translation is

43:
end whilereturn v 44: end procedure Slicing can be viewed as identifying connected components in a graph, where the vertices of the graph are boolean variables and the edges of the graph represent two variables that appear within the same clause.Each slice is thus one connected component in the graph.The conventional way to proceed with this is to first build a graph for the entire boolean formula, and then run a depth-first-search (DFS) to identify each connected component [55].For large specifications this can be both time and memory intensive.To improve performance, our algorithm applies a modified UNION-FIND algorithm [12], that traverses the boolean formula only once to identify connected components.
Algorithm 1 outlines the slicing process.Given boolean formula root, the algorithm first initializes a data structure used by its subroutine (Lines 2-6).Each slice is identified by a representative, which is one variable within the slice.Array Parent is used to find the representative variable.Array Rank is used to construct a balanced parent array.Array Slices maps a representative variable to its corresponding slice; its size equals the number of slices.The algorithm then calls subroutine DECOMPOSE to decompose the root formula.
DECOMPOSE recursively partitions a boolean formula f into subformulas in such a way that the conjunction of all subformulas equals f, and each subformula cannot be decomposed into smaller subformulas.
The UNION-FIND procedure (Algorithm 2) takes a decomposed subformula and finds a slice to which it belongs.The basic idea behind the algorithm is that each slice is represented by one variable.UNION-FIND has two basic operators: UNION and FIND.If UNION operates on two slices, it joins them into one slice (Lines 27-38).If UNION operates on two variables, it assigns one variable to be the parent of the other (Lines 20-26).The FINDSLICE operation determines the representative variable for the slice -the variable to which the input variable belongs.It does so by traversing the Parent array until it finds one variable v p whose parent is itself, i.e., parent[v p ] = v p .All variables along this path belong to the same slice and are represented by v p .
The input boolean formula has two states: UnMeetState, which indicates that f does not belong to any slice yet, and MeetState, which indicates that f belongs to some slice that is represented by represent.For each variable v of the input boolean formula f, UnMeetState first obtains the representative variable for v (which could be itself if v does not belong to any slice yet).If v has not been visited, the algorithm unions v and the representative variable of the subformula (Lines 20-26).Otherwise, if v has been visited (i.e., it belongs to some slice), and if f is in UnMeetState, then the algorithm adds f to the slice represented by represent.Finally, if f is in MeetState, this means that f belongs to one slice and v belongs to another and these need to be joined together (Lines 27-38).The time complexity of the UNION-FIND algorithm is near linear [12].Without this improvement and using the conventional DFS-based approach taken by Green [55] among others, in one case in our empirical study, a few minutes were required to produce independently analyzable slices.Using our algorithm, this time was reduced to about 10 milliseconds -an order of magnitude speedup.This speedup occurs for the following reason.A graph is needed to start the DFS.The graph contains information about which variable belongs to which clause and which clause contains which variables, and a map-like data structure is needed to store this information.When the number of variables becomes hugetypically hundreds of thousands in formulas produced for Alloy specifications of realworld systems-it is time and memory consuming to obtain this information and store it.It is also time consuming to retrieve the graph information during the DFS.Our UNION-FIND based algorithm, in contrast, requires information only on the node's parents, and this can be placed in a static array that requires only linear time to store and retrieve.

Canonicalization Algorithm 3 Canonicalization
The slices produced by the prior step are passed to this step, which transforms each slice into a canonical format in order to capture the syntactic equivalence between dif-ferent slices.For a slice ϕ, where ϕ = ϕ 1 ∧ ϕ 2 ∧ ... ∧ ϕ n , canonicalization generates one boolean formula ϕ , such that ϕ = ϕ 1 ∧ ϕ 2 ∧ ... ∧ ϕ n , where ϕ is the canonical format of ϕ.The canonical form of the formulas is constructed by renaming variables and formula labels.Algorithm 3 outlines this transformation.
Canonicalization first renames each boolean variable based on its weight (Lines 2-7).For each variable v ∈ V , where V = var(ϕ 1 ) ∪ var(ϕ 2 ) ∪ ... ∪ var(ϕ n ), the weight of v is calculated as the sum of the number of its occurrences and the number of operators applied on v in all of the subformulas.To improve the performance of this step, the weight for each variable is collected during the slicing phase; then, V is sorted based on variable weight.If two variables have the same weight, their original labels are used to sort them.Each variable is then renamed to their index in the sorted array.The mapping relations from canonical variables to original variables for each slice are stored in labelMap for use in assembling the solution for the original boolean formula.Next, the label for each formula is renamed (Lines 8-20).The purpose of this step is to maintain consistency with variables when translating to CNF.The labels of formulas are used as auxiliary variables when they are translated to CNF.

Storing and Reuse
After slicing and canonicalization have been completed, each boolean formula is decomposed into several independent formulas.For each canonicalized boolean formula, PLATINUM checks its hash code in storage.If there is a hit, this boolean formula is already solved, and the result will then be retrieved.If not, the boolean formula will be translated into CNF and solved by the SAT solver independently.The result will then be stored.
After solving all slices, using the labelMap (Algorithm 3) that maps canonical variables to original variables, PLATINUM obtains the solution for the original boolean formula and passes it to Alloy to generate a solution instance.

Empirical Study
We empirically evaluated the performance of PLATINUM in relation to the following research questions: RQ1: How does the performance of PLATINUM compare to the performance of existing approaches on specifications that have undergone relatively small amounts of change?RQ2: How does the performance of PLATINUM compare to the performance of existing approaches on specifications that have gone through several successive rounds of evolution?RQ3: How does the performance of PLATINUM compare to the performance of existing approaches on specifications that have run against higher scopes?RQ4: What is the overhead of PLATINUM in restructuring a relational logic formula into its canonical form?RQ5: How does the performance of PLATINUM compare to the performance of existing approaches in practice on specifications automatically extracted from real-world applications?Our objects of analysis are specifications drawn from a variety of sources and problem domains.These specifications vary widely in terms of size and complexity.Table 1 lists the specifications that we use, with statistics on their size in terms of the numbers of relations in their underlying logic.Note that this number, in turn, represents the sum of the numbers of signatures and fields, as both are indeed translated into relations in the underlying relational logic.

Objects of Analysis
Ecommerce is a model, adopted from Lau and Czarnecki [25], that represents a common architecture for open-source and commercial E-commerce systems.Decider [1] is a model of a system to support design space exploration.CSOS is a model of a cyber-social operating system meant to help coordinate people and tasks.WordPress is an object model obtained by reverse engineering an open-source blog system [4].Finally, the last six rows of the table correspond to six large specifications intended for the analysis of security properties in the context of the Android platform.Each consists of a bundle of Android applications installed on a mobile device for detecting security vulnerabilities that may arise due to inter-application communication, adopted from [10].
For the first four objects of analysis, we do not have access to actual, modified versions of their Alloy specifications, and even if we did, there would not likely be enough versions to provide data sufficient to support quantitative analyses.Thus, instead, we used a mutation-based approach to create modified versions of the specifications.We used edit operations for Alloy specifications [9] and incorporated into the MuAlloy mutation system [56] to derive a list of mutation operators.Table 2 provides a list of these mutation operators, together with short descriptions.To investigate RQ1 we wished to apply our mutation operators to create 30 modified versions of each of our objects of study.Because prior work by Li et al. [26] showed that users tend to modify Alloy specifications incrementally by small amounts, we chose to create versions of our object specifications by mutating between one and 10% of the relations in the specifications.Given object specification S, for each modified specification S of S to be created, we randomly chose a number N in this range; N denotes the number of mutations to apply to S. We then began randomly choosing relations L in S , then randomly choosing a mutation operator M applicable to L, and applied M to S .We did not allow a given L to be utilized more than once in this process.Following each operator application, we ran Alloy on the current version of S to ensure that it is a valid specification.We repeated this process until N mutations had been inserted into S .Ultimately, this process produced 30 modified versions of each object specification, wherein each version contained a randomly selected number of randomly selected mutations -a number no greater than 10% of the number of relations in the original specification.
To investigate RQ2 we used a similar process; however, in this case our goal was to "evolve" each object specification S iteratively.Given the original version S, we created a successor version S 1 by repeating the process of inserting a randomly selected number of randomly selected mutations (again, a number no greater than 10% of the number of relations in S).However, our next iteration applied this same process to S 1 (which now contains a number of mutations) to produce a version S 2 that potentially contains more mutations.Here, we say "potentially" because we did not place any restrictions on the re-use of mutation operators or mutation locations in subsequent versions S k of S; thus, conceivably, a mutation could be "undone" in a subsequent version.We repeated this process 30 times on each specification, thereby obtaining a sequence of specifications that have evolved iteratively.
It is common for users of bounded verification techniques such as Alloy to increase the scope of the analysis, in order to obtain greater confidence in the validity of the specification.As the scope of analysis increases, the space of cases that must be examined expands dramatically.To investigate RQ3, we increased the scope of analysis on each of our object specifications.Note that the only change in the specification between two successive runs of the analyzer in this case was the scope of analysis.
To investigate RQ4 we used the dataset created for RQ1.To investigate RQ5, we created six different app bundles, each containing 20 Android apps drawn from public app repositories such as Google Play [3].We then used the COVERT tool [2] to automatically extract Alloy specifications from the app bundles.Given an original bundle B, we created a successor version B by adding a new app or removing an existing app (randomly selected) to/from the given bundle.The specifications automatically derived from app bundles tend to evolve as apps are added to, or removed from, the bundles.The resulting app bundles thus provide us with an ideal suite of evolving specifications that can be used for our evaluation.We repeated this process 30 times on each of the app bundles to produce 30 modified versions of each bundle specification.

Variables and Measures
Independent Variables As independent variables we wished to utilize PLATINUM, as well as baseline techniques representing state of the art approaches capable of performing the same function as PLATINUM.
We consider both the Alloy Analyzer (version 4.2) and Titanium [9], which is an extension of Alloy that supports analysis of evolving specifications, as baseline techniques to compare against PLATINUM.The other potential baseline technique is Green [55], an optimization technique that, during symbolic execution, memoizes and reuses the results of satisfiability checking.The current implementation of Green, however, has two fundamental problems in the context of this study.First, while Green supports the use of Integer and Real variables in expressions, it does not support the use of boolean variables, which are widely used in the context of Alloy's relational logic.We were able to work around this challenge, however, by modeling boolean variables as Green's Integers and limiting their size to zero and one -an approach suggested by Green's developers.A more insidious problem, however, is that the Green framework does not currently support constraints with the disjunction operator.Because Alloy specifications are in relational logic, native support for the disjunction operator is essential to effectively analyze such specifications.This issue has been reported to the Green repository [5], and we have been in contact with the authors about it; however, to date, the issue has not been resolved and there are no workarounds for it.Thus, we were ultimately unable to use Green as a baseline technique.
Additional independent variables used were (b) the size of specifications in terms of relations in the relational logic, (c) the number of mutation operations, (d) the type of mutation operations, and (e) the scope of the analysis.

Dependent Variables
We measure several dependent variables.The first variable, analysis time, tracks performance directly.Here, we measure the wall clock time required to run (1) a complete Alloy analysis and (2) a complete PLATINUM analysis on each specification considered.The second variable is the number of unique, independently analyzable slices produced by PLATINUM for each specification under analysis.The third variable is the number of slices for which solutions are already available for each specification under analysis.Finally, the fourth variable is the size of the generated CNF formulas that must be solved by the underlying SAT solver.In the last case, we record the number of CNF variables and clauses produced by each of the two techniques when translating high-level Alloy specifications into SAT formulas.

Study Operation
For RQ1 and RQ3, for each of our specification pairs, we applied the Alloy Analyzer, Titanium, and PLATINUM, measuring the time required by each approach, and the number of variables and clauses at the SAT level produced by each tool.
For RQ2, for each of our specification sequences, we applied both the Alloy Analyzer and PLATINUM to each pair of successive specifications in the sequence, measuring, for each iteration, the time required by each approach, the size of the SAT formula produced by each tool, and the number of slices reused across sequences.
For RQ4, for each of our specification pairs, we applied PLATINUM, measuring the time required for formula restructuring, including the slicing and canonicalization steps.
Finally, for RQ5, for each of the specification pairs extracted from app bundles, we applied both the Alloy Analyzer and PLATINUM, measuring the time required by each approach.
All of our runs of the Alloy Analyzer and PLATINUM were conducted on an 8-core 2.0 GHz AMD Opteron 6128 system with 40 GB of memory.Both techniques leveraged SAT4J as the SAT solver across the entire study to keep extraneous variables constant.

Threats to Validity
External validity threats concern the generalization of our findings.We have studied ten sets of Alloy specifications and cannot claim that they are representative of all such specifications.Additionally, our modified specifications for the first four objects of analysis were created via a mutation approach, and while this allows us to obtain large amounts of data, these objects may not directly represent modified specifications that exist in practice.To reduce this threat and help determine whether our results may generalize, we conducted additional studies using real-world software systems, where both the Alloy specifications and their revisions are automatically extracted from evolving bundles of real Android apps.Finally, different versions of the Alloy Analyzer may leverage different translation algorithms to CNF, and this may affect the execution time of the analyzer.To reduce this threat we used the latest stable release of the Alloy Analyzer, Alloy Analyzer 4.2, for all runs collected in the study.
Construct validity threats concern our metrics and measures; we are aware of no such threats in this case.We first assess the effectiveness of PLATINUM with respect to the incremental changes derived from our first four object specifications.The boxplots in Fig. 2 depict the size of the generated CNF formulas, given as the number of variables (Fig. 2a) and clauses (Fig. 2b) across mutations for each object of study.

Results for RQ1 (Small Changes)
The results show that in comparison to the Alloy Analyzer, PLATINUM's translation of relational logic specifications results in much smaller and simpler SAT formulas, and the numbers of CNF variables and clauses generated by PLATINUM were smaller than the numbers generated by Alloy.Specifically, in the analyses of the CSOS, Decider, Ecommerce, and Wordpress specifications, the numbers of variables and the numbers of clauses in the formulas produced by PLATINUM on average were 4.5/2.6/5.1/3.5 and 2.1/1.4/2.0/1.7 times lower, respectively, than the numbers in the formulas produced by the Alloy Analyzer.This is because already analyzed slices do not need to be translated into SAT formulas, thus reducing the sizes of the generated CNF formulas.Table 3 shows the results of a comparison of the average analysis times required by the Alloy Analyzer and PLATINUM across the four objects of study.On average, PLATINUM exhibited a 67.16% improvement over the Alloy Analyzer, with the average improvement across objects of study ranging from 16.82% to 82.31%.Fig. 3 depicts the results of a comparison of the average analysis times required by Titanium and PLATINUM, including the adjustment overhead incurred by each of the techniques to optimize the analysis bounds and formulas, across the four objects of study.According to the results, the average improvement exhibited by PLATINUM over Titanium across objects of study ranges from 44.42% to 75.64%.
These results demonstrate the potential effectiveness of our optimization technique, because in every case, the analysis time required by PLATINUM to find solution instances of mutated specifications was less than that required by the state of the art analysis techniques.

Results for RQ2 (Successive Changes)
To assess the effectiveness of PLATINUM in accelerating analysis in successive runs on evolving specifications we use two performance metrics: time ratio (TR) and variable ratio (VR).We define the time ratio as t P t A , where t P is the analysis time taken by PLAT-INUM and t A is the analysis time taken by the Alloy Analyzer.Intuitively, lower values of TR imply greater speedup.A TR of 0.5, for example, indicates that PLATINUM is two times faster than the Alloy analysis of the same specification, whereas a TR of 0.1 indicates that PLATINUM is 10 times faster.Similarly, we define the variable ratio as var P var A , where var P is the number of variables in a SAT formula produced by PLATINUM and var A is the number of variables in a SAT formula produced by the Alloy Analyzer for the same specification.Again, lower values of VR imply that there are fewer variables in a formula generated by PLATINUM than in a formula generated by the Alloy Analyzer.We started PLATINUM with an empty cache, and then analyzed each mutation in turn, continually populating the cache.Fig. 4 presents a pair of diagrams for each of the four object specifications, demonstrating speedup and reuse during successive mutation analyses.The left column represents scatter plots of time ratios across subject domains, and the right column represents scatter plots of variable ratios.All four sets of experiments exhibit similar behavior: in every case, and for every revision, the analysis time taken by PLATINUM is less than that of using the Alloy Analyzer (values of TR are always less than 1), and the number of variables in formulas generated by PLATINUM is significantly less than those generated by the Alloy Analyzer.The speedup, however, varies for different mutations.Variation across mutations is expected, given that the size and complexity of the mutations produced in successive runs differ greatly.In a few cases, the values for TR jump.Investigation of the data shows that this occurred because the mutations present in those cases contained several new slices not yet observed, which in turn reduced the amount of reuse.Despite these few cases, the empirical results suggest that significant speedup was possible in all cases.

Results for RQ3 (Scope Changes)
Alloy's analysis is exhaustive, yet bounded, up to a user-specified scope on the size of the domains.In cases in which the analyzer fails to produce a solution that satisfies specification constraints within a given scope, a solution may be found in a larger scope.In practice, Alloy users often conduct consecutive analysis runs of specifications, applying small increases in the analysis scope, in the hopes of gaining further confidence in their results.It has been shown that 17.6% of consecutive Alloy analyses differ only in terms of their analysis scopes [26].
To examine how our optimization approach responds to increases in analysis scope, for each specification, we gradually increased the scope of the analysis.We set the initial scope for the analysis of each specification to the scope that had already been specified by its original modeler, reasoning that whomever had developed and analyzed the specification is most likely the best judge of the scope that is needed.The initial scopes for the CSOS, Decider, Ecommerce, and Wordpress specifications were 51, 27, 50, and 32, respectively.We started PLATINUM with an empty cache for the analysis of each specification, and gradually populated it as the analysis scope increased.Table 4 shows the time ratios (TRs) measured as the analysis scope increased for each of the objects of study.Recall that lower values for TR indicate that greater acceleration was achieved by our optimization technique.The data shows that overall as scope increased, TR tended to decrease.For example, for the Ecommerce system, the lowest value for TR occurred when the scope increased to five, resulting in a 1 / 0.031 = 32 fold analysis speed acceleration.We next evaluate the performance of PLATINUM's formula restructuring analysis.Table 5 shows the time required to restructure relational logic formulas into their canonical forms.The first column represents the time spent decomposing formulas into independent slices, and the second column represents the time spent canonicalizing them into normalized formats.

Results for RQ4 (Overhead)
As the data shows, the analysis time overhead incurred by these two steps is 1.11% on average, and no greater than 2.44% in any case.This is negligible, particularly when compared to the analysis time overhead incurred by the Alloy Analyzer (cf.Table 3).While the restructuring steps introduce little overhead, they substantially enable reuse of slice solutions, which in turn greatly reduces analysis costs.
4.9 Results for RQ5 (Real-World Specifications) Fig. 5: Analysis times for the Alloy Analyzer and PLATINUM across specifications from real-world Android apps.
Finally, to assess the improvements one could expect in practice using PLATINUM, we used Alloy specifications that were automatically extracted from real-world software systems and evolved versions thereof, as described in Section 4.1.Fig. 5 shows the results of a comparison of the analysis time required by each of the two techniques as boxplots across the six bundle specifications.As the results show, PLATINUM exhibited a 66.4% improvement, on average, over the Alloy Analyzer; the average improvement across app bundles ranged from 44.2% to 78.4%, indicating relative stability across bundles.These results further confirm those obtained through our mutation-based experiments, corroborating the effectiveness of PLATINUM in improving the analysis time required by the Alloy Analyzer to find solution instances of revised specifications.

Related Work
The literature contains a large body of research related to ours.Here, we provide an overview of the most notable and closely related work and examine it in the light of our research.
The widespread use of Alloy has prompted a number of extensions to the language and its underlying automated analyzer [9,18,19,20,22,27,31,33,34,35,39,47,51,52].Among these, Titanium [9] presents an exploration space reduction strategy that narrows the space of values to be explored by an underlying constraint solver.This approach, however, requires an entire solution set to be produced for the original specification, to determine tighter bounds for certain relations in the revised specification.Our work differs primarily in its emphasis on reducing constraints into a more concise form at the level of relational logic abstractions, which in turn allows for substantial reuse of analysis efforts in subsequent analyses.Research efforts on bound adjustment and solution reuse are complementary in that, in spite of the adjustments made to the analysis bounds, the solver still needs to solve for the shared constraints.
Uzuncaova and Khurshid [53] partition a specification into base and derived slices, in which a solution to the base slice can be extended to produce a solution for the entire specification.PLATINUM is fundamentally different from this work in that the problem addressed by Uzuncaova and Khurshid assumes a fixed specification and does not consider specification evolution.Further, their approach does not eliminate the need to solve shared, canonicalized constraints across analyses.
Rosner et al. [45] present a technique, Ranger, that leverages a linear ordering of the solution space to support parallel analysis of first-order logic specifications.While the linear ordering enables partitioning of the solution space into ranges, there is no clear way in which it can be extended with incremental analysis capabilities, which are crucial for effective analysis of evolving specifications.
Several techniques attempt to explore specification instances derived from Alloy's relational logic constraints [13,28,38,39,49].Macedo et al. [28] examine scenario explorations in the context of relational logic.Aluminum [39] extends the Alloy Analyzer to generate minimal specification instances.Both of these efforts focus primarily on the order in which solutions are produced, as opposed to facilitating analysis of evolving specifications, which is our goal.Montaghami and Rayside [33] extend the Alloy language to explicitly support partial modeling.Their work, however, does not consider evolving specifications.In fact, it is widely recognized that efficient techniques for analyzing Alloy specifications are needed [51].To the best of our knowledge, however, no prior research has attempted to reduce the need to call a solver to improve the efficiency of the analysis of evolving Alloy specifications.
The technique most closely related to ours is Green [55]; this technique has been the subject of several more recent papers [7,8,24,41,43,44,57], that improve on its algorithm.As noted in Section 1, Green and its offshoots also rely on back-end constraint solving engines.In contrast to all of this prior work, the problem we address in this paper involves supporting the evolutionary analysis of relational logic.Among other things, this requires the development of both original slicing and canonicalization approaches appropriate for models specified in Alloy's relational logic.Moreover, neither Green's slicer nor its canonicalizer take into account the disjunction operator [5].While the lack of support for the disjunction operator might be allowable in the context of symbolic execution, that support is essential in the context of first-order logic to allow an approach to effectively recognize opportunities for constraint reduction and reuse.Further, while most of the prior techniques use a classic lexicographic ordering of the variables before transforming each slice into a canonical format, PLATINUM leverages a reverse shortlex order, in which the variables are first sorted by their weight and then sorted lexicographically.This choice improves the identification of syntactic equivalence between different slices.To the best of our knowledge, PLATINUM is the first technique for evolutionary analysis of relational logic specification that operates without requiring an entire solution set for the original specification.

Conclusions
We have presented PLATINUM, a novel extension to the Alloy Analyzer that substantially improves the process of analyzing evolving Alloy specifications.Our approach proceeds by storing solved constraints incrementally, and reusing them within subsequent analysis of a revised specification.It also omits redundant constraints from specifications before translating them into formulas that will be sent to constraint solvers.Our evaluation of PLATINUM shows that it is able to support substantial reuse of constraint solutions across analyses of evolving specifications.Our empirical results show significant speedup over the Alloy Analyzer in various scenarios.Our evaluation also shows that as the scope of analysis increases, PLATINUM achieves even further improvements, and that the overhead associated with the approach is negligible.Finally, our evaluation shows that PLATINUM continues to result in savings on specifications extracted from real-world software systems.
Our future work involves extending the optimization ideas presented here to leverage domain-specific knowledge.Specifically, we intend to explore the possibility of driving the automated discovery of domain-specific optimizations, wherein each system of interest can have bounded verification tailored to its specific characteristics.While such optimizations historically have arisen from the insights of a few dozen experts in software verification, we envision a bounded speculative analysis to identify how operations permissible within a certain domain may impact the exploration space of bounded analyses, thereby facilitating analysis of specifications in a given domain more effectively.

INUM. 1 // (a) a simple customer-order class diagram 2 one sig Customer extends Class{}{ 3 a t t r S e t = customerID +customerName 4 i d =customerID 5 i s A b s t r a c t = No 6 no p a r e n t 7 } 8 4 one p a r e n t 5 p 9
one sig customerID extends I n t e g e r {} 9 one sig customerName extends s t r i n g {} 10 one sig Order extends Class{}{ 11 a t t r S e t = o r d e r I D + o r d e rV a l u e 12 i d = o r d e r I D 13 i s A b s t r a c t = No 14 no p a r e n t 15 } 16 one sig o r d e r I D extends I n t e g e r {} 17 one sig o r d er V a l ue extends Real{} 18 one sig CustOrder extends A s s o c i a t i o n{}{ 19 s r c = Customer 20 d s t = Order 21 } 22 f a c t a s s o c i a t i o n M u l t i p l i c i t y { 23 one CustOrder .s r c and some CustOrder .d s t 24 } 1 // (b) new constructs added to the revised specification 2 one sig PreferredCustomer extends Class{}{ 3 a t t r S e t = d i s c o u n t one sig d i s c o u n t extends I n t e g e r {} Listing 1.1: (a) a specification describing a simple customer order class diagram; (b) new constructs added to a revised version of that specification.

Fig. 1 :
Fig. 1: Overview of PLATINUM are then stored.Finally, PLATINUM combines the results for each slice and passes them to the Alloy interpreter.Next, we describe each step taken by PLATINUM in detail.

Fig. 2 :
Fig. 2: Sizes of generated CNF formulas in terms of the number of (a) variables and (b) clauses produced by the Alloy Analyzer and PLATINUM across mutations for each object of study.

Fig. 3 :
Fig. 3: Performance comparison: Analysis times for Titanium and PLATINUM across objects of study.

Fig. 4 :
Fig. 4: Speedup and reuse during successive mutation analyses across subject domains.The left column represents scatter plots of time ratios (Analysis time taken by PLAT-INUM / Analysis time taken by Alloy), and the right column represents scatter plots of reuse ratios (#Variables in the SAT formula transformed by PLATINUM / #Variables in the SAT formula transformed by the Alloy Analyzer) across systems.
where o is the auxiliary variable.Even if v 1 and v 2 are independent formulas, in the CNF, v 1 and v 2 are dependent on each other.

Table 3 :
Performance Statistics

Table 4 :
Analysis Time Improvements Over Increasing Sizes of Analysis Scope

Table 5 :
Analysis Times With Respect to Overhead Incurred Due to Restructuring of Formulas