asecond of all, glibc delays freeing of some memory (in the brk() area)
to optimize for cases of frequent malloc/free operations, so that it
doesn't have to go to the kernel all the time (and a free would imply
across cpu TLB invalidate which is *expensive*, so batching those up isscenario Ireally good thing for performance)As per my observation, in two scenarios that I have tried, in oneseeam able to see the prints from remove_vm_struct(), but in the other
scenario, I don't see any prints from remove_vm_strcut().
My question is, if there is delayed freeing of virtual address space, it
should be the same in both the scenarios, but its not the case, and this
behavior is consistent for my two scenarios, i.e.. in one I am able to
the kernel prints and in other I am not, respectively.I'm sorry but you're not providing enough information for me to
understand your follow-on question.
Well, the application, which is causing problem is specific to our
organization and details may not be known to the list. Any ways I am
detailing it further,
Our application is a VoIP application, which uses OSIP stack.
While running the application, when I give outgoing call, I see the VM
getting allocated and subsequently getting freed, this I have verified from
/proc/meminfo and kernel prints (that of remove_vm_struct). But in the case
of incoming call, though this is a reverse case, but I see memory only
getting allocated and not being freed.
I can see in the code that the free function is called but the call has not
been propagated to the kernel. The allocation is in the tune of 4 MB, so the
memory must have been allocated using mmap and not brk, as the heap size for
an application is defined to be 4 K, as per my knowledge. Even if the
allocation is from heap, the heap should get enlarged and on subsequent call
to free, the surplus space should be returned to OS.