What verion of the OS are you using. With 6.3.2 the heap can only grow it never shrinks.  On 6.4.X the heap can shrink 
and the memory is return to the OS.  Check the documentation.

-----Original Message-----
From: kuldeep paranjpe [mailto:community-noreply@qnx.com] 
Sent: Wednesday, July 15, 2009 8:45 AM
To: ostech-core_os
Subject: Memory release issue after pthread_detach and pthread_cancel

Hi,

I am trying to create a thread in 'main' process. This thread allocates about 100K memory, sleeps for few seconds and 
then releases the memory. 3 such threads are created by the parent process.
After creating each thread parent process sleeps for some time and calls pthread_detach() and pthread_cancel() on 
particular 'tid'.
When I do 'pidin m' for that process, I could see the memory of parent process goes on increasing. with each thread 
create the parent process starts with new memory offset(actual + allocated). i.e when thread finishes it does not 
liberate the complete memory and parent process does not return to it's original value

The logs says that;
parent process starts with about 36K, and after finishing all the threads it ends up acquiring 456K.

pthread_detach() synopsis says '"When a detached thread terminates, all system resources allocated to that thread are 
immediately reclaimed."

OS should destroy all the thread stack once its function is done and is cancelled(also pidin dosen't show that thread).

from where this memory is getting accumulated in parent process? OR is there any other way to clean up the thread stack?
??

Here is the sample program;

#include <cstdlib>
#include <iostream>
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/resource.h>

static void* cliente(void *datos)
{
	while(true)
	{
		//Allocating dummy memory of about 100K
		char *buff= new char[100000];
		sleep(20);
		//releasing memory
		delete [] buff;
		buff=NULL;
	}
}

int main()
{
    int ret1;
    ret1=0;
    pthread_t mythread[4];

   while(ret1 < 3)
   {
	   //create thread
	   if(!pthread_create((pthread_t *)&mythread[ret1],NULL,cliente,NULL))
	   {
	   	perror("pthread_create");
	   }
	   //dummy sleep
	   sleep(60);
	    //detach the thread
	   int ret = pthread_detach((pthread_t)mythread[ret1]);
	    if(EOK == ret)
	    {
	    	printf("Thread %d got detached\n",mythread[ret1]);
	    	fflush(stdout);
	    }
	    //cancel the thread
	    int iRet = pthread_cancel((pthread_t)mythread[ret1]);  
	    if(EOK == iRet)
	    {
	    	printf("Thread %d got cancelled\n",mythread[ret1]);
	    	fflush(stdout);
	    }   
	    mythread[ret1] = NULL;
	    ret1++;
   }
   while(true)
   {
   }          
return EXIT_SUCCESS;
}






_______________________________________________
OSTech
http://community.qnx.com/sf/go/post33805

"System resources" that suppose to be deallocated does not include heap 
memory since memory heap is managed separately.
If objects are properly deleted heap memory can be reclaimed for re-use. 
Total heap may not shrink though especially if it is heavily fragmented 
(and depends on OS version).

kuldeep paranjpe wrote:
> Hi,
>
> I am trying to create a thread in 'main' process. This thread allocates about 100K memory, sleeps for few seconds and 
then releases the memory. 3 such threads are created by the parent process.
> After creating each thread parent process sleeps for some time and calls pthread_detach() and pthread_cancel() on 
particular 'tid'.
> When I do 'pidin m' for that process, I could see the memory of parent process goes on increasing. with each thread 
create the parent process starts with new memory offset(actual + allocated). i.e when thread finishes it does not 
liberate the complete memory and parent process does not return to it's original value
>
> The logs says that;
> parent process starts with about 36K, and after finishing all the threads it ends up acquiring 456K.
>
> pthread_detach() synopsis says '"When a detached thread terminates, all system resources allocated to that thread are 
immediately reclaimed."
>
> OS should destroy all the thread stack once its function is done and is cancelled(also pidin dosen't show that thread)
.
>
> from where this memory is getting accumulated in parent process? OR is there any other way to clean up the thread 
stack???
>
> Here is the sample program;
>
> #include <cstdlib>
> #include <iostream>
> #include <stdio.h>
> #include <pthread.h>
> #include <errno.h>
> #include <unistd.h>
> #include <stdlib.h>
> #include <sys/resource.h>
>
> static void* cliente(void *datos)
> {
> 	while(true)
> 	{
> 		//Allocating dummy memory of about 100K
> 		char *buff= new char[100000];
> 		sleep(20);
> 		//releasing memory
> 		delete [] buff;
> 		buff=NULL;
> 	}
> }
>
> int main()
> {
>     int ret1;
>     ret1=0;
>     pthread_t mythread[4];
>
>    while(ret1 < 3)
>    {
> 	   //create thread
> 	   if(!pthread_create((pthread_t *)&mythread[ret1],NULL,cliente,NULL))
> 	   {
> 	   	perror("pthread_create");
> 	   }
> 	   //dummy sleep
> 	   sleep(60);
> 	    //detach the thread
> 	   int ret = pthread_detach((pthread_t)mythread[ret1]);
> 	    if(EOK == ret)
> 	    {
> 	    	printf("Thread %d got detached\n",mythread[ret1]);
> 	    	fflush(stdout);
> 	    }
> 	    //cancel the thread
> 	    int iRet = pthread_cancel((pthread_t)mythread[ret1]);  
> 	    if(EOK == iRet)
> 	    {
> 	    	printf("Thread %d got cancelled\n",mythread[ret1]);
> 	    	fflush(stdout);
> 	    }   
> 	    mythread[ret1] = NULL;
> 	    ret1++;
>    }
>    while(true)
>    {
>    }          
> return EXIT_SUCCESS;
> }
>
>
>
>
>
>
> _______________________________________________
> OSTech
> http://community.qnx.com/sf/go/post33805
>   

The memory allocation has changed a little from 6.3.2 to 6.4.x. 

But specifically what you are trying to do, can be achieved, I think,
in 6.3.2 by just using some environment variables. 

specifically you can use 

MALLOC_MEMORY_HOLD=0 
(this doesnt hold on to memory in the heap, when blocks are freed and
"can" be released to the system using an underlying munmap call)

or more individually

MALLOC_ARENA_CACHE_MAXBLK=0
MALLOC_ARENA_CACHE_MAXSZ=0

which reduces the size of cached memory blocks inside the heap when
memory is free-ed.

both 6.3.2 and 6.4.x do shrink the heap, but the settings like these
variables control what is freed and when.

in 6.3.2 by default the MAXBLK = 8, so we will cached "8" arena blocks
(this would be 8 blocks of memory that we went to the system with mmap
for).

the size allows you to configure the total size of the
malloc_arena_cache to the specified total size.

let me know if this works for you.

shiv

On Wed, 2009-07-15 at 08:45 -0400, kuldeep paranjpe wrote:
> Hi,
> 
> I am trying to create a thread in 'main' process. This thread
> allocates about 100K memory, sleeps for few seconds and then releases
> the memory. 3 such threads are created by the parent process.
> After creating each thread parent process sleeps for some time and
> calls pthread_detach() and pthread_cancel() on particular 'tid'.
> When I do 'pidin m' for that process, I could see the memory of parent
> process goes on increasing. with each thread create the parent process
> starts with new memory offset(actual + allocated). i.e when thread
> finishes it does not liberate the complete memory and parent process
> does not return to it's original value
> 
> The logs says that;
> parent process starts with about 36K, and after finishing all the
> threads it ends up acquiring 456K.
> 
> pthread_detach() synopsis says '"When a detached thread terminates,
> all system resources allocated to that thread are immediately
> reclaimed."
> 
> OS should destroy all the thread stack once its function is done and
> is cancelled(also pidin dosen't show that thread).
> 
> from where this memory is getting accumulated in parent process? OR is
> there any other way to clean up the thread stack???
> 
> Here is the sample program;
> 
> #include <cstdlib>
> #include <iostream>
> #include <stdio.h>
> #include <pthread.h>
> #include <errno.h>
> #include <unistd.h>
> #include <stdlib.h>
> #include <sys/resource.h>
> 
> static void* cliente(void *datos)
> {
>         while(true)
>         {
>                 //Allocating dummy memory of about 100K
>                 char *buff= new char[100000];
>                 sleep(20);
>                 //releasing memory
>                 delete [] buff;
>                 buff=NULL;
>         }
> }
> 
> int main()
> {
>     int ret1;
>     ret1=0;
>     pthread_t mythread[4];
> 
>    while(ret1 < 3)
>    {
>            //create thread
>            if(!pthread_create((pthread_t
> *)&mythread[ret1],NULL,cliente,NULL))
>            {
>                 perror("pthread_create");
>            }
>            //dummy sleep
>            sleep(60);
>             //detach the thread
>            int ret = pthread_detach((pthread_t)mythread[ret1]);
>             if(EOK == ret)
>             {
>                 printf("Thread %d got detached\n",mythread[ret1]);
>                 fflush(stdout);
>             }
>             //cancel the thread
>             int iRet = pthread_cancel((pthread_t)mythread[ret1]); 
>             if(EOK == iRet)
>             {
>                 printf("Thread %d got cancelled\n",mythread[ret1]);
>     ...