Concurrency abstractions in a C++ class library

ABSTRACT

C++ is increasingly becoming the language of choice among software developers. It is therefore not surprising to see the many attempts that have been made to add concurrency to C++. Concurrency can be added to C++ either by extending the language or through the use of a class library.There is much debate among language designers about the approach to take in the integration of two paradigms of concurrency and object-oriented programming (OOP). The library approach keeps the language small, allows the programmer to work with familiar compilers and tools, provides the option of sup - porting many concurrent models through a variety of libraries, and eases porting of code to other architectures (usually, a small amount of assembler code needs to be changed). Software developers typically have large investments in existing code and are reluctant to adopt a new language. A class library with sufficient flexibility that can provide most of the functionality of a new or extended language is often more palatable. On the other hand, new or extended languages can use the compiler to provide higher-level constructs, compile-time type checking, and enhanced performance.The Parallel Computing Project at the Centre for Advanced Studies has been researching the possibility of adding concurrency to C++ with the assistance of a class library. The library consists of two layers. The bottom layer provides a set of low level concurrency primitives. The top layer, ABC++, uses the bottom layer to provide implicit parallelism. To our knowledge, ABC++ is the only concurrent class library that provides almost all of the functionality of extended languages without requiring the users to deal with explicit concurrency control and without imposing severe limitations. This paper outlines the progress of the project, the low level concurrency primitives and describes how ABC++ differs from other existing concurrent class libraries for C++.

REFERENCES

