Static Execute After/Before as a replacement of traditional software dependencies

The paper explores Static Execute After (SEA) dependencies in the program and their dual Static Execute Before (SEB) dependencies. It empirically compares the SEA/SEB dependencies with the traditional dependencies that are computed by System Dependence Graph (SDG) and program slicers. In our case study we use about 30 subject programs that were previously used by other authors in empirical studies of program analysis. We report two main results. The computation of SEA/SEB is much less expensive and much more scalable than the computation of the SDG. At the same time, the precision declines only very slightly, by some 4% on average. In other words, the precision is comparable to that of the leading traditional algorithms, while intuitively a much larger difference would be expected. The paper then discusses whether based on these results the computation of the SDG should be replaced in some applications by the computation of the SEA/SEB.

[1]  Alessandro Orso,et al.  Leveraging field data for impact analysis and regression testing , 2003, ESEC/FSE-11.

[2]  David W. Binkley,et al.  Source Code Analysis: A Road Map , 2007, Future of Software Engineering (FOSE '07).

[3]  Frank Tip,et al.  A survey of program slicing techniques , 1994, J. Program. Lang..

[4]  Linda Badri,et al.  Supporting predictive change impact analysis: a control call graph based technique , 2005, 12th Asia-Pacific Software Engineering Conference (APSEC'05).

[5]  Matthew S. Hecht,et al.  Flow Analysis of Computer Programs , 1977 .

[6]  David W. Binkley,et al.  A large-scale empirical study of forward and backward static slice size and context sensitivity , 2003, International Conference on Software Maintenance, 2003. ICSM 2003. Proceedings..

[7]  Tibor Gyimóthy,et al.  Columbus - reverse engineering tool and schema for C++ , 2002, International Conference on Software Maintenance, 2002. Proceedings..

[8]  Steven S. Muchnick,et al.  Advanced Compiler Design and Implementation , 1997 .

[9]  Jim Alves-Foss,et al.  Hidden Implementation Dependencies in High Assurance and Critical Computing Systems , 2006, IEEE Transactions on Software Engineering.

[10]  Tibor Gyimóthy,et al.  The Dynamic Function Coupling Metric and Its Use in Software Evolution , 2007, 11th European Conference on Software Maintenance and Reengineering (CSMR'07).

[11]  Barbara G. Ryder,et al.  Constructing the Call Graph of a Program , 1979, IEEE Transactions on Software Engineering.

[12]  Giuliano Antoniol,et al.  Variable precision reaching definitions analysis for software maintenance , 1997, Proceedings. First Euromicro Conference on Software Maintenance and Reengineering.

[13]  Václav Rajlich,et al.  Hidden dependencies in program comprehension and change propagation , 2001, Proceedings 9th International Workshop on Program Comprehension. IWPC 2001.

[14]  William G. Griswold,et al.  The design of whole-program analysis tools , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[15]  Jean-Marc Jézéquel,et al.  Design by Contract: The Lessons of Ariane , 1997, Computer.

[16]  Mark Harman,et al.  An empirical study of static program slice size , 2007, TSEM.

[17]  David W. Binkley,et al.  Interprocedural slicing using dependence graphs , 1990, TOPL.

[18]  A. Orso,et al.  Efficient and precise dynamic impact analysis using execute-after sequences , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[19]  David W. Binkley,et al.  Program slicing , 2008, 2008 Frontiers of Software Maintenance.

[20]  Barbara G. Ryder,et al.  Pointer-induced aliasing: a problem classification , 1991, POPL '91.

[21]  Tibor Gyimóthy,et al.  Computation of Static Execute After Relation with Applications to Software Maintenance , 2007, 2007 IEEE International Conference on Software Maintenance.