Static extraction and conformance analysis of hierarchical runtime architectural structure using annotations

Subscribe (Full Service)


	Search: The ACM Digital Library The Guide

	Feedback

Static extraction and conformance analysis of hierarchical runtime architectural structure using annotations

Full text

Pdf (739 KB)

Source

Conference on Object Oriented Programming Systems Languages and Applications archive
Proceeding of the 24th ACM SIGPLAN conference on Object oriented programming systems languages and applications table of contents

Orlando, Florida, USA

SESSION: Evolutioin and transformations table of contents

Pages 321-340

Year of Publication: 2009

ISBN:978-1-60558-766-0

Also published in ...

Authors

Marwan Abi-Antoun	Carnegie Mellon University, Pittsburgh, PA, USA
Jonathan Aldrich	Carnegie Mellon University, Pittsburgh, PA, USA

Sponsor

SIGPLAN: ACM Special Interest Group on Programming Languages

Publisher

ACM New York, NY, USA

Bibliometrics

Downloads (6 Weeks): 25, Downloads (12 Months): 25, Citation Count: 0

Additional Information:

abstract references index terms

Tools and Actions:	Request Permissions Review this Article Save this Article to a Binder Display Formats: BibTeX EndNote ACM Ref

DOI Bookmark:	Use this link to bookmark this Article: http://doi.acm.org/10.1145/1640089.1640113 What is a DOI?

ABSTRACT

An object diagram makes explicit the object structures that are only implicit in a class diagram. An object diagram may be missing and must extracted from the code. Alternatively, an existing diagram may be inconsistent with the code, and must be analyzed for conformance with the implementation. One can generalize the global object diagram of a system into a runtime architecture which abstracts objects into components, represents how those components interact, and can decompose a component into a nested sub-architecture.

A static object diagram represents all objects and inter-object relations possibly created, and is recovered by static analysis of a program. Existing analyses extract static object diagrams that are non-hierarchical, do not scale, and do not provide meaningful architectural abstraction. Indeed, architectural hierarchy is not readily observable in arbitrary code. Previous approaches used breaking language extensions to specify hierarchy and instances in code, or used dynamic analyses to extract dynamic object diagrams that show objects and relations for a few program runs.

Typecheckable ownership domain annotations use existing language support for annotations and specify in code object encapsulation, logical containment and architectural tiers. These annotations enable a points-to static analysis to extract a sound global object graph that provides architectural abstraction by ownership hierarchy and by types, where architecturally significant objects appear near the top of the hierarchy and data structures are further down.

Another analysis can abstract an object graph into a built runtime architecture. Then, a third analysis can compare the built architecture to a target, analyze and measure their structural conformance, establish traceability between the two and identify interesting differences.

