How to properly manage memory in SDL2?

Question

I have yet another question regarding SDL2.

I have some drawSprite & drawBackround & drawText functions, all draw to the screen. They do this by creating a new surface, turning it into a new texture, rendering the texture, then destroying/freeing everything.

This worked fine until I wanted to put it in a very fast loop. There was a slight delay (or something) which caused images on the screen to flicker. (It would draw a background, draw sprites, draw text, then loop. So this caused the sprites to flicker.)

I looked up the issue, and found that you shouldn't create and destroy a texture every single frame, AKA allocate and deallocate memory every single frame. So, I created some a global texture and surface variables, with the intent to re-assign these variables every time I called any of the drawing functions, and then destroy them when the program closed. (Reduce, Reuse, Recycle!)

This did not work. My memory required by my program ballooned upward into the gigabytes, which made it totally unresponsive. Through some trial and error, I found that I STILL had to run DestroyTexture and FreeSurface functions at the end of each drawing function. I don't understand why this is, since I'm reusing the variables.

Anyways, once I added those back in I've found that my program is working but is MUCH SLOWER in rendering than before!!! Why is this??? What did I do wrong? (again)

Answer 1

Your drawSprite and drawBackground functions definitely shouldn't be allocating any memory. What are you doing inside them that requires you to allocate memory?

Anyways, I'll start by explaining how manual memory management works. The functionality behind SDL_CreateTexture & SDL_DestroyTexture is very similar to how new and delete work in C++.

Let's do an example:

SDL_Texture* texture = SDL_CreateTexture(...);

Here we create a texture. One texture exists in our program.

SDL_DestroyTexture(texture);

Here we destroy the created texture. No textures exist anymore.
Now let's change things up a little:

texture = SDL_CreateTexture(...);
texture = SDL_CreateTexture(...);

Here we create two textures, so two textures exist in total. But now, if we call SDL_DestroyTexture, we will only delete the latter created texture, since that's what texture points to! There's also no way to access the result of the first SDL_CreateTexture call, so we have a memory leak. A general rule is that there has to be a matching SDL_DestroyTexture call for each SDL_CreateTexture.

Now, text rendering is a little more tricky. Textures required for text rendering are something that change relatively often, and do indeed need to be created as they are rendered. However, there's no need to do this every frame, since it's not likely that you're rendering text for just a single frame.

I personally use an LRU cache for text rendering in SDL. Essentially, in your text rendering function, you check if there exists an item with the same color, text and size in the cache, and if it does, you just fetch the cache item, and blit the texture inside it to the screen. If there isn't a cache item for the text, you create one by using the correct TTF_* calls. That way if you render the same text next frame, there already exists a texture to be used for the rendering. We use an LRU cache with a fixed size so that we don't end up leaking memory. I think I keep 200 cache items around at once in my game.

As a last note, globals are definitely not the way to go. I'm unsure about why you are allocating stuff inside the very basic sprite and background rendering functions, since you should probably just preload the textures you need to the objects that use them at start up.

struct Sprite
{
    float X, Y;
    SDL_Texture* texture;

    ~Sprite() { SDL_DestroyTexture(texture); }
};

Sprite player { 0.0f, 0.0f, SDL_CreateTexture(...) };

while (runGame)
{
    handleEvents();
    updateStuff();

    render(player);
}

Essentially something like this for sprites.