Re: Ada package registry?

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:n9hgje$vai$1@gioia.aioe.org...
> On 11/02/2016 02:37, Randy Brukardt wrote:
>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
>> news:n9c9a8$mt9$1@gioia.aioe.org...
>>> On 09/02/2016 00:02, Randy Brukardt wrote:
>>>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
>>>> news:n94cbv$19ed$1@gioia.aioe.org...
>>>
>>>>> For persistence layer you need dereference primitive operations. One 
>>>>> for
>>>>> read access in order to cache data and one write access to mark the
>>>>> cache
>>>>> dirty.
>>>>
>>>> The first is the function call (to Reference, if you're looking at the
>>>> Ada
>>>> containers), and the second is the Finalize call that happens when the
>>>> object returned from Reference goes away. That was the whole point of 
>>>> the
>>>> design. (Of course, you could have written that in Ada 95, but without
>>>> the
>>>> syntactic sugar that makes it easier to read and write.)
>>>
>>> It is not same. A reference points to a proxy object, a cached copy of 
>>> the
>>> external object in the persistent storage. When the proxy object is
>>> updated via any reference, it must be marked dirty. So that when the
>>> object at some point gets finalized or the transaction is committed it
>>> would be written back to the storage.
>>
>> But actually they are the same, because the reference can only exist for 
>> a
>> very short time. (You can't assign a reference because the accessibility 
>> is
>> too shallow.) Thus, the proxy object can be marked dirty (if you created 
>> a
>> writable reference, which is only created when you actually use the
>> reference in a writable context) and written back to the persistent 
>> storage.
>
> Writing objects is very expensive. So objects must be reference counted 
> anyway. I don't see how the schema can handle all this, as well as 
> inducing the reference type (read-only vs. read-write) from the context.

The language rules determine the reference type from context, so that's done 
automatically for you. (And, yes, there are ACATS tests for it, so a 
conforming Ada compiler will do it correctly -- now. [The tests failed on 
compilers when they came out, but those problems were swiftly fixed.]) See 
the difference between Reference and Constant_Reference in the 
Ada.Containers library.

You don't necessarily have to reference count objects, especially if you use 
a read-write lock (as discussed below); in that case, there can never be 
more than one writable reference active at a time anyway. But you surely can 
do that.

>> You do have to make sure that only one task is potentially writing a 
>> proxy
>> object at a time, but that seems like a good thing.
>
> Not good. Object updating through a reference and handling reference 
> counts must be atomic. References must act as read-write locks.

That's what I meant: the implementation of Reference can include an 
appropriate read-write lock. I wouldn't leave it to the programmer to get 
right.

Everything you've asked about is present in the Ada 2012 features (or 
before), so I think it's possible to write such a library and have it work 
reasonably transparently. Not having tried it myself, I don't want to make a 
100% certainty claim, but surely we intended that it would work.

                       Randy.