Cleanup at end of program
Members - Reputation: 200
Posted 22 July 2012 - 04:40 PM
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)?
Members - Reputation: 241
Posted 22 July 2012 - 06:10 PM
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, 22 July 2012 - 06:14 PM.
Members - Reputation: 200
Posted 23 July 2012 - 05:00 AM
Guess I'll just use heap memory (new) and delete them manually before the program ends.
Moderators - Reputation: 4654
Posted 23 July 2012 - 07:00 AM
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, 23 July 2012 - 07:01 AM.
Members - Reputation: 1988
Posted 23 July 2012 - 07:02 AM
Members - Reputation: 547
Posted 24 July 2012 - 10:30 AM
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, 24 July 2012 - 10:44 AM.
Crossbones+ - Reputation: 5186
Posted 25 July 2012 - 08:36 AM
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.
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.
I spent most of my life learning the courage it takes to go out and get what I want. Now that I have it, I am not sure exactly what it is that I want. - L. Spiro 2013
L. Spiro Engine: http://lspiroengine.com
L. Spiro Engine Forums: http://lspiroengine.com/forums