Re: Exception propagation

[Ludovic Brenta <ludovic@ludovic-brenta.org>]

"REH" <spamjunk@stny.rr.com> writes:

> Ludovic Brenta wrote:
>> "REH" <spamjunk@stny.rr.com> writes:
>> > I found this "In a distributed program, the identity is unique across
>> > an entire program, not just across a single partition. Exception
>> > propagation works properly across RPC's. An exception can be propagated
>> > from one partition to another, and then back to the first, where its
>> > identity is known. " in the ARM.
>> >
>> > Does this mean that the id of an exception is identical in each
>> > partition? So, if I am using a partitioned OS, can I send an
>> > exception's id from one partition to another and reliably raise it?
>>
>> I am under the impression that you confuse the Ada notion of a
>> "partition" and the OS notion; please correct me if I'm wrong.
>>
> Well, I'm not sure.  What if I have a partitioned Ada program running
> in a partitioned OS?  What I wasn't sure of was whether I could take an
> exception raised in one address space, and send it to another address
> space and re-raise it.  We are using Integrity.  I was told I must use
> connections (and not the RPC services in the distributed annex) because
> they are faster.  Whether that is true or not, I do not know.  What I
> am wondering (I have no hardware or software yet, so I cannot do any
> prototyping), is will the two "pieces" of Ada, which are in separate
> address spaces but built as one monolithic object, have the same
> exception id mapping.  Since I have to use connection objects, I have
> to handle the exception propagation myself.  I am trying to figure out
> if I need to convert the exception ids to a common value both pieces of
> Ada can agree on, like an enumeration, or if that is unnecessary
> because the pieces already agree on the values of the ids.
>
> Is it even possible to have a partitioned Ada program without using
> the distributed services annex?

No, not in the sense of the Ada distributed systems annex.  Whoever
said you must use "connections" instead of "RPC" was thinking in terms
of low-level OS services, and does not display understanding of the
distributed systems annex.  The DSA sits on top of the OS, and uses
whatever services are available.  The DSA then guarantees that all
partitions agree on the same exception definitions, and provides a
common protocol for exception propagation.

If you can't or won't use the DSA, then you're pretty much on your
own, and you have to solve the problems of common definition,
propagation and handling.  Instead of one partitioned program in the
sense of the DSA, you will have several Ada programs talking to each
other, much like you would do in lesser languages.

Unfortunately, it seems you're in that situation, as Green Hills
doesn't support the DSA, or even provide an implementation of it.
Only AdaCore provides an implementation, called GLADE.  With GLADE,
you first compile and test your program as one monolithic executable;
then you use "gnatdist" to split that program into one executable file
per partition.  GLADE does the rest.  It's really very easy to do.

> Does that make sense?

Now it does.

HTH

-- 
Ludovic Brenta.