Standard

Incremental Flow Analysis through Computational Dependency Reification. / Van der Plas, Jens; Stiévenart, Quentin; Van Es, Noah; De Roover, Coen.

Proceedings of the 20th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2020). IEEE, 2020. p. 25-36.

Research output: Chapter in Book/Report/Conference proceedingConference paper

Harvard

Van der Plas, J, Stiévenart, Q, Van Es, N & De Roover, C 2020, Incremental Flow Analysis through Computational Dependency Reification. in Proceedings of the 20th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2020). IEEE, pp. 25-36, 20th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM2020), Adelaide, Australia, 27/09/20.

APA

Van der Plas, J., Stiévenart, Q., Van Es, N., & De Roover, C. (2020). Incremental Flow Analysis through Computational Dependency Reification. In Proceedings of the 20th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2020) (pp. 25-36). IEEE.

Vancouver

Van der Plas J, Stiévenart Q, Van Es N, De Roover C. Incremental Flow Analysis through Computational Dependency Reification. In Proceedings of the 20th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2020). IEEE. 2020. p. 25-36

Author

Van der Plas, Jens ; Stiévenart, Quentin ; Van Es, Noah ; De Roover, Coen. / Incremental Flow Analysis through Computational Dependency Reification. Proceedings of the 20th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2020). IEEE, 2020. pp. 25-36

BibTeX

@inproceedings{997048cbe6514227ba52a48031b864c2,
title = "Incremental Flow Analysis through Computational Dependency Reification",
abstract = "Static analyses are used to gain more confidence in changes made by developers. To be of most use, such analyses must deliver feedback fast. Therefore, incremental static analyses update previous results rather than entirely recompute them. This reduces the analysis time upon a program change, and makes the analysis well-suited for environments where the codebase is frequently updated, such as in IDEs and CI pipelines. In this work, we present a general approach to render a modular static analysis for highly dynamic programs incremental, by exploiting dependencies between intermediate analysis results. Modular analyses divide a program in interdependent parts that are analysed in isolation. The dependencies between these parts stem, for example, from the use of shared variables within the program. Our incrementalisation approach leverages the modularity of the analysis together with the dependencies that it reifies to compute and bound the impact of changes. This way, only the affected parts of the result need to be reanalysed, and unnecessary recomputations are avoided. We apply our approach to both a function-modular and thread-modular analysis and evaluate it by comparing an incremental update of an existing result to a full reanalysis. We find reductions of the analysis time from 6{\%} to 99{\%} on 14 out of 16 benchmark programs, and on most programs the impact on precision is limited. On 7 of the programs, reanalysis time is reduced by more than 75{\%}, showing that our approach results in fast incremental updates.",
author = "{Van der Plas}, Jens and Quentin Sti{\'e}venart and {Van Es}, Noah and {De Roover}, Coen",
year = "2020",
month = "9",
day = "27",
language = "English",
isbn = "978-1-7281-9248-2",
pages = "25--36",
booktitle = "Proceedings of the 20th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2020)",
publisher = "IEEE",

}

RIS

TY - GEN

T1 - Incremental Flow Analysis through Computational Dependency Reification

AU - Van der Plas, Jens

AU - Stiévenart, Quentin

AU - Van Es, Noah

AU - De Roover, Coen

PY - 2020/9/27

Y1 - 2020/9/27

N2 - Static analyses are used to gain more confidence in changes made by developers. To be of most use, such analyses must deliver feedback fast. Therefore, incremental static analyses update previous results rather than entirely recompute them. This reduces the analysis time upon a program change, and makes the analysis well-suited for environments where the codebase is frequently updated, such as in IDEs and CI pipelines. In this work, we present a general approach to render a modular static analysis for highly dynamic programs incremental, by exploiting dependencies between intermediate analysis results. Modular analyses divide a program in interdependent parts that are analysed in isolation. The dependencies between these parts stem, for example, from the use of shared variables within the program. Our incrementalisation approach leverages the modularity of the analysis together with the dependencies that it reifies to compute and bound the impact of changes. This way, only the affected parts of the result need to be reanalysed, and unnecessary recomputations are avoided. We apply our approach to both a function-modular and thread-modular analysis and evaluate it by comparing an incremental update of an existing result to a full reanalysis. We find reductions of the analysis time from 6% to 99% on 14 out of 16 benchmark programs, and on most programs the impact on precision is limited. On 7 of the programs, reanalysis time is reduced by more than 75%, showing that our approach results in fast incremental updates.

AB - Static analyses are used to gain more confidence in changes made by developers. To be of most use, such analyses must deliver feedback fast. Therefore, incremental static analyses update previous results rather than entirely recompute them. This reduces the analysis time upon a program change, and makes the analysis well-suited for environments where the codebase is frequently updated, such as in IDEs and CI pipelines. In this work, we present a general approach to render a modular static analysis for highly dynamic programs incremental, by exploiting dependencies between intermediate analysis results. Modular analyses divide a program in interdependent parts that are analysed in isolation. The dependencies between these parts stem, for example, from the use of shared variables within the program. Our incrementalisation approach leverages the modularity of the analysis together with the dependencies that it reifies to compute and bound the impact of changes. This way, only the affected parts of the result need to be reanalysed, and unnecessary recomputations are avoided. We apply our approach to both a function-modular and thread-modular analysis and evaluate it by comparing an incremental update of an existing result to a full reanalysis. We find reductions of the analysis time from 6% to 99% on 14 out of 16 benchmark programs, and on most programs the impact on precision is limited. On 7 of the programs, reanalysis time is reduced by more than 75%, showing that our approach results in fast incremental updates.

M3 - Conference paper

SN - 978-1-7281-9248-2

SP - 25

EP - 36

BT - Proceedings of the 20th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2020)

PB - IEEE

ER -

ID: 53858151