This Article 
   
 Share 
   
 Bibliographic References 
   
 Add to: 
 
Digg
Furl
Spurl
Blink
Simpy
Google
Del.icio.us
Y!MyWeb
 
 Search 
   
Architectural Tradeoffs for a Meaning-Preserving Program Restructuring Tool
April 1995 (vol. 21 no. 4)
pp. 275-287
Maintaining the consistency of multiple program representations—such as abstract syntax trees and program dependence graphs—in a program manipulation tool is difficult. This paper describes a hybrid software architecture for a meaning-preserving program restructuring tool. Layering is the primary architectural paradigm, which successively provides increasingly integrated and unified abstract machines to implement the tool. However, layering does not provide adequate control over extensibility or the independence of components. Consequently, we also adopted the paradigm of keeping the key program abstractions separate throughout the layering, providing independent “columns” of abstract data types. A pair of columns is integrated by a mapping column that translates elements in one column's data type into related elements in the other column's data type. Thus integration of function and separation of representation can be achieved simultaneously in this complex domain.This hybrid architecture was crucial in overcoming severe performance problems—classic in traditional layered systems— that became apparent once the basic tool was completed. By taking advantage of the independence of the columns and the special characteristics of meaning-preserving restructuring, it was possible to extend one representation column of the architecture to the uppermost layer to provide the required access for efficient update without compromising independence. The cost of the extended architecture is that the upper layers are no longer as simple because they expose operations that only guarantee consistency under careful usage. However, the structural constraints of the hybrid architecture and provided models for building the more complicated layers minimizes the negative impact of this tradeoff.

