Greedy memory handling

[monarch_dodra]

On Wednesday, 11 September 2013 at 13:33:23 UTC, Joseph Rushton 
Wakeling wrote:
> On 11/09/13 15:13, monarch_dodra wrote:
>> That's somewhat better, as it would allow the GC to collect my 
>> buffer, if it
>> wants to, but I wouldn't actually know about it afterwards 
>> which leaves me screwed.
>
> Just to clarify, is this buffer meant only for internal use in 
> your function or is it meant to be externally accessed as well?
>  I'd kind of assumed the former.
>
> Either way, isn't it sufficient to have some kind of
>
>     if (buf is null)
>     {
>         // allocate the buffer
>     }
>
> check in place?  The basic model seems right -- at the moment 
> when you need the buffer, you check if it's allocated (and if 
> not, allocate it as needed); you indicate to the GC that it 
> shouldn't collect the memory; you use the buffer; and the 
> moment it's no longer needed, you indicate to the GC that it's 
> collectable again.
>
> It means having to be very careful to check the buffer's 
> allocation status whenever you want to use it, but I think 
> that's an unavoidable consequence of wanting a static variable 
> that can be freed if needed.
>
> The alternative I thought of was something like comparing the 
> size difference between the currently-needed buffer and the 
> last-needed buffer (... or if you want to be over-the-top, 
> compare to a running average:-), and if the current one is 
> sufficiently smaller, free the old one and re-alloc a new one; 
> but that's a bit _too_ greedy in the free-up-memory stakes, I 
> think.

The buffer is meant strictly for internal use. It never escapes 
the function it is used in, which not re-entrant either.

Basically, I'm storing the buffer in a "static ubyte[]", and if 
there isn't enough room for what I'm doing, I simply make it 
grow. No problems there.

The issue I'm trying to solve is "and the moment it's no longer 
needed" part. The function is really just a free function, in a 
library. The user could use it ever only once, or use it very 
repeatedly, I don't know. I particular, the amount of buffer 
needed has a 1:1 correlation with the user's input size. The user 
could repeatedly call me with input in the size of a couple of 
bytes, or just once or twice with input in the megabytes.

I *could* just allocate and forget about it, but I was curious 
about having a mechanism where the buffer would just be 
"potentially collected" between two calls. As a form of 
"failsafe" if it got too greedy, or if the user just hasn't used 
the function in a while.