REFERENCES

Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references.

	1	M. Abi-Antoun. Static Extraction and Conformance Analysis of Hierarchical Runtime Architectural Structure. PhD thesis, Carnegie Mellon University. Available as Technical Report CMU-ISR-09-119.
	2	M. Abi-Antoun and J. Aldrich. Ownership Domains in the Real World. In IWACO, pages 93--104, 2007.
	3	M. Abi-Antoun and J. Aldrich. A Field Study in Static Extraction of Runtime Architectures. In PASTE, 2008.
	4	M. Abi-Antoun and J. Aldrich. Static Extraction of Sound Hierarchical Runtime Object Graphs. In Types in Lang. Design and Impl. (TLDI), pages 51--64, 2009.
	5	M. Abi-Antoun, J. Aldrich, and W. Coelho. A Case Study in Re-engineering to Enforce Architectural Control Flow and Data Sharing. J. Systems & Software, 80(2):240--264, 2007.
	6	M. Abi-Antoun, J. Aldrich, N. Nahas, B. Schmerl, and D. Garlan. Differencing and Merging of Architectural Views. Automated Software Eng., 15(8):35--74, 2008.
	7	J. Aldrich and C. Chambers. Ownership Domains: Separating Aliasing Policy from Mechanism. In ECOOP, pages 1--25, 2004.
	8	J. Aldrich, C. Chambers, and D. Notkin. ArchJava: Connecting Software Architecture to Implementation. In ICSE, pages 187--197, 2002.
	9	A. Christl, R. Koschke, and M.-A. Storey. Equipping the Reflexion Method with Automated Clustering. In WCRE, 2005.
	10	D. G. Clarke, J. M. Potter, and J. Noble. Ownership Types for Flexible Alias Protection. In OOPSLA, pages 48--64, 1998.
	11	P. Clements et al. Documenting Software Architecture. Addison-Wesley, 2003.
	12	D. Conte, P. Foggia, C. Sansone, and M. Vento. Thirty Years of Graph Matching in Pattern Recognition. Int. J. Pattern Recognit. Artif. Intell., 18(3):265--298, 2004.
	13	C. Flanagan and S. N. Freund. Dynamic Architecture Extraction. In FATES-RV, 2006.
	14	E. Gamma, R. Helm, R. Johnson, and J. Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley, 1994.
	15	D. Garlan et al. The Acme Architectural Description Language. http://www.cs.cmu.edu/ acme.
	16	T. Hill, J. Noble, and J. Potter. Scalable Visualizations of Object-Oriented Systems with Ownership Trees. J. Visual Lang. and Comput., 13(3):319--339, 2002.
	17	D. Jackson and A. Waingold. Lightweight Extraction of Object Models from Bytecode. TSE, 27(2), 2001.
	18	jRM. http://jrmtool.sourceforge.net, 2003.
	19	R. Koschke and D. Simon. Hierarchical Reflexion Models. In WCRE, 2003.
	20	P. Lam and M. Rinard. A Type System and Analysis for the Automatic Extraction and Enforcement of Design Information. In ECOOP, pages 275--302, 2003.
	21	S. Lee, G. Murphy, T. Fritz, and M. Allen. How can diagramming tools help support programming activities. In VL/HCC, pages 246--249, 2008.
	22	D. C. Luckham and J. Vera. An Event-Based Architecture Definition Language. TSE, 21(9):717--734, 1995.
	23	K.-K. Ma and J. S. Foster. Inferring Aliasing and Encapsulation Properties for Java. In OOPSLA, 2007.
	24	N. Medvidovic, P. Oreizy, J. E. Robbins, and R. N. Taylor. Using Object-Oriented Typing to Support Architectural Design in the C2 Style. In FSE, 1996.
	25	N. Medvidovic and R. N. Taylor. A Classification and Comparison Framework for Software Architecture Description Languages. TSE, 26(1), 2000.
	26	A. Milanova, A. Rountev, and B. G. Ryder. Constructing Precise Object Relation Diagrams. In ICSM, 2002.
	27	A. Milanova, A. Rountev, and B. G. Ryder. Parameterized Object Sensitivity for Points-To Analysis for Java. TOSEM, 14(1):1--41, 2005.
	28	G. C. Murphy, D. Notkin, and K. J. Sullivan. Software Reflexion Models: Bridging the Gap between Design and Implementation. TSE, 27(4):364--380, 2001.
	29	R. W. O'Callahan. Generalized Aliasing as a Basis for Program Analysis Tools. PhD thesis, CMU, 2001.
	30	M. Sagiv, T. Reps, and R. Wilhelm. Parametric Shape Analysis via 3-Valued Logic. In POPL, 1999.
	31	J. Schafer and A. Poetzsch-Heffter. A Parameterized Type System for Simple Loose Ownership Domains. Journal of Object Technology, 5(6):71--100, 2007.
	32	J. Schafer, M. Reitz, J.-M. Gaillourdet, and A. Poetzsch-Heffter. Linking Programs to Architectures: an Object-Oriented Hierarchical Software Model based on Boxes. In Common Component Modeling Example (CoCoME), pages 238--266, 2008.
	33	B. Schmerl, J. Aldrich, D. Garlan, R. Kazman, and H. Yan. Discovering Architectures from Running Systems. TSE, 32(7):454--466, 2006.
	34	M. Sefika, A. Sane, and R. H. Campbell. Monitoring Compliance of a Software System with its High-Level Design Models. In ICSE, pages 387--396, 1996.
	35	M.-A. Storey, C. Best, and J. Michaud. SHriMP Views: An Interactive Environment for Exploring Java Programs. In IWPC, page 111, 2001.
	36	P. Tonella and A. Potrich. Reverse Engineering of Object Oriented Code. Springer-Verlag, 2004.
	37	R. van Ommering, R. Krikhaar, and L. Feijs. Languages for Formalizing, Visualizing and Verifying Software Architectures. Computer Languages, 27(1-3):3--18, 2001.