Unused tile geometry isn't deleted which leads to VRAM issues

[levndev]

In the tile reader there is a map that keeps tiles alive to reuse their geometry, saving VRAM, but because of the ref_ptr those tiles are never deleted which overtime leads to VRAM filling completely in certain conditions, for example when an elevation layer is used.

So far changing

mutable std::map<dvec4, ref_ptr<VertexIndexDraw>> _geometryMap;

to

mutable std::map<dvec4, observer_ptr<VertexIndexDraw>> _geometryMap;

and adding a check for null in tile::createECEFTile:

    // check if reusable geometry exists already
    {
        std::scoped_lock<std::mutex> lock(_geometryMapMutex);
        if (auto itr = _geometryMap.find(geometryKey); itr != _geometryMap.end())
        {
            if (itr->second)
                vid = itr->second;
        }
    };

seemingly solves the problem with no observable side effects.

[robertosfield]

Could you provide a camera animation path that recreates the memory growth? I'd like to reproduce the problem.

In the case of stale geometries, one would should aim to reuse and for cases where use of tile geometry that has is no longer being rendered should be only be disposed off if memory is short, not in all cases like your changes would introduce.

[AnyOldName3]

Whether it uses a ref_ptr or observer_ptr, something will need to periodically scan the geometry map to remove orphaned items, otherwise it'll just fill up with junk. An observer_ptr won't remove itself from the map when the object it observes is deleted. If it uses ref_ptr, it can remove anything with a reference count of one, and if it uses observer_ptr, it can remove anything that's null when locked.

[levndev]

The problem only becomes noticeable when using an elevation layer because that increases the amount of vertices in each tile, in my case one tile becomes 256x256 vertices and that fills the video memory up a lot when moving around.

I don't really have time to figure out a camera path right now, so my way to reproduce this is to either connect an elevation layer or manually increase tile vertex resolution and then just crawl along the ground.

I do agree that my solution might not be good for everyone but with this thread I mostly just wanted to inform @robertosfield of the existence of the problem, in my case the fix is already in our company's clone of the repo and it works for now, which is why I didn't create a PR, just an issue.

As for the dangling observers, of course they need to be cleaned up but when compared to entire VertexIndexDraws being kept around forever the memory footprint is much smaller.