为什么程序分配的内存不会减少？

Question

There is a rule telling that local variables are deleted after end of calling function.

I tried to call the function (in C++)

void DoIt()
{   
    double x[100000];
}

and investigated that at the moment when creating array x memory allocated by program increases by some KBytes . However after end of calling function that memory does not decrease. Also function delete gives runtime error.

So, why memory allocated by program doesn't decrease after the end calling function? Is there any way to delete local variable like above?

Answer 1

It is surprising that you see memory usage going up, since you do not initialize (or touch) the array. On the other hand, it is not surprising at all that you do not see memory usage going down in Task Manager afterwards. That's nothing to worry about, though.

Why is that so?

When you declare an array like this, it has automatic storage duration. This means that space on the stack is allocated for it (formally, the C++ language knows of no such thing as a "stack", but this is how all implementations -- at least all implementations I ever heard of -- work like).

Allocating space on the stack is simply a pointer decrement by some value. As long as you do not try to read or write to the memory pointed to, you can pretty much do anything to a pointer without anything happening (well, of course something happens, but not something spectacular).

On a low level, memory is managed in pages (usually 4 kilobytes) which map a range of virtual addresses with some access rights to physical RAM in some opaque way. The operating system makes sure that you never get to know that. Now, operating systems deliberately set the page following the stack's last page to having an invalid access mode, so whenever you try to read or write a value from that page, a fault is generated ¹ . When that happens, the OS checks whether the stack's maximum size has been exceeded (in which case your program is terminated). If that isn't the case, the OS commits a new page, adding it to your working set and lets your program continue.

The advantage of that is that you can have very large numbers of threads and very large theoretical stack sizes for each individual thread, but you only pay for what you use.

Now, what happens when you allocate an array of a hundred thousand double s is simply that the stack pointer is moved down by a value of 800,000 bytes (assuming the "usual" size of 8 bytes for a double ). If you initialize the array as well or if you touch any other variable that you declare after this array, said page fault will occur, the OS will be kicked off and will allocate the stack space. Process Explorer will show it.

Once committed, it doesn't go away any more ² , and Task Manager will keep showing it. However, as soon as the function returns, the stack pointer pops back to where it was before, so you recycle that memory.

Do note that the stack can generally not grow indefinitely (often, it is by default limited to a megabyte or so). Therefore, allocating such huge arrays with static storage duration is generally not a good idea.

---

¹ Under Windows, there is a special term for this: guard page
² In principle, it could , but there is no easy way for the OS to tell when it's safe to throw away the pages without requiring the compiler to insert extra syscalls, and simply keeping the pages around and swapping them out in the worst case works fine and is a lot easier.

Answer 2

Definitely use new and delete for any significant amount of memory allocation; let's say for anything over 1Kb or anything that could use more than 1Kb of memory -- if this is going into a class, you probably need to run with a local static variable to count the number of instances (int my_class::static_variable;) and give each instance of the class a unique id and a memory allocation flag so that you can track who gets memory allocated, who doesn't and who's memory gets deallocated -- then you will observe the expected increases and decreases in memory consumption in Task Manager; I digress. Nothing to do with disk drive Virtual Memory allocations.

Overall, using a staticly sized array like that is pretty irresponsible, when it comes to memory management, even if it is guaranteed that there won't be a memory leak, per se, simply because in all likelihood you won't need all of the memory allocated en bloc immediately, unless you are diving into a loop that iterates through every entry in the array.