insanity is free()

Question

In my simple C program (gnu linux) I am getting the rss value from proc/stat.
int GetRSS() returns the RSS value from proc/stat for my process.

---

In this instance:

printf("A RSS=%i\n", GetRSS());
char *cStr = null;
cStr = malloc(999999);
if (cStr != NULL)
{
    printf("B RSS=%i\n", GetRSS());
    free(cStr);
    printf("C RSS=%i\n", GetRSS());
}

I get:

A RSS=980
B RSS=984
C RSS=980

I can't explain why C did not return 984.

---

If I run the same procedure twice I get:

A RSS=980
B RSS=984
C RSS=980
B RSS=984
C RSS=980

Looks fine.

---

But, in this instance:

struct _test
{
    char *pChar;
}
struct _test **test_ptr;

int i = 0;
printf("D RSS=%i\n",GetRSS());
assert(test_ptr = (struct _test **)malloc( (10000) * sizeof(struct _test *)));

for (i = 0; i < 1000; i++)
{
    assert(test_ptr[i] = (struct _test *)malloc(sizeof(struct _test)));
    test_ptr[i]->pChar=strdup("Some garbage");
}

printf("E RSS=%i\n", GetRSS());

for (i=0; i<1000; i++)
{
    free(test_ptr[i]->pChar);
    free(test_ptr[i]);
}

free(test_ptr);
printf("F RSS=%i\n", GetRSS());

I get:

D RSS=980
E RSS=1024
F RSS=1024
D RSS=1024
E RSS=1024
F RSS=1024

Huh? Why is the memory not freeing here?

Answer 1

The fact that a block of memory has been freed does not necessarily make that block the most eligible for a subsequent allocation. There are several strategies for a memory manager to select a block of memory (best fit, worst fit, first fit).

Most memory managers also attempt to coalesce free blocks, but some try to let the free blocks "age" as long as possible before coalescing, on the theory that as they age, there's a better chance that blocks next to them will also be freed, improving the success rate at coalescing blocks (thus reducing fragmentation).

The fact that the block wasn't used to satisfy your next allocation request does not mean it wasn't freed.

Answer 2

From the free() man page: "Occasionally, free can actually return memory to the operating system and make the process smaller. Usually, all it can do is allow a later call to malloc to reuse the space. In the meantime, the space remains in your program as part of a free-list used internally by malloc."