Automatic Incrementalization of Prolog Based Static Analyses

Eichberg, Michael; Kahl, Matthias; Saha, Diptikalyan; Mezini, Mira; Ostermann, Klaus

doi:10.1007/978-3-540-69611-7_7

Cited by 26 publications

(13 citation statements)

References 35 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…part of(T,flyweightFactory(Instance)), 3 tnot(part of(S,flyweightCreation(Instance))). 4 5 violations(S,T,layering(Instance)) :− 6 part of(T,layer(M,Instance)), 7 tnot(part of(S,layer(N,Instance))), 8 N>=M.…”

Section: Constraints On Dependencies Between Ensemblesmentioning

confidence: 99%

“…This constraint is necessary, since given two ensemble specifications S1 and S2, it is not possible to statically decide whether S1 matches a subset of 1 violations(S, T, 'enclosing') :− 2 isEnclosedIn(E, EnclosingEnsemble), 3 part of(S, E), 4 tnot(part of(S, EnclosingEnsemble)). 5 6 violations(S, T, 'outgoing') :− 7 tnot(outPort(E, Port), isOpen(Port)), 8 (depends(E, DependentEnsemble) | E=DependentEnsemble), 9 part of(S, E), tnot(part of(T, DependentEnsemble)). 10 11 violations(S, T, 'incoming') :− 12 tnot(inPort(E, Port), isOpen(Port)), 13 (depends(E, DependentEnsemble) | E=DependentEnsemble), 14 tnot(part of(S, DependentEnsemble)), part of(T, E).…”

Section: Listing 6: Representing Ensemble-dependenciesmentioning

confidence: 99%

“…The integration into the incremental built process of Eclipse enables the implementation of queries over Java code that are continuously evaluated when code changes. Furthermore, the integration of the XSB engine enables that queries are evaluated in an incremental way, due to XSB's support for automatic incrementalization [8,33] of queries.…”

Section: Ide Integrationmentioning

confidence: 99%

See 2 more Smart Citations

Defining and continuous checking of structural program dependencies

Eichberg

Kloppenburg

Klose

et al. 2008

Proceedings of the 13th International Conference on Software Engineering - ICSE '08

Self Cite

View full text Add to dashboard Cite

Dependencies between program elements need to be modeled from different perspectives reflecting architectural, design, and implementation level decisions. To avoid erosion of the intended structure of the code, it is necessary to explicitly codify these different perspectives on the permitted dependencies and to detect violations continuously and incrementally as software evolves.We propose an approach that uses declarative queries to group source elements -across programming language module boundaries-into overlapping ensembles. The dependencies between these ensembles are also specified as logic queries. The approach has been integrated into the incremental build process of Eclipse to ensure continuous checking, using an engine for tabled and incremental evaluation of logic queries. Our evaluation shows that our approach is fast enough for day-to-day use along the incremental build process of modern IDEs.

show abstract

Section: Constraints On Dependencies Between Ensemblesmentioning

confidence: 99%

Section: Listing 6: Representing Ensemble-dependenciesmentioning

confidence: 99%

Section: Ide Integrationmentioning

confidence: 99%

See 1 more Smart Citation

Defining and continuous checking of structural program dependencies

Eichberg

Kloppenburg

Klose

et al. 2008

Proceedings of the 13th International Conference on Software Engineering - ICSE '08

Self Cite

View full text Add to dashboard Cite

show abstract

“…Eichberg et al [6] use incremental tabled evaluation to update analysis results deduced in a logic language. This approach comes with the cost of having to translate the program graph to Prolog facts and depends on the performance of the underlying general-purpose reasoning engine.…”

Section: Related Workmentioning

confidence: 99%

“…As others have argued before [6,19,20], a large margin of this inefficiency is due to the fact that current data-flow analyses lack a way to respond to incremental program changes.…”

Section: Introductionmentioning

confidence: 99%

Reviser: efficiently updating IDE-/IFDS-based data-flow analyses in response to incremental program changes

