Prev: ANN: Units of Measurement for Ada v3.1
Next: SI unit checking
From: usenet on 3 Jul 2010 16:06
Suppose I have a multi-tasking system where different tasks may
execute a sequence like

P1(A,B);
P2(C,D);
P3(E,F);

and I want to make this sequence a critical section. What is the
typical Ada way to do this? Would I wrap P1, P2 and P3 in a protected
object and call as follows (perhaps creating a record to hold A..F to
make things a bit cleaner)?

PO.P(A,B,C,D,E,F);

Or if not that, what? Thanks.
From: John B. Matthews on 3 Jul 2010 17:48
In article
<71385df3-5fec-49b9-9d7a-98cb95a346ed(a)n20g2000prc.googlegroups.com>,
usenet(a)scriptoriumdesigns.com wrote:

> Suppose I have a multi-tasking system where different tasks may
> execute a sequence like
>
> P1(A,B);
> P2(C,D);
> P3(E,F);
>
> and I want to make this sequence a critical section. What is the
> typical Ada way to do this? Would I wrap P1, P2 and P3 in a
> protected object and call as follows (perhaps creating a record to
> hold A..F to make things a bit cleaner)?
>
> PO.P(A,B,C,D,E,F);
>
> Or if not that, what? Thanks.

Looks like what it was designed for. See also,

<http://www.adaic.com/standards/95rat/RAThtml/rat95-p1-2.html#9>
<http://www.adaic.com/standards/05rat/html/Rat-5-3.html>

--
John B. Matthews
trashgod at gmail dot com
<http://sites.google.com/site/drjohnbmatthews>
From: Dmitry A. Kazakov on 4 Jul 2010 03:58
On Sat, 3 Jul 2010 13:06:24 -0700 (PDT), usenet(a)scriptoriumdesigns.com
wrote:

> Suppose I have a multi-tasking system where different tasks may
> execute a sequence like
>
> P1(A,B);
> P2(C,D);
> P3(E,F);
>
> and I want to make this sequence a critical section. What is the
> typical Ada way to do this?

I depends on the nature of P1..P3

> Would I wrap P1, P2 and P3 in a protected
> object and call as follows (perhaps creating a record to hold A..F to
> make things a bit cleaner)?
>
> PO.P(A,B,C,D,E,F);
>
> Or if not that, what?

There are many ways and solutions, starting with better design. What are
A,B,C,D,E,F. They might be made objects or put into object maintaining
their invariants when accessed concurrently.

At the low level there are four major approaches:

1. Protected operation. Used when what you do is short and non-blocking.
E.g. P1 cannot do I/O.

2. Monitor task performing desired actions. This one can perform lengthy or
blocking operations.

3. Mutexes (implemented by a protected object, mutex holder is wrapped into
a controlled object). The mutex holder when constructed seizes the mutex
and releases it upon finalization. While the holder exists you execute the
desired actions.

4. Asynchronous monitor task. That is when you start actions entering a
rendezvous with the monitor. Then you leave the rendezvous and do something
else, while the monitor is busy executing the actions. Some time later you
engage another rendezvous to make sure that the monitor task finished the
work.

--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de
 | 
Pages: 1
Prev: ANN: Units of Measurement for Ada v3.1
Next: SI unit checking