Abnormally high memory usage about gperftools HOT 9 CLOSED

You can try MallocExtension::DumpStats, which will report some information about
tcmalloc's internal state.  This may be enough to figure out what memory loss 
is due
to internal fragmentation, what is due to the fact tcmalloc does not return 
memory to
the system, and so forth.

I'm not an expert on tcmalloc internals myself, so I'm afraid I can't give an
authoratative answer on how well tcmalloc "should" work for your application.

} I tried making a small test case, but I stumbled upon the problem that
} simply allocating a lot of small blocks and subsequently deallocating them
} never returns the memory back to the OS.

MallocExtension has a method called ReleaseFreeMemory() which may be helpful 
for your
test case.  You might also try using it in your actual application.  See the 
caveats
for when it's appropriate in google/malloc_extension.h, though.

You can try MallocExtension::DumpStats, which will report some information about
tcmalloc's internal state.  This may be enough to figure out what memory loss 
is due
to internal fragmentation, what is due to the fact tcmalloc does not return 
memory to
the system, and so forth.

I'm not an expert on tcmalloc internals myself, so I'm afraid I can't give an
authoratative answer on how well tcmalloc "should" work for your application.

} I tried making a small test case, but I stumbled upon the problem that
} simply allocating a lot of small blocks and subsequently deallocating them
} never returns the memory back to the OS.

MallocExtension has a method called ReleaseFreeMemory() which may be helpful 
for your
test case.  You might also try using it in your actual application.  See the 
caveats
for when it's appropriate in google/malloc_extension.h, though.

(btw, I'm not sure this is actually a bug report.  If there's something you 
think is
broken and actually needs fixing, could you clarify what it is?  Otherwise, it's
probably more useful to have this discussion on the newsgroup (or rather, google
group) for google-perftools.

You can try MallocExtension::DumpStats, which will report some information about
tcmalloc's internal state.  This may be enough to figure out what memory loss 
is due
to internal fragmentation, what is due to the fact tcmalloc does not return 
memory to
the system, and so forth.

I'm not an expert on tcmalloc internals myself, so I'm afraid I can't give an
authoratative answer on how well tcmalloc "should" work for your application.

} I tried making a small test case, but I stumbled upon the problem that
} simply allocating a lot of small blocks and subsequently deallocating them
} never returns the memory back to the OS.

MallocExtension has a method called ReleaseFreeMemory() which may be helpful 
for your
test case.  You might also try using it in your actual application.  See the 
caveats
for when it's appropriate in google/malloc_extension.h, though.

(btw, I'm not sure this is actually a bug report.  If there's something you 
think is
broken and actually needs fixing, could you clarify what it is?  Otherwise, it's
probably more useful to have this discussion on the newsgroup (or rather, google
group) for google-perftools.

You can try MallocExtension::DumpStats, which will report some information about
tcmalloc's internal state.  This may be enough to figure out what memory loss 
is due
to internal fragmentation, what is due to the fact tcmalloc does not return 
memory to
the system, and so forth.

I'm not an expert on tcmalloc internals myself, so I'm afraid I can't give an
authoratative answer on how well tcmalloc "should" work for your application.

} I tried making a small test case, but I stumbled upon the problem that
} simply allocating a lot of small blocks and subsequently deallocating them
} never returns the memory back to the OS.

MallocExtension has a method called ReleaseFreeMemory() which may be helpful 
for your
test case.  You might also try using it in your actual application.  See the 
caveats
for when it's appropriate in google/malloc_extension.h, though.

(btw, I'm not sure this is actually a bug report.  If there's something you 
think is
broken and actually needs fixing, could you clarify what it is?  Otherwise, it's
probably more useful to have this discussion on the newsgroup (or rather, google
group) for google-perftools.

You can try MallocExtension::DumpStats, which will report some information about
tcmalloc's internal state.  This may be enough to figure out what memory loss 
is due
to internal fragmentation, what is due to the fact tcmalloc does not return 
memory to
the system, and so forth.

I'm not an expert on tcmalloc internals myself, so I'm afraid I can't give an
authoratative answer on how well tcmalloc "should" work for your application.

} I tried making a small test case, but I stumbled upon the problem that
} simply allocating a lot of small blocks and subsequently deallocating them
} never returns the memory back to the OS.

MallocExtension has a method called ReleaseFreeMemory() which may be helpful 
for your
test case.  You might also try using it in your actual application.  See the 
caveats
for when it's appropriate in google/malloc_extension.h, though.

(btw, I'm not sure this is actually a bug report.  If there's something you 
think is
broken and actually needs fixing, could you clarify what it is?  Otherwise, it's
probably more useful to have this discussion on the newsgroup (or rather, google
group) for google-perftools.

You can try MallocExtension::DumpStats, which will report some information about
tcmalloc's internal state.  This may be enough to figure out what memory loss 
is due
to internal fragmentation, what is due to the fact tcmalloc does not return 
memory to
the system, and so forth.

I'm not an expert on tcmalloc internals myself, so I'm afraid I can't give an
authoratative answer on how well tcmalloc "should" work for your application.

} I tried making a small test case, but I stumbled upon the problem that
} simply allocating a lot of small blocks and subsequently deallocating them
} never returns the memory back to the OS.

MallocExtension has a method called ReleaseFreeMemory() which may be helpful 
for your
test case.  You might also try using it in your actual application.  See the 
caveats
for when it's appropriate in google/malloc_extension.h, though.

(btw, I'm not sure this is actually a bug report.  If there's something you 
think is
broken and actually needs fixing, could you clarify what it is?  Otherwise, it's
probably more useful to have this discussion on the newsgroup (or rather, google
group) for google-perftools.

You can try MallocExtension::DumpStats, which will report some information about
tcmalloc's internal state.  This may be enough to figure out what memory loss 
is due
to internal fragmentation, what is due to the fact tcmalloc does not return 
memory to
the system, and so forth.

I'm not an expert on tcmalloc internals myself, so I'm afraid I can't give an
authoratative answer on how well tcmalloc "should" work for your application.

} I tried making a small test case, but I stumbled upon the problem that
} simply allocating a lot of small blocks and subsequently deallocating them
} never returns the memory back to the OS.

MallocExtension has a method called ReleaseFreeMemory() which may be helpful 
for your
test case.  You might also try using it in your actual application.  See the 
caveats
for when it's appropriate in google/malloc_extension.h, though.

(btw, I'm not sure this is actually a bug report.  If there's something you 
think is
broken and actually needs fixing, could you clarify what it is?  Otherwise, it's
probably more useful to have this discussion on the newsgroup (or rather, google
group) for google-perftools.

Thanks, I'll try your suggestions.

I didn't notice there was a google group for this, so sorry for the noise. You 
can
close this issue.