'calloc' does not automatically consumes memory out of RAM

Question

According to the answer to this question:

Difference between malloc and calloc?

Isak Savo explains that:

calloc does indeed touch the memory (it writes zeroes on it) and thus you'll be sure the OS is backing the allocation with actual RAM (or swap). This is also why it is slower than malloc (not only does it have to zero it, the OS must also find a suitable memory area by possibly swapping out other processes)

So, I decided to try it myself:

#include <stdlib.h>
#include <stdio.h>

#define ONE_MB = 1048576

int main() {
    int *p = calloc(ONE_MB, sizeof(int));

    int n;
    for(n = 0; n != EOF; n = getchar()) ; /* Gives me time to inspect the process */

    free(p);
    return 0;
}

After executing this application, Windows's Task Manager would tell me that only 352 KB were being used out of RAM.

It appears that the 1MB block I allocated is not being backed with RAM by the OS.

---

On the other hand, however, if I would call malloc and initialize the array manually:

#include <stdlib.h>
#include <stdio.h>

#define ONE_MB = 1048576

int main() {
    int *p = malloc(sizeof(int) * ONE_MB);

    int n;

    /* Manual Initialization */
    for(n = 0; n < ONE_MB; n++)
        memory[n] = n;

    for(n = 0; n != EOF; n = getchar()) ; /* Gives me time to inspect the process */

    free(p);
    return 0;
}

Task Manager would show me that there is actually 4.452KB of RAM being used by the application.

---

Was Isak incorrect about his argument? If so, what does calloc do then? Doesn't it zero the whole memory block, and therefore "touches" it, just as I did?

If that's the case, why isn't RAM being used in the first sample?

Answer 1

He was wrong in the point, that it is much slower because of it has to write 0 in the block first.

Any smart coded OS prepares such blocks for such purposes (where calloc() isn't the only case such blocks are used for) and if you call calloc() it just assigns such a block of zeroed memory to your process instead of a uninitialized one as it >could< do by calling malloc().

So it handles such blocks of memory the same way. and if the compiler/OS decides you don't ever/yet need the full 1MB it also dont' gives you a full 1MB block of the zeroed memory.

In How far he was right: If you heavily call calloc() and also use the memory, the OS could go out of zeroed memory which was probably prepared in some idle time.

This would be causing indeed the system to get a bit slower, as than the os is forced by a call to calloc() to write 0's in the block first.

But at all: There is no regulation about whether malloc/calloc have to allocate the memory on the call or just as you are using the memory. So your special example depends on the OS treatment.