Re: Memory Management Question
Nick Keighley <firstname.lastname@example.org> wrote:
as others have stated modern OSs clean up on exit. This includes
Windows XP and anything that came after it, Linux and MacOS.
I don't know why, but I find the notion that an OS would not free the
resources reserved by a process so antiquated that it's almost amusing.
In most systems when you do a "new" (or "malloc()" or whatever), that's
*not* a system call (ie. a call to the operating system). It simply causes
the C runtime environment to allocate a block of memory from the heap.
The heap is something that's not managed by the code that the programmer
writes. It's managed by the C runtime environment (eg. in most unix systems
it would be the libc.so shared library). This runtime interacts with the
operating system, and it happens by the runtime, basically, saying to the
OS "hey, increase my heap by this much" (which is usually a bigger chunk
than what was requested by the code) when the runtime needs more heap.
When the program ends, the runtime usually just tells the OS "I don't
need this heap anymore". It doesn't matter whether the code has forgotten
some deletes or not. It all goes away when the program ends.
Even if the program is for some reason killed abruptly (eg. by sending
it SIGKILL), the OS will remove the process and take its heap back. Again,
whether the program code forgot some deletes is completely irrelevant.
That memory management is at a completely different level.
In short: The OS sees the memory taken by a process just one big chunk
of heap. The OS couldn't care less how the program uses that heap. If the
program internally "leaks" objects inside the heap, that's completely
inconsequential. When the program ends, it takes that heap back (if the
runtime didn't release it explicitly) and that's it.
The reason why leaks are bad is if they happen in a loop or slowly over
long periods of time. This will cause the runtime to request more and more
heap space from the OS, consuming physical RAM and eventually running out
There are other resources that are much closer to the notion that the
program requests the OS directly a resource and the OS has then to release
it if the program itself doesn't. These may include (depending on the OS)
things like file handles (although these are often also process-specific
and not systemwide) and sockets. Temporary files are an interesting case
as well (if the temp file was requested from the OS).