Arzt

Bodden

2014

Proceedings of the 36th International Conference on Software Engineering

View full text Add to dashboard Cite

Most application code evolves incrementally, and especially so when being maintained after the applications have been deployed. Yet, most data-flow analyses do not take advantage of this fact. Instead they require clients to recompute the entire analysis even if little code has changed-a time consuming undertaking, especially with large libraries or when running static analyses often, e.g., on a continuous-integration server.In this work, we present Reviser, a novel approach for automatically and efficiently updating inter-procedural dataflow analysis results in response to incremental program changes. Reviser follows a clear-and-propagate philosophy, aiming at clearing and recomputing analysis information only where required, thereby greatly reducing the required computational effort. The Reviser algorithm is formulated as an extension to the IDE framework for Inter-procedural Finite Distributed Environment problems and automatically updates arbitrary IDE-based analyses.We have implemented Reviser as an open-source extension to the Heros IFDS/IDE solver and the Soot program-analysis framework. An evaluation of Reviser on various client analyses and target programs shows performance gains of up to 80% in comparison to a full recomputation. The experiments also show Reviser to compute the same results as a full recomputation on all instances tested.

show abstract

Incremental inconsistency detection with low memory overhead

Falleri

Blanc

Bendraou³

et al. 2012

Softw Pract Exp

View full text Add to dashboard Cite

Ensuring models' consistency is a key concern when using a model-based development approach. Therefore, model inconsistency detection has received significant attention over the last years. To be useful, inconsistency detection has to be sound, efficient, and scalable. Incremental detection is one way to achieve efficiency in the presence of large models. In most of the existing approaches, incrementalization is carried out at the expense of the memory consumption that becomes proportional to the model size and the number of consistency rules. In this paper, we propose a new incremental inconsistency detection approach that only consumes a small and model size-independent amount of memory. It will therefore scale better to projects using large models and many consistency rules.Many approaches dealing with inconsistency management exist in the literature. The first generation of approaches that tackle this challenge uses inconsistency rules and executes them on models in batch [9][10][11][12][13][14]. The limitation of these first generation approaches, also called batch checkers, is efficiency. The main problem is that each time a model is modified, all inconsistency rules have to be rechecked as a whole, which turns to be highly time consuming. As reported by [3], checking large models with batch checkers can then take hours to complete, which cannot be sustainable in effective development processes.A second generation of approaches has then emerged to deal with efficiency. These approaches, also called incremental checkers, limit the set of rules to recheck (rule reduction) and/or the model elements to consider (scope reduction) after each model change [15][16][17][18]. The most efficient approaches intensively use cache memory, thus introducing a memory overhead relative to the size of models and requiring a mechanism to manage the cache along the model's life cycle. An experimental study shows that one of the current fastest incremental checkers has a cache that induces a linear memory overhead on several real-world Unified Modeling Language (UML) models but that has a worst-case memory overhead that is quadratic in the number of elements [15]. With the increasing complexity and size of industrial design models, we believe that optimal memory management (scalability) in inconsistency management is as important as response time (efficiency). This is also confirmed by our industrial partners, which have realized a case study that confirms the critical need for more optimal memory management for large and complex models [19].In this paper, we present an incremental checker that puts more emphasis on scalability rather than on efficiency. It has no cache and requires only a fixed memory overhead to perform both rule and scope reductions. Even if it cannot perform reduction for some cases (explained in Section 5) and is therefore less efficient than checkers that use cache for such cases, the intensive benchmark we have performed, using real large open source models, shows that it is fast enough (rechecks are perf...

show abstract

Automatic Incrementalization of Prolog Based Static Analyses

Cited by 26 publications

References 35 publications

Defining and continuous checking of structural program dependencies

Defining and continuous checking of structural program dependencies

Reviser: efficiently updating IDE-/IFDS-based data-flow analyses in response to incremental program changes

Incremental inconsistency detection with low memory overhead

Contact Info

Product

Resources

About