Неуловимая утечка памяти Java

Question

У меня есть Java-приложение, основанное на LWJGL. Я рендеринг рельефа через 9 буферов вершин, расположенных в сетке 3 х 3. Когда камера перемещается за определенную границу, 9 буферов либо обновляются, либо заменяются новым набором ландшафтов. Все это прекрасно работает, за исключением того, что, когда новый блок ландшафта добавлен массив из 9 элементов, я получаю увеличение памяти примерно на 5 МБ. Это одно ожидается. Чего не ожидается, так это того, что 5 МБ памяти, которую занимал предыдущий кусок ландшафта, не очищаются.

Я исчерпал свое Google-фу, поэтому я надеюсь, что кто-то может мне помочь. У меня установлена ​​и работает VisualVM. Что я не понимаю, так это то, что Windows показывает мое приложение, используя, скажем, 200 МБ после большой загрузки и выгрузки ландшафта. Но дамп кучи VisualVM показывает только 12 МБ.

Игровой цикл для загрузки ландшафта не работает в отдельном потоке от "основного". Может кто-то указать мне верное направление? Я вставил бы некоторый код, но он настолько большой, что я не уверен, какой бит вставить.

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();
    }

Есть основной цикл. Кажется, проблема возникает в функции terrain.updateNew ().

Что здесь:

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;
    }
}

Вот функция, которая создает буферы вершин:

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, 
            (VERTEX_SIZE * VERTEX_COUNT),
            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,
            ARBVertexBufferObject.GL_WRITE_ONLY_ARB,
            (TEXTURE_SIZE * VERTEX_COUNT),
            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,
            ARBVertexBufferObject.GL_WRITE_ONLY_ARB,
            (INDEX_SIZE * INDEX_COUNT),
            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;
}

А вот и функция рендеринга: 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,
            VERTEX_SIZE,
            NORMAL_SIZE
    );

    GL11.glColorPointer(
            4, 
            GL11.GL_FLOAT, 
            VERTEX_SIZE, 
            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);
}

Заранее спасибо за любую помощь или совет.

Answer 1

Я думаю, что это может быть артефактом того, как виртуальные машины Java выделяют память из ОС, особенно их тенденция не выпускать страницы, даже если куча сокращается, а сохранять ее на случай, если куча снова увеличится.

Но что касается утечки памяти в вашем коде, все, что имеет значение, это то, что VisualVM говорит о размере вашей кучи. Если это стабильно, там нет утечки.

Следует также учитывать, что сама виртуальная машина Java использует много собственных библиотек и других вещей, которые потребляют физическую или виртуальную память, что дает примерно постоянные издержки для каждого процесса Java.

( Это тоже может помочь.)

Answer 2

Утечки могут происходить внутри базовых собственных библиотек. Кажется, что LWJGL привязан к собственным библиотекам C (OpenGL, OpenAL и т. Д.), И я подозреваю, что для отображения используются временные буферы памяти, которые никогда не освобождаются. Это объяснит, почему VisualVM показывает только 12 МБ (объекты, о которых он заботится), а Windows показывает 200 МБ (данные, созданные как JVM, по-прежнему внутри GC, так и данные, используемые в библиотеках C).

Вы уверены, что правильно используете Framework?

РЕДАКТИРОВАТЬ:

Я могу ошибаться, потому что я не знаком с этой конкретной библиотекой, но действительно вы используете собственную библиотеку для выделения памяти \ операций .

Кажется, у тебя все хорошо, но я заметил

ARBBufferObject.glGenBuffersARB

, который выделяет ваш буфер. Этот метод переносит нативный C * , так что пока вы не вызовете

ARBBufferObject.glDeleteBuffersARB

или прекращение этого буфера будет сохраняться в памяти. Вы должны определить жизненный цикл данных, созданных с помощью createVertexBuffer(), сколько раз вы их вызываете, и удалить буферы, когда ни вы, ни графический процессор не закончили с этим.

Опять же, я не знаю эту сторону OpenGl, поэтому кто-то, кто может, с большей вероятностью поможет вам. Вы замечаете, что API ARBBufferObject совпадает с тем, который обсуждался в C ++ Wiki

Answer 3

Ответ прост: буфер, в который вы помещаете вершины в "vertextPositionAttributes", скорее всего, является прямым буфером, что означает, что он существует из управляемой кучи GC и невидим для JVisualVM.