This chapter has given an introduction
to the problems involved in extending
the object paradigm with distribution
and concurrency.
1
- active objects -- client/server model
- cooperation -- concurrent problem solving
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.
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].
3
- design issues --
active/passive objects
- {\em Concurrent C++ } --
\c{an} orthogonal \c{approach}
- {\em ACT++} -- the actor model
- {\em {}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++,
{}C++, Compositional C++ and Mentat/C++,
and we discussed their design rationale.
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.
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.
- Explain why the client/server
model may be regarded as a suitable metaphor
for concurrent object-oriented computing.
- What ways can you think of to extend
object-based languages with concurrency
features?
- How would you characterize the notion of active objects?
- What do you consider the major design issues
in extending C++ with concurrency?
- Discuss how Concurrent C++ extends
C++ with concurrency?
- What are the features of the actor model?
Describe how ACT++ realizes the actor model for C++.
- Characterize how {}C++ extends C++
with concurrency.
Do the same for Compositional C++.
- What problems arise
with respect to concurrency control
if you allow for inheritance?
- Can you think of an example
where inheritance on processes is useful?
What impacts does your solution have
for the implementation language?
- What are the problems involved in remote
object invocation?
Characterize the model of dual objects.
Do you consider this an adequate solution?
Explain.
For background reading on concurrency and
distribution, consult [Ba89] or [Andrews].
Research papers concerning concurrent object-oriented
programming are collected in
[YT87] and [AWY93].