[1] E. Dijkstra, "The Structure of the 'T.H.E.' Multiprogramming System," Comm. ACM, Aug. 1968, pp. 453-457.
[2] D. Garlan and M. Shaw,“An introduction to software architecture,”inAdvances in Software Engineering and Knowledge Engineering,V. Ambriola and G. Tortora, Eds. Singapore: World Scientific, 1993, vol. 1, pp. 1–39.
[3] D. L. Parnas,“Designing software for ease of extension and contraction,”IEEE Trans. Software Eng.,vol. 5, pp. 128–138, Mar. 1979.
[4] A.N. Haberman, L. Flon, and L. Cooprider, “Modularization and Hierarchy in a Family of Operating Systems,” Comm. ACM, May 1976, pp. 266-272.
[5] J. Stankovic,“Good system structure features: Their complexity and execution time cost,”IEEE Trans. Software Eng.,vol. SE-8, pp. 306–318, July 1982.
[6] W. G. Griswold,“Program Restructuring as an Aid to Software Maintenance,”Ph.D. dissertation, Univ. Washington, Dep. Comput. Sci. Eng., Tech. Rep. 91-08-04, Aug. 1991.
[7] W. G. Griswold and D. Notkin,“Automated assistance for program restructuring,”ACM Trans. Software Eng. and Method.,vol. 2, no. 3, pp. 228–269, July 1993.
[8] J. Ferrante,K.J. Ottenstein,, and J.D. Warren,“The program dependence graph and its use in optimization,” ACM Trans. Programming Languages and Systems, vol. 9, no. 3, pp. 319-349, June 1987.
[9] K.J. Sullivan and D. Notkin, "Reconciling Environment Integration and Evolution," ACM Trans. Software Eng. and Methodology vol. 1, no. 3, July 1992.
[10] K.J. Sullivan, "Mediators: Easing the Design and Evolution of Integrated Systems," PhD dissertation, Dept. of Computer Science, Univ. of Washington, Aug. 1994.
[11] W. G. Griswold and D. C. Atkinson,“Managing the design tradeoffs for a program understanding and transformation tool,”J. Syst. Software,July 1995.
[12] M.M. Lehman and L.A. Belady, Program Evolution: Processes of Software Change.London: Academic Press, 1985.
[13] Ralph E. Johnson and William F. Opdyke,“Refactoring and aggregation,”inObject Technologies for Advanced Software. First JSSST Int. Symp., Nov. 1993, vol. 742 ofLecture Notes in Computer Science,pp. 264–278.
[14] J. R. Larus,Restructuring Symbolic Programs for Concurrent Execution on Multiprocessors,Ph.D. dissertation, UC Berkeley Comput. Sci., May 1989, Also Tech. Rep. UCB/CSD 89/502.
[15] J. R. Larus and P. N. Hilfinger,“Detecting conflicts between structure accesses,”inProc. SIGPLAN '88 Conf. Programming Languages Design and Implementation,June 1988, pp. 21–34;SIGPLAN Notices, vol. 23, no. 7.
[16] B. Stroustrup,The C++ Programming Language. Reading MA: Addison-Wesley, 1991, 2nd ed.
[17] D. L. Parnas,“On a buzzword: Hierarchical structure,”inProc. IFIP Congr.Amsterdam, The Netherlands: North-Holland, Mar. 1974.
[18] D. Clark, "The Structuring of Systems with Upcalls," Proc. 10th ACM Symp. Operating Systems Principles,Orcas Island, Washington, Dec. 1985.
[19] H. L. Ossher,“A mechanism for specifying the structure of large, layered programs,”inRes. Directions in Object-Oriented Programming,B. Shriver and P. Wegner, Eds. Boston, MA: M.I.T. Press, 1987, pp. 219–252.
[20] V. Rajlich and J. Sliva,“A case study of software reuse in the vertical domain,”inProc. 4th Syst. Reengineering Technol. Workshop,Monterey, CA, Feb. 1994.
[21] K. B. Gallagher and J. R. Lyle,“Using program slicing in software maintenance,”IEEE Trans. Software Eng.,vol. 17, pp. 751–761, Aug. 1991.
[22] S. Horwitz, J. Prins, and T. Reps, ”Integrating Noninterfering Versions of Programs,” ACM Trans. Programming Languages and Systems, vol. 11, no. 3, pp. 345–387, July 1989.
[23] M. Weiser,“Program slicing,”IEEE Trans. Software Eng.,vol. SE-10, pp. 352–357, July 1984.
[24] S. Horwitz, T. Reps, and D. Binkley, “Interprocedural Slicing Using Dependence Graphs,” ACM Trans. Programming Languages and Systems. vol. 12, no. 1, pp. 26-60, Jan. 1990.
[25] T. Reps and T. Teitelbaum,“Language processing in program editors,”IEEE Comput.,pp. 29–40, Nov. 1987.
[26] M. Burke, "An Interval-Based Approach to Exhaustive and Incremental Interprocedural Data-Flow Analysis," ACM Trans. Programming Languages and Systems, vol. 12, no. 3, pp. 341-395, July 1990.
[27] W. G. Griswold,“Direct update of dataflow representations for a meaning-preserving program restructuring tool,”inACM SIGSOFT '93 Symp. Foundations of Software Eng.,Dec. 1993, pp. 42–55.
[28] T. J. Marlowe and B. G. Ryder,“Hybrid incremental alias algorithms,”inHawaii Int. Conf. Syst. Software,Jan. 1991, pp. 428–437.
[29] W. Landi, B.G. Ryder, and S. Zhang, “Interprocedural Modification Side Effect Analysis with Pointer Aliasing,” Proc. ACM SIGPLAN Conf. Programming Language Design and Implementation, pp. 56-67, June 1993.
[30] A.V. Aho, R. Sethi, and J.D. Ullman, Compilers, Principles, Techniques and Tools.New York: Addison-Wesley, 1985.
[31] D.J. Kuck,R. Kuhn,D. Padua,B. Leasure,, and M. Wolfe,“Dependence graphs and compiler optimizations,” Proc. 1981 SIGACT-SIGPLAN Symp. Principles of Programming Languages, pp. 207-218, Jan. 1981.
[32] R. W. Bowdidge and W. G. Griswold,“Automated support for encapsulating abstract data types,”inACM SIGSOFT '94 Symposium on the Foundations of Software Engineering,Dec. 1994, pp. 97–110.
[33] D. Notkin, D. Garlan, W. G. Griswold, and K. Sullivan,“Adding implicit invocation to languages: Three approaches,”inObject Technologies for Advanced Software. First JSSST Int. Symp., Nov. 1993, vol. 742 ofLecture Notes in Computer Science,pp. 489–510.
[34] D. R. Chase, M. Wegman, and F. K. Zadeck,“Analysis of pointers and structures,”inProc. SIGPLAN '90 Conf. Programming Languages Design and Implementation,June 1990, pp. 296–310;SIGPLAN Notices, vol. 25, no. 6.
[35] T. J. Marlowe and B. G. Ryder,“An efficient hybrid algorithm for incremental data flow analysis,”inProc. 17th Symp. Principles of Programming Languages,Jan. 1990, pp. 184–196.
[36] E. Lippe and V. van Oosterom,“Operation-based merging,”inProc. SIGSOFT '92 Fifth Symp. Software Develop. Environ.,Dec. 1992, pp. 78–87.

Index Terms:
Software architecture, software design, program restructuring, program representation, modularization, layered systems, evolution
Citation:
William G. Griswold, David Notkin, "Architectural Tradeoffs for a Meaning-Preserving Program Restructuring Tool," IEEE Transactions on Software Engineering, vol. 21, no. 4, pp. 275-287, April 1995, doi:10.1109/32.385967
Usage of this product signifies your acceptance of the Terms of Use.