Skip to main content
SpringerLink
Log in

Support for Implementation of Evolutionary Concurrent Systems

  • Published:
International Journal of Parallel Programming Aims and scope Submit manuscript

Abstract

Concurrent programs that embed specifications of synchronizations in the body of their component are difficult to extend and modify. Small changes in a concurrent program, particularly changes in the interactions among components, may require re-implementation of a large number of components. Even specifications of components cannot be reused easily. This paper presents a concurrent program composition mechanism in which both specification and implementation of computations and interactions are completely separated. Separation of specifications and implementations facilitates extensions and modifications of programs by allowing one to separately change the implementations of computations and interactions. It also supports their reusability. The paper also describes the design and implementation of a concurrent object-oriented programming language based on this model, including a compiler for the language, and reports on the execution behavior of programs written in the language.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Similar content being viewed by others

REFERENCES

  1. Gregory R. Andrews, Concurrent Programming, The Benjamin/Cummings Publishing Company, Redwood City, California (1991).

    Google Scholar 

  2. Raju Pandey and James C. Browne, A Compositional Approach to Concurrent Object-Oriented Programming, IEEE Int'l. Conf. Computer Lang., IEEE Press (May 1994).

  3. Chris Tomlinson and Mark Scheevek, Concurrent Object Oriented Programming Languages, In Kim and F. H. Lochovsky (eds.), Object Oriented Concepts, Databases, and Applications, ACM Press, pp. 79–124 (1989).

  4. Denis Caromel, Toward a Method of Object-Oriented Concurrent Programming, Comm. ACM, 36(9):90–102 (September 1993).

    Google Scholar 

  5. K. Mani Chandy and Carl Kesselman, Compositional C++: Compositional Parallel Programming, Technical Report Caltech-CS-TR-92–13, Cal Tech (1992).

  6. C. A. R. Hoare, Communicating Sequential Processes, CACM, 21(8):666–677 (1978).

    Google Scholar 

  7. Dennis Kafura and Keung Lee, Inheritance in Actor Based Concurrent Object-Oriented Languages, Proc. ECOOP'89, Cambridge University Press, pp. 131–145 (1989).

  8. S. Crespi Reghizzi and G. Galli de Paratesi, Definition of Reusable Concurrent Software Components, ECOOP '91, Springer-Verlag, pp. 148–165 (1991).

  9. Laurent Thomas, Extensibility and Reuse of Object-Oriented Synchronization Components, Parallel Architecture and Languages Europe, LNCS 605, Springer Verlag, pp. 261–275 (1992).

  10. Chris Tomlinson and Vineet Singh, Inheritance and Synchronization with Enabled Sets, OOPSLA '89 Conf. Object-Oriented Programming, ACM Press, pp. 103–112 (1989).

  11. Bjarne Stroustrup, The C++ Programming Language, Addison Wesley, 2nd ed. (1991).

  12. I. Foster, C. Kesselman, and S. Tuecke, The Nexus Approach to Integrating Multithreading and Communication, J. Parallel and Distributed Computation (1996).

  13. Raju Pandey, A Compositional Approach to Concurrent Programming, Ph.D. thesis, University of Texas at Austin, August (1995).

  14. J. Barnes and P. Hut, A Hierarchical O(N log N) Force Calculation Algorithm, Nature, p. 324 (1986).

  15. William Gropp, Ewing Lusk, and Anthony Skjellum, Using MPI: Portable Parallel Programming with the Message-Passing Interface, The MIT Press, Cambridge, Massachusetts (1994).

    Google Scholar 

  16. G. R. Andrews and F. B. Schneider, Concepts and Notations for Concurrent Programming, ACM Computing Surveys, 15(1):3–43 (1983).

    Google Scholar 

  17. H. E. Bal, J. G. Steiner, and A. S. Tanenbaum, Programming Languages for Distributed Computing Systems, ACM Computing Surveys, 21(3):259–321 (1989).

    Google Scholar 

  18. D. B. Skillicorn and D. Talia, Models and Languages for Parallel Computation, ACM Computing Survey, 30(2):123–169 (June 1998).

    Google Scholar 

  19. N. Medvidovic, A Classification and Comparison Framework for Software Architecture Description Languages, Technical Report UCI-ICS-97–02, University of California, Irvine, California (1997).

    Google Scholar 

  20. M. Shaw and D. Garlan, Software Architecture: Perspectives on An Emerging Discipline, Prentice Hall (1996).

  21. J. Bishop and R. Faria, Languages for Configuration Programming: A Comparison, Technical Report UP CS 94–04, University of Pretoria, South Africa (1994).

    Google Scholar 

  22. R. Allen and D. Garlan, Beyond Definition-Use: Architectural Interconnection, Int'l. Workshop on Interface Definition Languages, SIGPLAN, 29:35–45 (1994).

    Google Scholar 

  23. M. Shaw, R. DeLine, D. V. Klein, T. L. Ross, D. M. Young, and G. Zelesnik, Abstractions for Software Architecture and Tools to Support Them, IEEE Trans. Software Engng., 21(4):314–335 (April 1995).

    Google Scholar 

  24. J. Magee, N. Dulay, and J. Kramer, Structuring Parallel and Distributed Programs, Software Engng. J., 8(2):73–82 (1993).

    Google Scholar 

  25. J. Magee, N. Dulay, and J. Kramer, Regis: A Constructive Development Environment for Distributed Programs, Distributed Syst. Engng. J., 1(5):304–312 (1994).

    Google Scholar 

  26. J. Purtilo, The Polylith Software Bus, ACM Trans. Progr. Lang. Syst., 16(1):151–174 (1994).

    Google Scholar 

  27. C. V. Lopes and G. Kiczales, D: A Language Framework for Distributed Programming, Technical Report SPL97–010, Xerox Palo Alto Research Center (February 1997).

  28. Satoshi Matsuoka, Keniro Taura, and Akinori Yonezawa, Highly Efficient and Encapsulated Re-use of Synchronization Code in Concurrent Object-Oriented Languages, OOPSLA'93, ACM SIGPLAN, ACM Press, pp. 109–126 (1993).

  29. Svend Frolund and Gul Agha, A Language Framework for Multi-Object Coordination, Proc. ECOOP'93, pp. 346–360 (1993).

  30. Ian T. Foster, Information Hiding in Parallel Programs, Technical Report MCS-P290–0292, Argonne National Laboratory (1992).

  31. Peter A. Buhr and Richard A. Strossbosscher, μC++ Annotated Reference Manual, Technical Report Version 3.7, University of Waterloo, Waterloo, Ontario, Canada, N2L 3G1 (June 1993).

    Google Scholar 

  32. R. Chandra, A. Gupta, and J. L. Hennessy, COOL: A Language for Parallel Programming, Languages and Compilers for Parallel Computing Conference, Springer Verlag, pp. 126–147 (1992).

  33. Andrew S. Grimshaw, Easy-to-Use Object-Oriented Parallel Processing with Mentat, IEEE Computer, 26(6):39–51 (1993).

    Google Scholar 

  34. D. Dechouchant, S. Krakowiak, M. Meyesmbourg, M. Riveill, and X. Rousset de Pina, A Synchronization Mechanism for Typed Objects in a Distributed Systems, Workshop on Object-Based Concurrent Progr., ACM SIGPLAN, ACM, pp. 105–107 (September 1989).

  35. Narain H. Gehani, Capsules: A Shared Memory Access Mechanism for Concurrent C/C++, IEEE Trans. Parallel and Distributed Systems, 4(7):795–810 (July 1993).

    Google Scholar 

  36. J. E. Grass and R. H. Campbell, Mediators: A Synchronization Mechanism, Sixth Int'l. Conf. Distributed Computing Systems, pp. 468–477 (1986).

  37. Ciaran McHale, Bridget Walsh, Sea-n Baker, and Alexis Donnelly, Scheduling Predicates, Object-Based Concurrent Computing Workshop, ECOOP'91, LNCS 612, Springer Verlag, pp. 177–193 (1991).

  38. Christian Neusius, Synchronizing Actions, ECOOP '91, Springer Verlag, pp. 118–132 (1991).

  39. Svend Frolund, Inheritance of Synchronization Constraints in Concurrent Object-Oriented Programming Languages, ECOOP '92, LNCS 615, Springer Verlag, pp. 185–196 (1992).

  40. Satoshi Matsuoka, Language Features for Re-use and Extensibility in Concurrent Object-Oriented Programming, Ph.D. thesis, The University of Tokyo, Japan (June 1993).

    Google Scholar 

  41. R. H. Campbell and A. N. Habermann, The Specification of Process Synchronization by Path Expressions, Lecture Notes on Computer Sciences, Springer Verlag, Vol. 16, pp: 89–102 (1974).

    Google Scholar 

  42. Toby Bloom, Evaluating Synchronization Schemes, Proc. Seventh Symp. Oper. Syst. Principles, ACM, pp. 24–32 (1979).

  43. R. Pandey and James C. Browne, Support for Extensibility and Reusability in Concurrent Object-Oriented Programming Languages, Proc. Int'l. Parallel Processing Symp., IEEE, pp. 241–248 (1996).

  44. Satoshi Matsuoka and Akinori Yonezawa, Analysis of Inheritance Anomaly in Object-Oriented Concurrent Programming Languages, Research Directions in Object-Based Concurrency, MIT Press, Cambridge (1993).

    Google Scholar 

Download references

Author information

Authors and Affiliations

  1. Parallel and Dist. Computing Laboratory, Department of Computer Science, University of California, Davis, California, 95616

    Raju Pandey

  2. Department of Computer Sciences, The University of Texas, Austin, TX, 78702

    James C. Browne

Authors
  1. Raju Pandey
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. James C. Browne
    View author publications

    You can also search for this author in PubMed Google Scholar

Rights and permissions

Reprints and permissions

About this article

Cite this article

Pandey, R., Browne, J.C. Support for Implementation of Evolutionary Concurrent Systems. International Journal of Parallel Programming 29, 401–431 (2001). https://doi.org/10.1023/A:1011173302980

Download citation

  • Issue Date:

  • DOI: https://doi.org/10.1023/A:1011173302980

Search

Navigation