Re: How to get Ada to ?cross the chasm??

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

On 18-05-07 20:49 , Paul Rubin wrote:
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
>> The difference to GC is determinism and efficiency. You don't need to
>> lock in order to decide if the object must be reclaimed.
>
> I don't see it.  I saw the word "lock" and thought you meant a
> concurrency lock, but I think you mean the notorious GC pause.  Yes that
> was a noticible issue in the 1980s but it's much less of one now.  In
> any case, something similar happens with refcounting: if you drop the
> last reference to a large structure, you have to recursively traverse
> the structure to decrement the refcount of everything that the structure
> contains pointers to.  So you still get arbitrarily long pauses.

True in general, but in the kinds of applications that I work on, and I 
believe in Dmitry's applications too, the length of such nested pointer 
chains is small and bounded. In fact, in all my current uses of 
reference counting, there are no nested pointers in any 
reference-counted object, so no recursive ref-count decrementation.

For the general case, I remember seeing some papers where the recursive 
reference-count decrementation was amortized over time, by recursing 
only by a bounded amount, and leaving (enqueuing) the rest of the job 
for later. This is similar to the GC systems where collection pauses are 
bounded.

> Regarding concurrency: any concurrent system is non-deterministic by
> definition.  So handling non-determinisism is simply part of the deal
> when you find yourself writing a concurrent program.

When one writes a concurrent program, the aim is to ensure that the 
program behaves as deterministically as required, even though the inputs 
are non-deterministic in content or timing. For example, schedulability 
analysis is one tool for ensuring a deterministic result (deadlines are 
met) in the face of non-deterministic inputs (variable input timings and 
task triggerings).

Additional non-determinism from the run-time SW system, such as 
garbage-collection pauses or large variations in allocation times due to 
heap fragmentation, is then an undesirable complication.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .