Jump to content
  • Advertisement
Sign in to follow this  
wolfscaptain

OpenGL Cleanup at end of program

This topic is 2246 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Does one need to clean up OpenGL resources when a program finishes?

I can't think of any not-annoying way to clean up global resources in an SFML project, since the window (and thus context) gets destroyed before my resources.

Do they leak to VRAM, or does the context take them with it?

Is there any decent design to delete global resources before a program ends (and before the window is closed)?

Thanks.

Share this post


Link to post
Share on other sites
Advertisement
To not 'clean up' after oneself is simply bad practice. Destructors are a very good way of dealing with such issues.

Personally, as a matter of course, for every byte allocated, I make sure there is an appropriate 'clean up' routine without exception. It's almost pathological - every time I new or malloc I create a delete/free. Edited by mark ds

Share this post


Link to post
Share on other sites
Like I wrote above, my resources get deleted (as in, the destructor is called) after the window is closed, so there is no context to delete them from.

Guess I'll just use heap memory (new) and delete them manually before the program ends.

Share this post


Link to post
Share on other sites
If you get to the point that the resources are released at the wrong time, then it's a question of design and not so much about how to nicely release them at the correct point.

For example, if you're using the destructor to automatically release the resource but the resources are released too late, then the scope of the object owning the resources is simply too wide. You say that your resources are global, and that is probably the reason: they are global and have the wides possible scope. If you define your resources in a narrower scope than the window, then you don't have this problem anymore (in reality it may not be as easy as just sticking the objects in a tighter scope though, you need to adapt the program to not use global resources anymore). Edited by Brother Bob

Share this post


Link to post
Share on other sites
The context will take everything with it when it's deleted. If you want to clean up before destroying the context then capture the close-window message and do your cleanup before actually destroying the window. I don't know how to do that in SFML but I'm sure there's some kind of event callback or something that you can register for to do things when the user tries to exit.

Share this post


Link to post
Share on other sites
its important to distinguish between ogl resources and other resources. ogl resources get freed automatically when your drawing context is deleted, that is when you call Window::close. You only want to delete them manually if you want to unload resources at runtime, and load something else, like streaming textures. if you have time for it then it is advisable to do manual deleting just for the sake of practicing.
other resources such as cpu side memory are usually freed by your os upon exit, but special oses may not. you still want to delete stuff here though to make sure youre not doing memory leaking.
Edit: the non-annoying way would be to encapsulate your objects in classes and make a on_delete function in each class. then when you react to the sf::Event::Close, just call the on_delete function of each object, then in the end call window.close(). you may want to employ some kind of global class that holds all these objects in some way, so that you can access your objects anywhere in your code. by making your global class lightweight and the actual objects heavyweight you can easily manage memory later (ie. the global object will live until your app is closed, everybody else dies as soon as they get deleted / get out of context). Edited by Yours3!f

Share this post


Link to post
Share on other sites
This is an issue of debate and I usually stay out of these, but in this case I have a strong opinion because I know that there is actually one side that is correct.

#1:
So firstly all your classes should know to delete whatever they allocate. Why would there be an exception to the rule?
If your texture class creates an OpenGL texture ID, it should also delete it. Simple logic. This should be in the destructor, though it could be in a general-purpose Reset() function that is also called by the destructor, meaning it is still a destructor function, but also could tailor to more areas of allocation.
Should your texture class destructor have some of knowledge as to why it is being destructed?
Obviously No. Not only does that never make sense, it just uses more code.

From there we can extrapolate.
#2:
Should a certain array of objects (etc.) be deleted when you shut down the game?
Well, according to #1, that doesn’t make sense.
Deleting all of your global objects (or whatever) cascades into deleting all of the OpenGL resources you have allocated, and some people seem to think that deleting these objects is not necessary at shut-down.
It is basically a fallacy in every sense of the word.
Yes, the memory will not be leaked because of the OS, but by the logic of #1 it should never have ended up in the hands of the OS. The basic principal behind #1 is that there are no special cases between what is created is deleted. Saying you will not delete something, OpenGL or otherwise, just because the game is shutting down, is a raw violation of pure and simple logic.

But there is more to it.
If your game is designed such that shutting down is not a special case, it can be assumed that anything reported as a leak is not just a shut-down leak but a run-time leak as well.
In other words, if shutting down produces a spam of error messages related to leaks, you are likely to just ignore them as just shut-down leaks even though some of them really are run-time leaks.


There is basically no excuse, for any reason, no exceptions, for leaking any form of memory.
Not only is it bad practice, but it also makes no sense what-so-ever and it ultimately just hinders your ability to track down actual run-time leaks.

Asking this question is basically like looking for an excuse to be lazy.
Products made by lazy people are garbage. Do you want to be lazy just because you can? This is how advocates of “just let the memory go” are.


L. Spiro

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!