10-26-2012
Quote:
Originally Posted by
alister
In the open source world, that hasn't been true for about 10 years. Linux (glibc), OpenBSD, NetBSD, and FreeBSD all return memory to the system under certain circumstances (such as free()ing a massive chunk).
This is contrary to what I have read...since the freed memory return to the OS pool only when the process exits. I maybe wrong but this seems to contradict what I read in this
book...besides frequent garbage collection by the OS is going to make the kernel sweat. In fact whatever I understood about runtime memory allocation from that book is exactly what Corona688 posted.
10 More Discussions You Might Find Interesting
1. UNIX for Advanced & Expert Users
Hi!! Experts,
Any ideas how to check for the memory leaks in a process during performance testing?? I dont use purify.. Any way of finding it out using default S/W in HP UX-11
Can U gimme pointers to site having good scripts/tutorials on performance testing??
Thanx in Advance..
:) (3 Replies)
Discussion started by: jyotipg
3 Replies
2. HP-UX
Hi folks,
We are using following listed configurations for a particular application.
HP-UX 11i
Sun Java 2 SDK Standard Edition 1.4.1 (version shipped with WebLogic 8)
Oracle 9i Release 2 (Oracle 9.2.0)
BEA WebLogic Server 8.1 SP3
It seems a memory leak when we use above configurations.... (1 Reply)
Discussion started by: gimhan90
1 Replies
3. Programming
hi, i am a c++ programmer working on linux(redhat linux8.0) environment, i need to find out the memory leaks, so far i didn't used any tools, so what are the tools are available, and whic one is good to use. plz provide with a small example. (1 Reply)
Discussion started by: sarwan
1 Replies
4. UNIX for Advanced & Expert Users
Hi Unix lovers,
I am facing a strange problem about memory leak. One component of our product show memory leak at customer's end but not in development environment. The memory used by the exe goes on increasing at customer end but not in dev.
customer has same m/c(HP unix 11i) , the same... (1 Reply)
Discussion started by: shriashishpatil
1 Replies
5. Shell Programming and Scripting
Hi all,
Has anyone out there a shell script to detect memory leaks on unix machines?
And if so what way did they go about it .? (5 Replies)
Discussion started by: nano2
5 Replies
6. UNIX and Linux Applications
Hello all
Is there good free ware tools to check software memory leaks ?
Some thing like purify
on unix platforms sun/hp/linux
Thanks (3 Replies)
Discussion started by: umen
3 Replies
7. Solaris
Hi,
Im working on Solaris 9 on SPARC-32 bit running on an Ultra-80, and I have to find out the following:-
1. Total Physical Memory in the system(total RAM).
2. Available Physical Memory(i.e. RAM Usage)
3. Total (Logical) Memory in the system
4. Available (Logical) Memory.
I know... (4 Replies)
Discussion started by: 0ktalmagik
4 Replies
8. AIX
Hi all,
I have written a small code just to invoke main and return immediately. When built with libpthread on AIX box, valgrind throws lots of memory leak errors. But when built without libpthread, no issues at all.
Here is the sample run for your look. Any idea where I might be going wrong?... (3 Replies)
Discussion started by: visionofarun
3 Replies
9. Emergency UNIX and Linux Support
Hello!
I've been struggling for not few hours with memory leaks on this
machine. I'm running linux 2.6.32-5-686, and the problem is as follows:
Some months ago, I have compiled kernel 2.6.33-2-686 without any issues
in this same machine. This week I have tried compiling GNUzilla Icecat
and... (23 Replies)
Discussion started by: teresaejunior
23 Replies
10. Solaris
Hi Experts,
Our servers running Solaris 10 with SAP Application. The memory utilization always >90%, but the process on SAP is too less even nothing.
Why memory utilization on solaris always looks high?
I have statement about memory on solaris, is this true:
Memory in solaris is used for... (4 Replies)
Discussion started by: edydsuranta
4 Replies
LEARN ABOUT CENTOS
libtalloc_pools
libtalloc_pools(3) talloc libtalloc_pools(3)
NAME
libtalloc_pools - Chapter 5: Memory pools
Memory pools
Allocation of a new memory is an expensive operation and large programs can contain thousands of calls of malloc() for a single
computation, where every call allocates only a very small amount of the memory. This can result in an undesirable slowdown of the
application. We can avoid this slowdown by decreasing the number of malloc() calls by using a memory pool.
A memory pool is a preallocated memory space with a fixed size. If we need to allocate new data we will take the desired amount of the
memory from the pool instead of requesting a new memory from the system. This is done by creating a pointer that points inside the
preallocated memory. Such a pool must not be reallocated as it would change its location - pointers that were pointing inside the pool
would become invalid. Therefore, a memory pool requires a very good estimate of the required memory space.
The talloc library contains its own implementation of a memory pool. It is highly transparent for the programmer. The only thing that needs
to be done is an initialization of a new pool context using talloc_pool() - which can be used in the same way as any other context.
Refactoring of existing code (that uses talloc) to take the advantage of a memory pool is quite simple due to the following properties of
the pool context:
o if we are allocating data on a pool context, it takes the desired amount of memory from the pool,
o if the context is a descendant of the pool context, it takes the space from the pool as well,
o if the pool does not have sufficient portion of memory left, it will create a new non-pool context, leaving the pool intact
/* allocate 1KiB in a pool */
TALLOC_CTX *pool_ctx = talloc_pool(NULL, 1024);
/* Take 512B from the pool, 512B is left there */
void *ptr = talloc_size(pool_ctx, 512);
/* 1024B > 512B, this will create new talloc chunk outside
the pool */
void *ptr2 = talloc_size(ptr, 1024);
/* The pool still contains 512 free bytes
* this will take 200B from them. */
void *ptr3 = talloc_size(ptr, 200);
/* This will destroy context 'ptr3' but the memory
* is not freed, the available space in the pool
* will increase to 512B. */
talloc_free(ptr3);
/* This will free memory taken by 'pool_ctx'
* and 'ptr2' as well. */
talloc_free(pool_ctx);
The above given is very convenient, but there is one big issue to be kept in mind. If the parent of a talloc pool child is changed to a
parent that is outside of this pool, the whole pool memory will not be freed until the child is freed. For this reason we must be very
careful when stealing a descendant of a pool context.
TALLOC_CTX *mem_ctx = talloc_new(NULL);
TALLOC_CTX *pool_ctx = talloc_pool(NULL, 1024);
struct foo *foo = talloc(pool_ctx, struct foo);
/* mem_ctx is not in the pool */
talloc_steal(mem_ctx, foo);
/* pool_ctx is marked as freed but the memory is not
deallocated, accessing the pool_ctx again will cause
an error */
talloc_free(pool_ctx);
/* This deallocates the pool_ctx. */
talloc_free(mem_ctx);
It may often be better to copy the memory we want instead of stealing it to avoid this problem. If we do not need to retain the context
name (to keep the type information), we can use talloc_memdup() to do this.
Copying the memory out of the pool may, however, discard all the performance boost given by the pool, depending on the size of the copied
memory. Therefore, the code should be well profiled before taking this path. In general, the golden rule is: if we need to steal from the
pool context, we should not use a pool context.
Version 2.0 Tue Jun 17 2014 libtalloc_pools(3)