Re: Garbage collection in C++
On Nov 19, 1:44 pm, "Chris M. Thomasson" <n...@spam.invalid> wrote:
"Matthias Buelow" <m...@incubus.de> wrote in message
news:6oj5jvF3us0aU1@mid.dfncis.de...
Juha Nieminen wrote:
I have worked in a project where the amount of calculations perfor=
med
by a set of programs was directly limited by the amount of available
memory. (If the program started to swap, it was just hopeless to try t=
o
wait for it to finish.)
You seem to think that a program that uses GC uses more memory, which i=
s
just false in the general case.
Well, memory only gets reclaimed when the GC "decides" to run a scan. So,=
if
the program is making frequent allocations, and the GC does not run enoug=
h
scans to keep up, it has no choice to keep expanding its internal heaps.
You make it sound like its a random occurance? GC runs when the
"managed" heap is full. Even then the heap is split into generations
and a *complete* reclamation isn't done all the time. If you make
frequent allocations, sooner or later you will run out of allocatable
memory and GC will then kick in. One common theme through out this
thread is from people like Juha who claim that this will simply
encourage programmers to allocate willy-nilly w/o bothering about
performance of the application. Well, if you can find that kind of
cowboy programmer, chances are he/she is going to be equally idiotic
about some other aspect of the language. I just don't understand why
or how GC is breaking new ground here.
// GC world
struct foo {
void do_something();
};
void thread() {
foo* f;
for (;;) {
f = new foo();
f->do_something();
}
}
int main() {
// create 32 threads
reutrn 0;
}
// Manual world
struct foo {
void do_something();
};
void thread() {
foo* f;
for (;;) {
f = new foo();
f->do_something();
delete f;
}
}
int main() {
// create 32 threads
reutrn 0;
}
Why should it use more? The amount of
memory a program is using depends on the program logic and its memory
trace and not on how the memory is managed, which is, as I said, an
uninteresting implementation detail.
Which program is going to use more memory? The Manual world, there can on=
ly
ever be up to 32 foo objects at a time. In the GC worlds, well, there can
potentially be hundreds, or thousands, in between GC scan intervals...
This is like arguing that templates provide compile-time
polymorphism. Of course they do!! Thats what they are for. In the
manual world memory management is the programmers' responsibility, in
the GC world you transfer it to the tool. The quantity of memory your
application needs is your application's own business. GC simply
_manages_ how much you create. If you create more its more work for
GC, if you create less its less work for GC. I am left wondering if
you are committing a non-sequitur or a tautology.