• 1: E. Arjomandi , W. O'Farrell , I. Kalas , G. Koblents , F. Ch. Eigler , G. R. Gao, ABC++: concurrency by inheritance in C++, IBM Systems Journal, v.34 n.1, p.120-137, 1995
• 2: AT&T C++ Language System Release 2.0: Product Reference Manual, 1989, Select Code 307--146.
• 3: Brian N. Bershad , Edward D. Lazowska , Henry M. Levy, PRESTO: a system for object-oriented parallel programming, Software—Practice & Experience, v.18 n.8, p.713-732, August 1988 [doi>10.1002/spe.4380180802]
• 4: A. D. Birrell, J. V. Guttag, J. Horning and R. Levin, Synchronization Primitives for a multiprocessor: a formal specification, Research Report 20, DEC System Research Center, 1987.
• 5: A. D. Birrell, An Introduction to programming with threads, Research Report 35, DEC System Research Center, 1989.
• 6: Grady Booch , Michael Vilot, The design of the C++ Booch Components, Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications, p.1-11, September 1990, Ottawa, Canada
• 7: Jean-Pierre Briot , Akinori Yonezawa, Inheritance and synchronization in concurrent OOP, European conference on object-oriented programming on ECOOP '87, p.32-40, October 1987, Paris, France
• 8: P.A. Buhr and G. Ditchfield, Adding Concurrency to a Programming Language, USENIX C++ Technical Conference, 1992.
• 9: P. A. Buhr , Glen Ditchfield , R. A. Stroobosscher , B. M. Younger , C. Robert Zarnke, &mgr;C++: concurrency in the object-oriented language C++, Software—Practice & Experience, v.22 n.2, p.137-172, Feb. 1992 [doi>10.1002/spe.4380220204]
• 10: Robit Chandra , Anoop Gupta , John L. Hennessy, COOL: a language for parallel programming, Selected papers of the second workshop on Languages and compilers for parallel computing, p.126-148, May 1990, Urbana, Illinois, United States
• 11: E. Cooper and R. Draves, C. Threads, TR CMU-CS-88-154, Carnegie Mellon University, 1988.
• 12: Edsger W. Dijkstra, The structure of the “THE”-multiprogramming system, Communications of the ACM, v.11 n.5, p.341-346, May 1968 [doi>10.1145/363095.363143]
• 13: T. W. Doeppner Jr., and Alan J. Gebele, C++ on a parallel machine, Report CS-87-26, Department of Computer Science, Brown University, November 1987.
• 14: Svend Frølund, Inheritance of Synchronization Constraints in Concurrent Object-Oriented Programming Languages, Proceedings of the European Conference on Object-Oriented Programming, p.185-196, June 29-July 03, 1992
• 15: P. Gautron, Porting and Extending the C++ Task System with the Support of Lightweight Processes, USENIX C++ Conference Proceedings, 1991, 135--146.
• 16: N. H. Gehani , W. D. Roome, Concurrent C++: concurrent programming with class(es), Software—Practice & Experience, v.18 n.12, p.1157-1177, Dec. 1988 [doi>10.1002/spe.4380181205]
• 17: D. Grunwald, A User's Guide to AWESIME: An Object-Oriented Parallel Programming and Simulation System, Technical Report CU-CS-552-91, Department of Computer Science, University of Colorado at Boulder.
• 18: Dennis Kafura, ACT++: building a concurrent C++ with actors, Journal of Object-Oriented Programming, v.3 n.1, p.25-37, May/Jun. 1990
• 19: D. G. Kafura , K. H. Lee, Inheritance in actor based concurrent object-oriented languages, The Computer Journal, v.32 n.4, p.297-304, Aug. 1989 [doi>10.1093/comjnl/32.4.297]
• 20: Laxmikant V. Kale , Sanjeev Krishnan, CHARM++: a portable concurrent object oriented system based on C++, Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applications, p.91-108, September 26-October 01, 1993, Washington, D.C., United States
• 21: Won Kim , F. H. Lochovsky, Object-oriented concepts, databases, and applications, ACM Press, New York, NY, 1989
• 22: S. Matsuoka, K. Wakita, and A. Yonezawa, Synchronization Constraints with Inheritance: What Is Not Possible - So What Is?, TR 90-010, Department of Information Science, the University of Tokyo, 1990.
• 23: S. Matsuoka and A. Yonezawa, Analysis of Inheritance Anomaly in Object-Oriented Concurrent Programming Languages, to appear.
• 24: IEEE, Threads Extension for Portable Operating Systems (Draft 6), P1003.4a/D6, February 1992.
• 25: Hayssam Saleh , Philippe Gautron, A Concurrency Control Mechanism for C++ Objects, Proceedings of the Workshop on Object-Based Concurrent Computing, p.195-210, July 15-16, 1991
• 26: H. Saleh and P. Gautron, A System Library for C++ Distributed Applications on Transputers, in Parallel Computing Action: Selections from Publications of the RXF/LITP Team, LITP 91-075, RXF, December 1991. Also in Applications of Transputers 91, IOS Press, August 1991.
• 27: R. Seliger, Extending C++ to Support Remote Procedure Call, Concurrency, Exception Handling, and Garbage Collection, Proceedings of 1990 USENIX C++ Conference, 1990, 241--264.
• 28: L. Sha , R. Rajkumar , J. P. Lehoczky, Priority Inheritance Protocols: An Approach to Real-Time Synchronization, IEEE Transactions on Computers, v.39 n.9, p.1175-1185, September 1990 [doi>10.1109/12.57058]
• 29: Bjarne Stroustrup, The C++ programming language, Addison-Wesley Longman Publishing Co., Inc., Boston, MA, 1986
• 30: B. Stroustrup, A Set of C Classes for Coroutine Style Programming, Technical Report CSRT 90, AT&T, November 1980, revised (1) July 1982, (2) November 1984.
• 31: Bjarne Stroustrup, The C++ programming language (2nd ed.), Addison-Wesley Longman Publishing Co., Inc., Boston, MA, 1991
• 32: C. Tomlinson , V. Singh, Inheritance and synchronization with enabled-sets, Conference proceedings on Object-oriented programming systems, languages and applications, p.103-112, October 02-06, 1989, New Orleans, Louisiana, United States
• 33: Chris Tomlinson , Mark Scheevel, Concurrent object-oriented programming languages, Object-oriented concepts, databases, and applications, ACM Press, New York, NY, 1989 [doi>10.1145/63320.66472]
• 34: Peter Wegner, Dimensions of object-based language design, Conference proceedings on Object-oriented programming systems, languages and applications, p.168-182, October 04-08, 1987, Orlando, Florida, United States