Memory leak with detached pthreads - how to free?

Using detached POSIX threads I recognized that they leak memory. I've searched for a long time but most answers told me to use either pthread_join() or pthread_detach(). Of course I've tried both without success. Here's a sample code:

Code:

---

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

void *func(void *dat) {
        int i;
        //pthread_detach(pthread_self());
       
        char stack[4234234];

        char *heap;
        printf("Enter amount: ");
        scanf("%d", &i); __fpurge(stdin);
        heap = (char *)malloc(i*1024);
        memset(heap, 'a', i*1024);
       
        printf("Press enter to stop thread");
        getchar();
       
        //free(heap);
        pthread_exit(NULL);
}

int main(void) {
        int i;
        pthread_t t;

        printf("Press enter to start thread");
        getchar();

        pthread_create(&t, NULL, func, NULL);
        pthread_join(t, NULL);
       
        printf("Press enter to exit");
        getchar();

        return 0;
}

---

I am checking the memory usage with "ps -o pid,pcpu,vsz,rss,user -p <pid>". Here is the result:

Before the thread starts: VSZ=1492, RSS=400
Inside the thread with i=1,000,000: VSZ=1009824 RSS=1000512
After exiting the thread: VSZ=1009868 RSS=1000576

As you can see the memory usage even increases after terminating the thread. Using pthread_detach() instead gives me the same results. Is it somehow possible to free the entire memory used within the thread?

Thanks in advance!

> heap = (char *)malloc(i*1024);
There's no need to cast the result of malloc in C, see the FAQ.

> //free(heap);
You do need to call free, since you called malloc.

> Is it somehow possible to free the entire memory used within the thread?
Call free() on the memory you malloc().

What you're not aware of is that calling free() does NOT give the memory back to the OS but it is kept by the memory pool manager in the process. This is so if you call malloc again, the process can satisfy the request quickly rather than trapping into the OS (which is very slow by comparison).

Code:

---

for ( i = 0 ; i < 1000 ; i++ ) {
  char *p = malloc( 100000 );
  usleep( 100000 );
  free( p );
}

---

With the free(), you'll see an initial jump in things like VSZ and then it will settle down to a steady state. This is perfectly fine for normal operation.
Without the free(), you will see the size increase over time as more and more memory is allocated because of the leak.

Quote:

---

Originally Posted by Salem

What you're not aware of is that calling free() does NOT give the memory back to the OS but it is kept by the memory pool manager in the process. This is so if you call malloc again, the process can satisfy the request quickly rather than trapping into the OS (which is very slow by comparison).

---

Ah, that was the issue! Even with or without the free() call the memory was never fully released. Thanks for your answer!