This is an extended abstract of [I. Garcia-Contreras et al., 2018]

Garcia-Contreras, Isabel

Hermenegildo, Manuel V.

Dagstuhl Research Online Publication Server

Towards Incremental and ModularContext-Sensitive AnalysisIsabel Garcia-ContrerasIMDEA Software Institute, Pozuelo de Alarcón, Madrid, Spain andUniversidad Politécnica de Madrid (UPM)isabel.garcia@imdea.orghttps://orcid.org/0000-0001-6098-3895José F. MoralesIMDEA Software Institute, Pozuelo de Alarcón, Madrid, Spainjosef.morales@imdea.orghttps://orcid.org/0000-0001-9782-8135Manuel V. HermenegildoIMDEA Software Institute, Pozuelo de Alarcón, Madrid, Spain andUniversidad Politécnica de Madrid (UPM)manuel.hermenegildo@imdea.orghttps://orcid.org/0000-0002-7583-323XAbstractThis is an extended abstract of [1].2012 ACM Subject Classification Theory of computation→ Invariants, Theory of computation→ Pre- and post-conditions, Theory of computation→ Program analysis, Theory of computation→ Program semantics, Theory of computation → AbstractionKeywords and phrases Program Analysis, (Constraint) Logic Programming, Abstract Interpre-tation, Fixpoint Algorithms, Incremental Analysis, Modular AnalysisDigital Object Identifier 10.4230/OASIcs.ICLP.2018.7Related Version https://arxiv.org/abs/1804.01839Funding Research partially funded by Spanish MINECO grant TIN2015-67522-C3-1-R TRACES,FPU grant 16/04811, and the Madrid M141047003 N-GREENS program.Static program analysis (generally based on computing fixpoints using the techniqueof abstract interpretation) is widely used for automatically inferring program propertiessuch as correctness, robustness, safety, cost, etc. Performing such analysis interactivelyduring software development allows early detection and reporting of bugs, such as, e.g.,assertion violations, back to the programmer. This can be done as the program is beingedited by (re-)running the analysis in the background each time a set of changes is made,e.g., when a file is saved, or a commit made in the version control system. However, real-lifeprograms are large, and, typically, have a complex structure combining a good number ofmodules with other modules in system libraries. Global analysis of such large code basescan be very expensive, and more so if context-sensitivity is supported for precision. Thisrenders triggering a complete reanalysis for each set of changes too costly. A key observation,however, is that in practice each development or transformation iteration is normally formedby relatively small modifications, which in turn are isolated inside a small number of modules.This property can be taken advantage of in order to reduce the cost of re-analysis by reusing© Isabel Garcia-Contreras, Jose F. Morales, and Manuel V. Hermenegildo;licensed under Creative Commons License CC-BYTechnical Communications of the 34th International Conference on Logic Programming (ICLP 2018).Editors: Alessandro Dal Palu’, Paul Tarau, Neda Saeedloei, and Paul Fodor; Article No. 7; pp. 7:1–7:2OpenAccess Series in InformaticsSchloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany7:2 Towards Incremental and Modular Context-Sensitive Analysisas much information as possible from previous analyses. Such cost reductions have beenachieved to date at two different levels, using relatively different techniques:Modular context-sensitive analyses obtain global information on the whole program byperforming local analyses one module at a time. They are typically aimed at reducingmemory consumption (working set size) but can also localize the (re)computation of theanalysis to the modules affected by changes, achieving some coarse-grained incrementality.Context-sensitive (non-modular) incremental analyses identify, invalidate, and recomputeonly those parts of the analysis results that are affected by fine-grain program changes.These analyses have been shown to achieve very high levels of incrementality, at finelevels of granularity (e.g., program line level).The problem that we address is that while, as mentioned before, large programs are typicallyhighly modular, the context-sensitive, fine-grained incremental analysis techniques presentedto date are not easily applicable to the modular setting: The flow of analysis informationthrough the module interfaces requires iterations, since the analysis of a module depends onthe analysis of other modules in complex ways, through several paths to different versions ofthe procedures.In order to bridge the gap we propose a framework that analyzes separately the modulesof a modular program, using context-sensitive fixpoint analysis while achieving both inter-modular (coarse-grain) and intra-modular (fine-grain) incrementality. The proposed analysisalgorithm assumes a setting in which we analyze successive “snapshots” of modular programs,i.e., at each analysis iteration, a snapshot of the sources is taken and used to perform thenext analysis. Each time an analysis is started, the modules will be analyzed independentlyand incrementally (possibly several times) until a global fixpoint is reached. The algorithmis designed to work with any partition of the sources. The essential point of the algorithm isthat analysis results are represented in a way that allows to partially invalidate the resultsthat are no longer valid, correct, or accurate, while keeping the information that does notneed recomputation. The information of source changes is used to invalidate (if necessary),and then decide which parts of the program (modules or predicates) need to be reanalyzed.We solve the problems related to the propagation of the fine-grain change information acrossmodule boundaries. We also work out the actions that need to be performed in order torecompute the analysis fixpoint incrementally after multiple additions and deletions acrossmodules in the program. Finally, we prove that the analysis result is always correct and it isthe best (most accurate) over-approximation of the actual behavior of the program.We have implemented the proposed approach within the Ciao/CiaoPP system [2]. Ourpreliminary results show promising speedups for medium and large programs. The addedfiner granularity (which allows reusing analysis information both at the intra- and inter-modular levels) reduces significantly the cost with respect to modular analysis alone. Theadvantages of fine-grain incremental analysis –making the cost ideally proportional to thesize of the changes– thus seem to carry over with our algorithm to the modular analysis case.Furthermore, the fine-grained propagation of analysis information of our algorithm improvesperformance with respect to traditional modular analysis even when analyzing from scratch.References1 I. Garcia-Contreras, J. F. Morales, and M. V. Hermenegildo. An Approach to Incremen-tal and Modular Context-sensitive Analysis of Logic Programs. Technical Report CLIP-2/2018.0, The CLIP Lab, April 2018. URL: https://arxiv.org/abs/1804.01839.2 M.V. Hermenegildo, F. Bueno, M. Carro, P. López, E. Mera, J.F. Morales, and G. Puebla.An Overview of Ciao and its Design Philosophy. TPLP, 12(1–2):219–252, 2012.

Towards Incremental and Modular Context-Sensitive Analysis

http://drops.dagstuhl.de/opus/volltexte/2018/9873/pdf/OASIcs-ICLP-2018-7.pdf

Towards Incremental and Modular Context-Sensitive Analysis

Abstract

Similar works

Full text

Available Versions

Dagstuhl Research Online Publication Server