Elusive JAVA memory leak
•
Java
I have a Java application based on lwjgl I render terrain with nine vertex buffers arranged in a 3 x 3 mesh When the camera moves over a boundary, the nine buffers are either updated or replaced with a new set of terrain All this is good, except that when a new terrain block adds a 9-element array, my memory increases by about 5MB This alone is expected Unexpectedly, the 5MB memory occupied by the previous terrain block has not been cleaned up
I'm exhausted from my Google, so I hope someone can give me some help I installed and ran visualvm What I don't understand is that windows uses 200MB to represent my application after loading and unloading a lot of terrain However, the visualvm heap dump only displays 12MB
The game loop used to load terrain does not run in an exact thread from "main" Who can point me in the right direction? I'll paste some code, but it's too big. I don't know which bit to paste
while(Game.running) {
time = Sys.getTime();
dt = (double)((time - lastTime))/1000.0;
lastTime = time;
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
input.pollInput(cam,dt);
cam.update(terrain.getTerrainHeight());
sun.render();
terrain.updateNew(cam.getPosition());
terrain.render();
frameRendering();
//testTriangle();
Display.update();
}
There is a main cycle The problem seems to be in terrain In the updatenew() function
This is:
public void updateNew(Vector3f playerPos)
{
_playerPos.x = playerPos.x;
_playerPos.y = playerPos.y;
_playerPos.z = playerPos.z;
int width = TerrainChunk.CHUNK_WIDTH;
_westernBounds = _chunks[4].getOrigin().x + 0;
_easternBounds = _chunks[4].getOrigin().x + width - 0;
_northernBounds = _chunks[4].getOrigin().z + 0;
_southernBounds = _chunks[4].getOrigin().z + width - 0;
if(_playerPos.x < _westernBounds && !_needUpdate)
{
_needUpdate = true;
_inWestBounds = true;
}
if(_playerPos.x > _easternBounds && !_needUpdate)
{
_needUpdate = true;
_inEastBounds = true;
}
if(_playerPos.z < _northernBounds && !_needUpdate)
{
_needUpdate = true;
_inNorthBounds = true;
}
if(_playerPos.z > _southernBounds && !_needUpdate)
{
_needUpdate = true;
_inSouthBounds = true;
}
if(_needUpdate)
{
long key = 0;
long key1 = 0;
long key2 = 0;
int[] coords = new int[2];
HashMap<Integer,Long> needed = new HashMap<Integer,Long>();
coords = calculateChunkCoords(0);
key1 = coords[0];
key2 = coords[1];
key = key1 << 32 | key2;
needed.put(0,key);
coords = calculateChunkCoords(1);
key1 = coords[0];
key2 = coords[1];
key = key1 << 32 | key2;
needed.put(1,key);
coords = calculateChunkCoords(2);
key1 = coords[0];
key2 = coords[1];
key = key1 << 32 | key2;
needed.put(2,key);
coords = calculateChunkCoords(3);
key1 = coords[0];
key2 = coords[1];
key = key1 << 32 | key2;
needed.put(3,key);
coords = calculateChunkCoords(4);
key1 = coords[0];
key2 = coords[1];
key = key1 << 32 | key2;
needed.put(4,key);
coords = calculateChunkCoords(5);
key1 = coords[0];
key2 = coords[1];
key = key1 << 32 | key2;
needed.put(5,key);
coords = calculateChunkCoords(6);
key1 = coords[0];
key2 = coords[1];
key = key1 << 32 | key2;
needed.put(6,key);
coords = calculateChunkCoords(7);
key1 = coords[0];
key2 = coords[1];
key = key1 << 32 | key2;
needed.put(7,key);
coords = calculateChunkCoords(8);
key1 = coords[0];
key2 = coords[1];
key = key1 << 32 | key2;
needed.put(8,key);
// copy the chunks we have into a searchable has map
HashMap<Long,TerrainChunk> have = new HashMap<Long,TerrainChunk>();
key1 = _chunks[0]._origin[0];
key2 = _chunks[0]._origin[1];
key = key1 << 32 | key2;
have.put(key,new TerrainChunk(_chunks[0],_chunks[0]._color));
key1 = _chunks[1]._origin[0];
key2 = _chunks[1]._origin[1];
key = key1 << 32 | key2;
have.put(key,new TerrainChunk(_chunks[1],_chunks[1]._color));
key1 = _chunks[2]._origin[0];
key2 = _chunks[2]._origin[1];
key = key1 << 32 | key2;
have.put(key,new TerrainChunk(_chunks[2],_chunks[2]._color));
key1 = _chunks[3]._origin[0];
key2 = _chunks[3]._origin[1];
key = key1 << 32 | key2;
have.put(key,new TerrainChunk(_chunks[3],_chunks[3]._color));
key1 = _chunks[4]._origin[0];
key2 = _chunks[4]._origin[1];
key = key1 << 32 | key2;
have.put(key,new TerrainChunk(_chunks[4],_chunks[4]._color));
key1 = _chunks[5]._origin[0];
key2 = _chunks[5]._origin[1];
key = key1 << 32 | key2;
have.put(key,new TerrainChunk(_chunks[5],_chunks[5]._color));
key1 = _chunks[6]._origin[0];
key2 = _chunks[6]._origin[1];
key = key1 << 32 | key2;
have.put(key,new TerrainChunk(_chunks[6],_chunks[6]._color));
key1 = _chunks[7]._origin[0];
key2 = _chunks[7]._origin[1];
key = key1 << 32 | key2;
have.put(key,new TerrainChunk(_chunks[7],_chunks[7]._color));
key1 = _chunks[8]._origin[0];
key2 = _chunks[8]._origin[1];
key = key1 << 32 | key2;
have.put(key,new TerrainChunk(_chunks[8],_chunks[8]._color));
Set<Entry<Integer,Long>> set = needed.entrySet();
Iterator<Entry<Integer,Long>> i = set.iterator();
// Garbage cleanup?
while(i.hasNext())
{
Map.Entry<Integer,Long> me = i.next();
if(have.containsKey(me.getValue()))
{
_chunks[me.getKey()] = null;
_chunks[me.getKey()] = new TerrainChunk(have.get(me.getValue()),getColor(me.getKey()));
} else {
_chunks[me.getKey()].destroy();
_chunks[me.getKey()] = null;
_chunks[me.getKey()] = new TerrainChunk(calculateChunkCoords(me.getKey()),getColor(me.getKey()),this);
}
}
_needUpdate = false;
have.clear();
needed.clear();
have = null;
needed = null;
}
}
This is the function that creates the vertex buffer:
private boolean createVertexBuffer()
{
_vboVertexAttribues = ARBVertexBufferObject.glGenBuffersARB();
_vboVertexIndices = ARBVertexBufferObject.glGenBuffersARB();
//_vboVertexTexture = ARBVertexBufferObject.glGenBuffersARB();
ARBVertexBufferObject.glBindBufferARB(
ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,_vboVertexAttribues
);
ARBVertexBufferObject.glBufferDataARB(
ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,(VERTEX_SIZE * VERTEX_COUNT),ARBVertexBufferObject.GL_STATIC_DRAW_ARB
);
ByteBuffer vertextPositionAttributes = ARBVertexBufferObject.glMapBufferARB(
ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,ARBVertexBufferObject.GL_WRITE_ONLY_ARB,null
);
for(int i = 0; i < VERTEX_COUNT; i++)
{
vertextPositionAttributes.putDouble(_vPos[i].x);
vertextPositionAttributes.putDouble(_vPos[i].y);
vertextPositionAttributes.putDouble(_vPos[i].z);
vertextPositionAttributes.putDouble(_vNorm[i].x);
vertextPositionAttributes.putDouble(_vNorm[i].y);
vertextPositionAttributes.putDouble(_vNorm[i].z);
vertextPositionAttributes.putFloat(_color.x);
vertextPositionAttributes.putFloat(_color.y);
vertextPositionAttributes.putFloat(_color.z);
vertextPositionAttributes.putFloat(1.0f);
}
vertextPositionAttributes.flip();
ARBVertexBufferObject.glUnmapBufferARB(ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB);
ARBVertexBufferObject.glBindBufferARB(ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,0);
vertextPositionAttributes.clear();
vertextPositionAttributes = null;
// TEXTURE COORDS
/*ARBVertexBufferObject.glBindBufferARB(
ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,_vboVertexTexture
);
ARBVertexBufferObject.glBufferDataARB(
ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,(TEXTURE_SIZE * VERTEX_COUNT),ARBVertexBufferObject.GL_STATIC_DRAW_ARB
);
ByteBuffer vertexTextureCoords = ARBVertexBufferObject.glMapBufferARB(
ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,null
);
for(int i = 0; i < VERTEX_COUNT; i++)
{
vertexTextureCoords.putFloat(_vTex[i].x);
vertexTextureCoords.putFloat(_vTex[i].y);
}
vertexTextureCoords.flip();
ARBVertexBufferObject.glUnmapBufferARB(ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB);
ARBVertexBufferObject.glBindBufferARB(ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,0);*/
ARBVertexBufferObject.glBindBufferARB(
ARBVertexBufferObject.GL_ELEMENT_ARRAY_BUFFER_ARB,_vboVertexIndices
);
ARBVertexBufferObject.glBufferDataARB(
ARBVertexBufferObject.GL_ELEMENT_ARRAY_BUFFER_ARB,(INDEX_SIZE * INDEX_COUNT),ARBVertexBufferObject.GL_STATIC_DRAW_ARB
);
ByteBuffer vertexIndices = ARBVertexBufferObject.glMapBufferARB(
ARBVertexBufferObject.GL_ELEMENT_ARRAY_BUFFER_ARB,null
);
for(int i = 0; i < _nIndices.length; i++)
{
vertexIndices.putInt(_nIndices[i]);
}
vertexIndices.flip();
ARBVertexBufferObject.glUnmapBufferARB(ARBVertexBufferObject.GL_ELEMENT_ARRAY_BUFFER_ARB);
ARBVertexBufferObject.glBindBufferARB(ARBVertexBufferObject.GL_ELEMENT_ARRAY_BUFFER_ARB,0);
// Cleanup our crap
_fXs = null;
_fYs = null;
_fZs = null;
_vPos = null;
_vNorm = null;
_color = null;
_nIndices = null;
_vTex = null;
vertexIndices.clear();
vertexIndices = null;
return true;
}
This is the rendering function: public void render(){
GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
GL11.glEnableClientState(GL11.GL_NORMAL_ARRAY);
GL11.glEnableClientState(GL11.GL_COLOR_ARRAY);
ARBVertexBufferObject.glBindBufferARB(
ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,_vboVertexAttribues
);
ARBVertexBufferObject.glBindBufferARB(
ARBVertexBufferObject.GL_ELEMENT_ARRAY_BUFFER_ARB,_vboVertexIndices
);
GL11.glVertexPointer(
3,GL11.GL_DOUBLE,VERTEX_SIZE,0
);
GL11.glNormalPointer(
GL11.GL_DOUBLE,NORMAL_SIZE
);
GL11.glColorPointer(
4,GL11.GL_FLOAT,POSITION_SIZE + NORMAL_SIZE
);
GL11.glDrawElements(
GL11.GL_TRIANGLE_STRIP,INDEX_COUNT,GL11.GL_UNSIGNED_INT,0
);
ARBVertexBufferObject.glBindBufferARB(
ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,0
);
ARBVertexBufferObject.glBindBufferARB(
ARBVertexBufferObject.GL_ELEMENT_ARRAY_BUFFER_ARB,0
);
GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY);
GL11.glDisableClientState(GL11.GL_NORMAL_ARRAY);
GL11.glDisableClientState(GL11.GL_COLOR_ARRAY);
}
Thank you for any help or advice
Solution
I think it may be an artifact of how the Java VM allocates memory from the operating system. In particular, even if the heap is reduced, it will not release pages, but it has to grow again to keep the heap
But in terms of memory leaks in code, what matters is what visualvm calls heap size If that's stable, there's no leakage
You should also consider that the Java VM itself uses a large number of native libraries and other things that consume physical or virtual memory, which provides approximately constant overhead for each java process
(this may also help.)
The content of this article comes from the network collection of netizens. It is used as a learning reference. The copyright belongs to the original author.
THE END
二维码