Re: Languages don't matter. A mathematical refutation

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

"G.B." <bauhaus@futureapps.invalid> wrote in message 
news:mg8ltb$nql$1@dont-email.me...
> On 10.04.15 01:35, Randy Brukardt wrote:
>> But how to do tracing without a lot of overhead??
>
> One lightweight way of allocating and tracing might be so
> dumb that it is not always useful. But I don't know if
> it is never useful, or not useful enough to be considered.
> The point is to really request memory once, and then to do
> almost nothing. Nothing new here (arena pools).

Right. Subpools provide a (possibly) better way to manage those.

> Imagine a procedure that manipulates a graph.
> Or tons of matrices. Or a sequence of short messages.
> You need "new T" for the objects(*).
>
> 1 - require the pool to have enough room for Max objects:
>     one stretch of storage.

Pretty much like any pool. :-)

> 2 - make Allocate return the address of the next free
>     storage element, etc.; remember the then next free
>     storage element in the pool object.

Pretty much like most user-defined pools. I have a pool that does exactly 
that, although the purpose is to detect valid vs. dangling pointers.

> 3 - Deallocate does nothing.

Typical in pools that implement subpools; only a subpool deallocate does 
anything. The mark-release pool example in the RM works this way.

> When the region ends, Finalize of the pool frees memory.
> So, I guess tracing overhead is one assignment for
> keeping track of the next free storage element's address.

Right. The subpool version is a bit more flexible, because it allows dumping 
a bunch of objects at a time (say all of the parts of a single matrix ), 
without dumping everything. Of course, if you use subpools, you reintroduce 
the possibility of dangling pointers. One could combine subpools and smart 
pointers such that dangling pointers are detected, that might be a very 
appealing combination. That wouldn't have to be very expensive (the 
expensive part of smart pointers is the implicit finalization, and one 
wouldn't need it here, at least if you could tolerate someone deallocating a 
pointer that is actively being used -- not a very likely occurrence), and it 
could be built in Ada today.

                               Randy.