Memory increase problem on Solaris

Question

We need your help in understanding and solving a memory problem in one of our products running on Soalris. The server memory keeps growing and there is a fear of a server crash.
We've run our product with Purify and libumem to identify memory leaks. Both of these products didn't report any leak. So, we are very much confident that there are no memory leaks in the product. Still the memory increase is seen on Unix systems. We've done extensive analysis on this subject and absorbed some key points regarding memory management in Unix.
1) Memory doesn't shrink on Unix systems. This is for the libc to retain the released memory and reuse it for further memory requirements.
2) Based on the memory requirements to our application there can be a stabilization point where in the application can serve all memory requests.
After reaching this point the Server memory doesn't increase.But the fear is that it may exceed the hardware resources constraint.
3) Rapid increase in memory can be because of Memory Fragmentation problem. There are environmental variables like Small Block Allocator (_M_SBA_OPTS) and Arena (_M_ARENA_OPTS) on HP-Unix machines which can be used to address Fragmentation issues. We've performed some tests using these variables and found significant improvement in the usage of memory. This confirms that there are no memory leaks. These variables are specific to HP-Unix machines and we are unaware of similar variables/mechanism on Sun Solaris Platform. Please recommend some environmental variables/mechanism on Sun Solaris platform to solve fragmentation problem.
We are performing some tests to observe memory stabilization over a period of time .
The memory bloat is following a pattern. Memory is increasing in chunks of (MB) 2,4,8,16,32,64,128,256,512,1024 MB pattern.
For example if Memory increase is 64 MB, then it stabilizes for some time and the next increase would be 128 MB at a time.
Then it stabilizes for double the time consumed earlier for 64 MB and after that only increases by 256 MB.
So the memory increase and stabilization time are getting doubled each time. Please validate our analysis and kindly suggest what can be done on Unix platforms for solving this memory increase problem.

Answer 1

Thanks MaximKartashev for your inputs.
Ours is a Multithreading application. We are testing it with Hoard for the last three days. The observation so far has been that the performance of Hoard is high but the bloat pattern is not avoided.
Even with Hoard, memory bloat is following a pattern. Memory is increasing in chunks of (MB) 2,4,8,16,32,64,128,256,512,1024 MB pattern.
We are searching for other ways to control this pattern and stabilize the application by making it to reuse the fragmented memory completely.
We have also tried Solaris libgc memory allocator (http://developers.sun.com/solaris/articles/libgc.html). It worked well initially and memory drop was seen. But on heavy load, it crashed the application with 'Can't allocate header' error. So this can't be used for heavy load.
We are trying to use Boehm-Demers-Weiser Garbage Collector (http://www.hpl.hp.com/personal/Hans_Boehm/gc/). Do any one have idea, if it controls memory fragmentation ?