Boost C++ Libraries: Ticket #11457: windows - boost::recursive_mutex leaks event handles when lock contention occurs.

status, component changed; owner set

viboes — Thu, 20 Aug 2015 23:02:22 GMT

owner set to viboes
status new → assigned
component None → thread

viboes — Thu, 20 Aug 2015 23:13:27 GMT

Please, could you provide a simple example?

viboes — Thu, 03 Sep 2015 07:13:51 GMT

I guess that your are on windows. I have no access to windows.

Please, could you detail each one of the patches that makes your example to don't leak?

viboes — Sun, 27 Sep 2015 13:23:42 GMT

Please, give me more details of the point 1.

viboes — Sun, 11 Oct 2015 19:09:01 GMT

PING !!!

anonymous — Tue, 10 Nov 2015 17:15:35 GMT

Yes, the handle leak occurs in Windows. I have not experienced it in Linux. Here is a simple example class.

class UserInfo
{
    boost::recursive_mutex m_Lock;
    bool IsEntitled (const unsigned int uBit);
}
bool CUserInfo::IsEntitled (const unsigned int uBit)
{
    bool    bRet = false;
    boost::recursive_mutex::scoped_lock lock (m_Lock);
    //do something...anything that takes a few nanoseconds.
    return bRet;
}

You can see the leak by creating a simple windows app that launches multiple threads and puts them each in a loop calling IsEntitled. It will leak event handles for each (or maybe just some?) lock contention events. So the more threads you launch, the more handle leaks you will see.

anonymous — Thu, 12 Nov 2015 03:51:36 GMT

Yes, recursive_mutex leak handles on windows! Please help!

summary changed

viboes — Thu, 12 Nov 2015 22:24:50 GMT

summary boost::recursive_mutex leaks event handles when lock contention occurs. → windows - boost::recursive_mutex leaks event handles when lock contention occurs.

I will take a look, but I don't have a Windows platform to check it.

Niall, if you have some time, could you take a look at this issue?

anonymous jellyfish — Thu, 02 Feb 2017 02:11:33 GMT

I saw a rising Event handle count as described because of boost::recursive_mutex contention with many objects. But the handles aren't leaking; if I delete my array of objects, the boost::recursive_mutex destructor releases the Event handle if it created one.

So, I don't think there is a bug here. If you have an array of 100k objects each containing boost::recursive_mutex, be prepared for anywhere between 0 and 100k Event handles.

status changed; resolution set; milestone deleted

viboes — Sat, 16 Sep 2017 16:56:04 GMT

status assigned → closed
resolution → worksforme
milestone To Be Determined

As we don't have an example I propose to close this issue.

viboes — Sat, 16 Sep 2017 16:58:48 GMT

See #13212