Fixing Memory Leak in Apache mod_proxy.

Good to work on ‘C’. Recently i had to spend some time on Apache looking out for specific memory leak.

Thanks to Paul for good article http://journal.paul.querna.org/articles/2005/02/23/apr-memory-pools-rock/

The memory leak can be observed when requests are sent on keep-alive connection without closing the connection. As long as the connection is open, in apache we tend to allocate some memory from connection pool for processing each request. So when you have more requests per connection you tend to see apache consuming more memory. If we release the connection and we see that apache frees the memory and don’t see this leaks impact.

For more on this please follow the following link;

http://www.gossamer-threads.com/lists/apache/dev/358549

Serialization

Did some serialization/deserialization evaluation of google protocol buffers and boost serialization.

Found that both lacked the efficiency required by me, and wrote my own version found that we were better then ( more then 10 times) in comparision to boost and google protocol buffers were not comparable.

But boost has the best implementation on net ( with our specific evaluation params), since we don’t wanted all the features of boost, and understanding ever evolving boost was more time consuming and when we wrote our implementation which all most matched the boost serialization implementation and meets our requirements efficiently, we settled for proprietary implementation.

We wrote in C++ and currently don’t support C or Java. I hope we need a way to support this package on ‘C’ and don’t see a need for Java.

It was fun implementing with C++ and templates and overriding.

boost interprocess named_mutex

Hello All,

Just wrote a simple boost named mutex and condition based IPC test tool. Boost has done life so simple, with these kind of interfaces to basic programming.

-thanks

Harish

<code>

#include <boost/interprocess/sync/named_condition.hpp>
#include <boost/interprocess/sync/named_mutex.hpp>

namespace ipc = boost::interprocess;

int main(int argc, char **argv)
{
std::string lMutexNamed(“harish_mutex”),lCondNamed(“harish_cond”);

std::string lCondNamed2(“harish_cond2″),lMutexNamed2(“harish_mutex2″);
ipc::named_mutex::remove(lMutexNamed.c_str());
ipc::named_mutex appTraceCtrlMutex(boost::interprocess::create_only,lMutexNamed.c_str());
ipc::named_condition::remove(lCondNamed.c_str());
ipc::named_condition appTraceCtrlCondition(boost::interprocess::create_only,lCondNamed.c_str());
ipc::named_condition::remove(lCondNamed2.c_str());
ipc::named_condition appTraceCtrlCondition2(boost::interprocess::create_only,lCondNamed2.c_str());
ipc::named_condition::remove(lMutexNamed2.c_str());
ipc::named_mutex appTraceCtrlMutex2(boost::interprocess::create_only,lMutexNamed2.c_str());

int i=10;
while(i) {
{
ipc::scoped_lock<ipc::named_mutex> lock(appTraceCtrlMutex);
printf(“Acquired lock:[%s]\n”,lMutexNamed.c_str());
//sleep on condition
appTraceCtrlCondition.wait(lock);
printf(“Notification recv from t1\n”);
}
{
ipc::scoped_lock<ipc::named_mutex> lock(appTraceCtrlMutex2);
appTraceCtrlCondition2.notify_one();
printf(“Notification sent to t2\n”);
}
i–;

}

printf(“Done with creation of named mutex/condition \n”);
}

t2.cpp

#include <boost/interprocess/sync/named_condition.hpp>
#include <boost/interprocess/sync/named_mutex.hpp>

namespace ipc = boost::interprocess;

int main(int argc, char **argv)
{
std::string lMutexNamed(“harish_mutex”),lCondNamed(“harish_cond”),lCondNamed2(“harish_cond2″),lMutexNamed2(“harish_mutex2″);
try {
ipc::named_mutex appTraceCtrlMutex(boost::interprocess::open_only,lMutexNamed.c_str());
ipc::named_condition appTraceCtrlCondition(boost::interprocess::open_only,lCondNamed.c_str());
ipc::named_mutex appTraceCtrlMutex2(boost::interprocess::open_only,lMutexNamed2.c_str());
ipc::named_condition appTraceCtrlCondition2(boost::interprocess::open_only,lCondNamed2.c_str());
int i=10;
while(i) {
{
ipc::scoped_lock<ipc::named_mutex> lock(appTraceCtrlMutex);
// wake-up the guy sleeping on condition
appTraceCtrlCondition.notify_one();
printf(“Sent notification to t1\n”);
}
{
ipc::scoped_lock<ipc::named_mutex> lock(appTraceCtrlMutex2);
appTraceCtrlCondition2.wait(lock);
printf(“Notification recv from t1\n”);
}

i–;
}
}
catch(boost::interprocess::interprocess_exception &ex){
printf(“handleTraceClient harish_mutex\n”);
}
printf(“Done with creation of named mutex/condition \n”);
}

</code>