Tracking down memory leaks?

[MKoool]

I have an application with one function called "compute", which given a
filename, goes through that file and performs various statistical
analyses. It uses arrays extensively and loops alot. it prints the
results of it's statistical significance tests to standard out. Since
the compute function returns and I think no variables of global scope
are being used, I would think that when it does, all memory returns
back to the operating system.

Instead, what I see is that every iteration uses several megs more.
For example, python uses 52 megs when starting out, it goes through
several iterations and I'm suddenly using more than 500 megs of ram.

Does anyone have any pointers on how to figure out what I'm doing
wrong?

Thanks,
mohan

[Rene Pijlman]

malv:

Is there any way for making Python return memory no longer needed to
the OS? Cases may arise where you indeed need a big memory block
temporarily without being able to split it up into smaller chunks.

That's not really necessary. On any decent OS it's just unused address
space, that doesn't consume any physical memory.

And when your process runs out of address space, you should program more
carefully :-)

--
René Pijlman

[Robert]

MKoool wrote:

I have an application with one function called "compute", which given a
filename, goes through that file and performs various statistical
analyses. It uses arrays extensively and loops alot. it prints the
results of it's statistical significance tests to standard out. Since
the compute function returns and I think no variables of global scope
are being used, I would think that when it does, all memory returns
back to the operating system.

Instead, what I see is that every iteration uses several megs more.
For example, python uses 52 megs when starting out, it goes through
several iterations and I'm suddenly using more than 500 megs of ram.

Does anyone have any pointers on how to figure out what I'm doing
wrong?

if gc.collect() doesn't help:

maybe objects of extension libs are not freed correctly.

And Python has a real skeleton in the cupboard:

a known problem with python object/libs when classes with __del__ are
involved ( Once suffered myself from such tremendous "unexplaina ble"
memory blow up until I found this "del gc.garbage[:]" remedy:

<http://www.python.org/doc/current/lib/module-gc.html>
garbage
A list of objects which the collector found to be unreachable but
could not be freed (uncollectable objects). By default, this list
contains only objects with __del__() methods.3.1Obje cts that have
__del__() methods and are part of a reference cycle cause the entire
reference cycle to be uncollectable, including objects not necessarily
in the cycle but reachable only from it. Python doesn't collect such
cycles automatically because, in general, it isn't possible for Python
to guess a safe order in which to run the __del__() methods. If you know
a safe order, you can force the issue by examining the garbage list, and
explicitly breaking cycles due to your objects within the list. Note
that these objects are kept alive even so by virtue of being in the
garbage list, so they should be removed from garbage too. For example,
after breaking cycles, do del gc.garbage[:] to empty the list. It's
generally better to avoid the issue by not creating cycles containing
objects with __del__() methods, and garbage can be examined in that case
to verify that no such cycles are being created.
Robert

[MKoool]

> How big is the file you are reading in? If it is (say) 400 MB, then it is

hardly surprising that you will be using 500MB of RAM. If the file is 25K,
that's another story.
Actually, I am downloading the matrix data from a file on a server on
the net using urllib2, and then I am running several basic stats on it
using some functions that i get from matplotlib. Most are statistical
functions I run on standard vectors, such as standard deviation, mean,
median, etc. I do then loop through various matrix items, and then
based on a set of criteria, I attempt to perform a sort of linear
regression model using a few loops on the vectors.
How are you storing your data while you are processing it? I'd be looking
for hidden duplicates.

I am storing basically everything as a set of vectors. For example, I
would have one vector for my X-axis, time. The other variables are the
number of units sold and the total aggregate revenue from selling all
units.

I am wondering if it's actually urllib2 that is messing me up. It
could be matplotlib as well, although I doubt it since I do not use
matplotlib unless the statistical significance test I produce indicates
a high level of strength (very rare), indicating to me that the company
has a "winning" product.

[John J. Lee]

Steven D'Aprano <st***@REMOVETH IScyber.com.au> writes:

On Sun, 12 Feb 2006 05:11:02 -0800, MKoool wrote: [...] I may be mistaken, and if so I will welcome the correction, but Python
does not return memory to the operating system until it terminates.

Objects return memory to Python when they are garbage collected, but not
the OS.

[...]

http://groups.google.com/group/comp....ea1c569a65e13e
John

[Christos Georgiou]

On 12 Feb 2006 05:11:02 -0800, rumours say that "MKoool"
<mo**********@g mail.com> might have written:

I have an application with one function called "compute", which given a
filename, goes through that file and performs various statistical
analyses. It uses arrays extensively and loops alot. it prints the
results of it's statistical significance tests to standard out. Since
the compute function returns and I think no variables of global scope
are being used, I would think that when it does, all memory returns
back to the operating system.
Would your program work if you substituted collections.deq ue for the arrays
(did you mean array.arrays or lists?)? Please test.
Instead, what I see is that every iteration uses several megs more.
For example, python uses 52 megs when starting out, it goes through
several iterations and I'm suddenly using more than 500 megs of ram.
If your algorithms can work with the collections.deq ue container, can you
please check that the memory use pattern changes?
Does anyone have any pointers on how to figure out what I'm doing
wrong?

I suspect that you have more than one large arrays (lists?) that
continuously grow.

It would be useful if you ran your program on a fairly idle machine and had
a way to see if the consumed memory seems to be swapped out without being
swapped in eventually.
--
TZOTZIOY, I speak England very best.
"Dear Paul,
please stop spamming us."
The Corinthians