Summary

This chapter has given an introduction to the problems involved in extending the object paradigm with distribution and concurrency.

A modeling perspective

1


slide: Section 6.1: A modeling perspective

In section 1, we looked at the client/server model and observed that the notion of active objects fits in naturally. We discussed concurrent problem solving and identified some common patterns of cooperation.

Objects and processes

2

  • language support -- processes, communication, fault-tolerance
  • concurrency -- processes, active objects, asynchrony
  • active objects -- sequential processes

slide: Section 6.2: Objects and processes

In section 2 we discussed language support for concurrency and the notion of active objects. Language support for concurrency and distribution consists of adding processes, communication facilities and fault-tolerance. For concurrency, in particular, we have the choice of adding processes as additional data types, introducing active objects or employing asynchronous communication. Active objects unify the notions of objects and processes. They are analogous to communicating sequential processes as introduced in  [Ho78].

Concurrent extensions of C++

3

  • design issues -- active/passive objects
  • {\em Concurrent C++ } -- \c{an} orthogonal \c{approach}
  • {\em ACT++} -- the actor model
  • {\em %m{}C++} -- write once variables
  • {\em Mentat/C++} -- data flow

slide: Section 6.3: Concurrent extensions of C++

In section 3, we looked at a number of concurrent extensions of C++, including Concurrent C++, ACT++, %m{}C++, Compositional C++ and Mentat/C++, and we discussed their design rationale.

Inheritance on processes

4

  • concurrency control -- \c{centralized,} decentralized
  • behavioral extensions -- ACT++
  • inheritance -- distributed termination \c{detection}

slide: Section 6.4: Inheritance on processes

Further, in section 4, we looked at the problems involved in combining processes and inheritance. An example was given demonstrating how inheritance and multi-threaded objects may be used to model distributed termination detection in a natural way.

Requirements for distribution

5

  • transparency -- \c{distributed} abstractions
  • distributed object computing -- remote object method invocation
  • remote object invocation -- dual objects\c{, annotations, placement}

slide: Section 6.5: Requirements for distribution

Finally, in section 5, we discussed a number of abstraction or transparency requirements and looked at an environment for distributed object computing. We also discussed the issues involved in replicating objects and and remote object method invocation. Finally, we looked at some network protocols.

Questions

  1. Explain why the client/server model may be regarded as a suitable metaphor for concurrent object-oriented computing.
  2. What ways can you think of to extend object-based languages with concurrency features?
  3. How would you characterize the notion of active objects?
  4. What do you consider the major design issues in extending C++ with concurrency?
  5. Discuss how Concurrent C++ extends C++ with concurrency?
  6. What are the features of the actor model? Describe how ACT++ realizes the actor model for C++.
  7. Characterize how %m{}C++ extends C++ with concurrency. Do the same for Compositional C++.
  8. What problems arise with respect to concurrency control if you allow for inheritance?
  9. Can you think of an example where inheritance on processes is useful? What impacts does your solution have for the implementation language?
  10. What are the problems involved in remote object invocation? Characterize the model of dual objects. Do you consider this an adequate solution? Explain.

Further reading

For background reading on concurrency and distribution, consult  [Ba89] or  [Andrews]. Research papers concerning concurrent object-oriented programming are collected in  [YT87] and  [AWY93].