Re: [PyOpenGL-Users] glInterleavedArrays memory leak

[Rene D. <il...@ya...>]

Micah Dowty wrote:

>Hi Everybody,
>
>I believe I found a memory leak in PyOpenGL's wrapper for
>glInterleavedArrays. The following is the simplest test case I could
>come up with:
>
>------8<------
>import pygame, time
>from pygame.locals import *
>from OpenGL.GL import *
>pygame.init()
>pygame.display.set_mode((640,480), OPENGL|DOUBLEBUF)
>while 1:
>    glInterleavedArrays(GL_T2F_N3F_V3F, 0, " " * 10000)
>    time.sleep(0.01)
>------>8------
>	
>In 'top' this should show the python process' memory usage steadily
>rising. This is from a Gentoo Linux system on an Athlon XP.
>I have tested it with PyOpenGL 2.0.0.42 and 2.0.1.04, both show the bug.
>
>As much as I'm interested in helping squash this bug, I'm also
>interested in finding a workaround so my users (when they exist :) won't
>absolutely have to have the latest PyOpenGL code.
>
>I have tried using glVertexPointer and friends, however
>glTexCoordPointerf() would always cause an "OpenGL.GL.GLerror: [Errno
>1281] invalid value" exception.
>
>I'd like to thank the PyOpenGL developers for bringing such a neat
>interface to life. I have been using it for a 3D frontend to PyBZFlag
>with amazing results. Most people think Python is too slow for games,
>then they see what can be accomplished with outstanding modules like
>PyOpenGL and Numeric :)
>
>In case you're curious, I have a few screenshots of what we've done so
>far: (Yep, there's a realtime cloth simulation in there too)
>   http://navi.picogui.org/images/bzflag/
>The code is in BZFlag's CVS repository.
>
>--Micah
>
>  
>
Very nice on the bzFlag front!

The memory leak is there.  It leaks with numeric arrays as well.

#--------------------------------------------------------------------------------------------
import pygame, time
from pygame.locals import *
from OpenGL.GL import *
import Numeric
try:
    from numeric_gl import *
except:
    print "numeric_gl import failed"

pygame.init()
pygame.display.set_mode((640,480), OPENGL|DOUBLEBUF)
while 1:
    b = [ 0.0, 0.0, 0.0,
          1.0, 0.0, 0.0,
          1.0, 1.0, 0.0,
          0.0, 1.0, 0.0 ] * (10000 / 12)

    glInterleavedArrays( GL_V3F, 0, b)

    time.sleep(0.01)
    pygame.display.flip()
#--------------------------------------------------------------------------------------------
 

It's related to the way that array related functions in pyopengl are 
used.  I've been thinking of redoing them for a while but haven't had 
time :(

I've made a seperate numeric module with the gl*Pointer functions.  I 
just added a glInterleavedArrays which doesn't seem to have a memory leak.

Could you give it a go and tell me what you think?


It can be found here:
http://py3d.org/files/numeric_gl.tar.gz

It only works with numeric arrays(ie strings etc will probably not work).

It's only tested/compiled on debian linux.  I ran the OpenglContext test 
which used numeric arrays and it ran ok once I removed the tostring() calls.


I will eventually add this into pyopengl I think.  That is a seperate 
sub module for numeric stuff.  Which would be automatically detected and 
included into OpenGL.GL using python.

Along with some PyArray_ContiguousFromObject type function calls to 
allow you to check if memory is being copied unnecessarily(or did you 
allready add something like this Mike?).


Have fun!