Re: reclaiming memory guarantees
Brendan Miller ha scritto:
Some related thoughts, since I thought your discussion of the various
levels of memory allocation was interesting.
I don't believe that type 2 memory is *ever* returned to type 1 memory in
real world systems. If you allocate a couple of gigabytes of memory, free
it, and then spend the rest of the life time using only a couple of
gigabytes, your total heap size should stay at 2 gigabytes, even if 99% of
the heap is sitting unused.
Are there any malloc implementations that are actually known to return
memory to the os?
<snip>
Of course, mine was an oversimplification of the issue, just the sake of
brevity. The fact is that in any implementations there are several
"tiers", the first one usually being the OS (if there's one! there are
embedded systems that don't have a real OS to speak about) and the last
one being a single object. Each tier requests memory from the previous
one and provides memory to the subsequent one(s). While descending this
hierarchy the memory becomes progressively "less free".
For example, there is usually a fourth tier which I didn't mention:
1) OS
2) C runtime
3) allocator
4) container
In this respect, the container could not even be consider a "leaf" in
this hierarchy, so we should add a fifth tier representing the container
element.
There are OSes which have system calls (for example CreateHeap on Win32)
which can be used to provide additional tiers.
To help debugging, I've seen several projects introducing another tier:
1) OS
2) C runtime
3) debug hooks
4) allocator
5) object
So, you see, speaking of when memory is swapped to disk may be an
important detail, but it's nothing more than an implementation-dependent
issue which is way outside the scope of my post and of a C++ discussion
in general.
Just my opinion,
Ganesh
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]