Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

TLS memory leaks were fixed;

Browse Source 
TLS was redesigned in more straightforward way;
OPENCV_ABI_COMPATIBILITY define was added;
pull/5177/head
Pavel Vlasov 10 years ago
parent 09b9b0fb9e
commit a33d98c13a
3 changed files with 230 additions and 177 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      modules/core/include/opencv2/core/cvdef.h
  2. 30
      modules/core/include/opencv2/core/utility.hpp
  3. 375
      modules/core/src/system.cpp

2
modules/core/include/opencv2/core/cvdef.h
Unescape View File

@ -58,6 +58,8 @@
#include "opencv2/hal/defs.h" #include "opencv2/hal/defs.h"
#define OPENCV_ABI_COMPATIBILITY 300
#ifdef __OPENCV_BUILD #ifdef __OPENCV_BUILD
# define DISABLE_OPENCV_24_COMPATIBILITY # define DISABLE_OPENCV_24_COMPATIBILITY
#endif #endif

30
modules/core/include/opencv2/core/utility.hpp
Unescape View File

@ -513,30 +513,42 @@ private:
AutoLock& operator = (const AutoLock&); AutoLock& operator = (const AutoLock&);
}; };
// TLS interface
class CV_EXPORTS TLSDataContainer class CV_EXPORTS TLSDataContainer
{ {
private:
int key_;
protected: protected:
TLSDataContainer(); TLSDataContainer();
virtual ~TLSDataContainer(); virtual ~TLSDataContainer();
#if OPENCV_ABI_COMPATIBILITY > 300
void* getData() const;
void release();
private:
#else
void release();
public: public:
void* getData() const;
#endif
virtual void* createDataInstance() const = 0; virtual void* createDataInstance() const = 0;
virtual void deleteDataInstance(void* data) const = 0; virtual void deleteDataInstance(void* pData) const = 0;
void* getData() const; int key_;
}; };
// Main TLS data class
template <typename T> template <typename T>
class TLSData : protected TLSDataContainer class TLSData : protected TLSDataContainer
{ {
public: public:
inline TLSData() {} inline TLSData() {}
inline ~TLSData() {} inline ~TLSData() { release(); } // Release key and delete associated data
inline T* get() const { return (T*)getData(); } inline T* get() const { return (T*)getData(); } // Get data assosiated with key
private: private:
virtual void* createDataInstance() const { return new T; } virtual void* createDataInstance() const {return new T;} // Wrapper to allocate data by template
virtual void deleteDataInstance(void* data) const { delete (T*)data; } virtual void deleteDataInstance(void* pData) const {delete (T*)pData;} // Wrapper to release data by template
}; };
/** @brief Designed for command line parsing /** @brief Designed for command line parsing

375
modules/core/src/system.cpp
Unescape View File

@ -936,241 +936,280 @@ bool Mutex::trylock() { return impl->trylock(); }
//////////////////////////////// thread-local storage //////////////////////////////// //////////////////////////////// thread-local storage ////////////////////////////////
class TLSStorage #ifdef WIN32
#ifdef _MSC_VER
#pragma warning(disable:4505) // unreferenced local function has been removed
#endif
#ifndef TLS_OUT_OF_INDEXES
#define TLS_OUT_OF_INDEXES ((DWORD)0xFFFFFFFF)
#endif
#endif
// TLS platform abstraction layer
class TlsAbstraction
{ {
std::vector<void*> tlsData_;
public: public:
TLSStorage() { tlsData_.reserve(16); } TlsAbstraction();
~TLSStorage(); ~TlsAbstraction();
inline void* getData(int key) const void* GetData() const;
{ void SetData(void *pData);
CV_DbgAssert(key >= 0);
return (key < (int)tlsData_.size()) ? tlsData_[key] : NULL;
}
inline void setData(int key, void* data)
{
CV_DbgAssert(key >= 0);
if (key >= (int)tlsData_.size())
{
tlsData_.resize(key + 1, NULL);
}
tlsData_[key] = data;
}
inline static TLSStorage* get();
};
private:
#ifdef WIN32 #ifdef WIN32
#ifdef _MSC_VER #ifndef WINRT
#pragma warning(disable:4505) // unreferenced local function has been removed DWORD tlsKey;
#endif #endif
#else // WIN32
pthread_key_t tlsKey;
#endif
};
#ifdef WIN32
#ifdef WINRT #ifdef WINRT
// using C++11 thread attribute for local thread data static __declspec( thread ) void* tlsData = NULL; // using C++11 thread attribute for local thread data
static __declspec( thread ) TLSStorage* g_tlsdata = NULL; TlsAbstraction::TlsAbstraction() {}
TlsAbstraction::~TlsAbstraction() {}
void* TlsAbstraction::GetData() const
{
return tlsData;
}
void TlsAbstraction::SetData(void *pData)
{
tlsData = pData;
}
#else //WINRT
TlsAbstraction::TlsAbstraction()
{
tlsKey = TlsAlloc();
CV_Assert(tlsKey != TLS_OUT_OF_INDEXES);
}
TlsAbstraction::~TlsAbstraction()
{
TlsFree(tlsKey);
}
void* TlsAbstraction::GetData() const
{
return TlsGetValue(tlsKey);
}
void TlsAbstraction::SetData(void *pData)
{
CV_Assert(TlsSetValue(tlsKey, pData) == TRUE);
}
#endif
#else // WIN32
TlsAbstraction::TlsAbstraction()
{
CV_Assert(pthread_key_create(&tlsKey, NULL) == 0);
}
TlsAbstraction::~TlsAbstraction()
{
CV_Assert(pthread_key_delete(tlsKey) == 0);
}
void* TlsAbstraction::GetData() const
{
return pthread_getspecific(tlsKey);
}
void TlsAbstraction::SetData(void *pData)
{
CV_Assert(pthread_setspecific(tlsKey, pData) == 0);
}
#endif
static void deleteThreadData() // Per-thread data structure
struct ThreadData
{
ThreadData()
{ {
if (g_tlsdata) idx = 0;
{ slots.reserve(32);
delete g_tlsdata;
g_tlsdata = NULL;
}
} }
inline TLSStorage* TLSStorage::get() std::vector<void*> slots; // Data array for a thread
{ size_t idx; // Thread index in TLS storage. This is not OS thread ID!
if (!g_tlsdata) };
{
g_tlsdata = new TLSStorage;
}
return g_tlsdata;
}
#else
#ifdef WINCE
# define TLS_OUT_OF_INDEXES ((DWORD)0xFFFFFFFF)
#endif
static DWORD tlsKey = TLS_OUT_OF_INDEXES;
static void deleteThreadData() // Main TLS storage class
class TlsStorage
{
public:
TlsStorage()
{ {
if(tlsKey != TLS_OUT_OF_INDEXES) tlsSlots = 0;
{ threads.reserve(32);
delete (TLSStorage*)TlsGetValue(tlsKey);
TlsSetValue(tlsKey, NULL);
}
} }
~TlsStorage()
inline TLSStorage* TLSStorage::get()
{ {
if (tlsKey == TLS_OUT_OF_INDEXES) for(size_t i = 0; i < threads.size(); i++)
{ {
tlsKey = TlsAlloc(); if(threads[i])
CV_Assert(tlsKey != TLS_OUT_OF_INDEXES); {
} /* Current architecture doesn't allow proper global objects relase, so this check can cause crashes
TLSStorage* d = (TLSStorage*)TlsGetValue(tlsKey);
if (!d) // Check if all slots were properly cleared
{ for(size_t j = 0; j < threads[i]->slots.size(); j++)
d = new TLSStorage; {
TlsSetValue(tlsKey, d); CV_Assert(threads[i]->slots[j] == 0);
}
*/
delete threads[i];
}
} }
return d; threads.clear();
} }
#endif //WINRT
#if defined CVAPI_EXPORTS && defined WIN32 && !defined WINCE void releaseThread()
#ifdef WINRT
#pragma warning(disable:4447) // Disable warning 'main' signature found without threading model
#endif
extern "C"
BOOL WINAPI DllMain(HINSTANCE, DWORD fdwReason, LPVOID lpReserved)
{
if (fdwReason == DLL_THREAD_DETACH || fdwReason == DLL_PROCESS_DETACH)
{ {
if (lpReserved != NULL) // called after ExitProcess() call AutoLock guard(mtxGlobalAccess);
ThreadData *pTD = (ThreadData*)tls.GetData();
for(size_t i = 0; i < threads.size(); i++)
{ {
cv::__termination = true; if(pTD == threads[i])
} {
else threads[i] = 0;
{ break;
// Not allowed to free resources if lpReserved is non-null }
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms682583.aspx
cv::deleteThreadAllocData();
cv::deleteThreadData();
} }
tls.SetData(0);
delete pTD;
} }
return TRUE;
}
#endif
#else
static pthread_key_t tlsKey = 0;
static pthread_once_t tlsKeyOnce = PTHREAD_ONCE_INIT;
static void deleteTLSStorage(void* data) // Reserve TLS storage index
size_t reserveSlot()
{ {
delete (TLSStorage*)data; AutoLock guard(mtxGlobalAccess);
tlsSlots++;
return (tlsSlots-1);
} }
static void makeKey() // Release TLS storage index and pass assosiated data to caller
void releaseSlot(size_t slotIdx, std::vector<void*> &dataVec)
{ {
int errcode = pthread_key_create(&tlsKey, deleteTLSStorage); AutoLock guard(mtxGlobalAccess);
CV_Assert(errcode == 0); CV_Assert(tlsSlots > slotIdx);
}
inline TLSStorage* TLSStorage::get() for(size_t i = 0; i < threads.size(); i++)
{
pthread_once(&tlsKeyOnce, makeKey);
TLSStorage* d = (TLSStorage*)pthread_getspecific(tlsKey);
if( !d )
{ {
d = new TLSStorage; if(threads[i]->slots[slotIdx])
pthread_setspecific(tlsKey, d); {
dataVec.push_back(threads[i]->slots[slotIdx]);
threads[i]->slots[slotIdx] = 0;
}
} }
return d; // If we removing last element, decriment slots size to save space
if(tlsSlots-1 == slotIdx)
tlsSlots--;
} }
#endif
class TLSContainerStorage // Get data by TLS storage index
{ void* getData(size_t slotIdx) const
cv::Mutex mutex_;
std::vector<TLSDataContainer*> tlsContainers_;
public:
TLSContainerStorage() { }
~TLSContainerStorage()
{ {
for (size_t i = 0; i < tlsContainers_.size(); i++) CV_Assert(tlsSlots > slotIdx);
{
CV_DbgAssert(tlsContainers_[i] == NULL); // not all keys released
tlsContainers_[i] = NULL;
}
}
int allocateKey(TLSDataContainer* pContainer) ThreadData* threadData = (ThreadData*)tls.GetData();
{ if(threadData && threadData->slots.size() > slotIdx)
cv::AutoLock lock(mutex_); return threadData->slots[slotIdx];
tlsContainers_.push_back(pContainer);
return (int)tlsContainers_.size() - 1; return NULL;
}
void releaseKey(int id, TLSDataContainer* pContainer)
{
cv::AutoLock lock(mutex_);
CV_Assert(tlsContainers_[id] == pContainer);
tlsContainers_[id] = NULL;
// currently, we don't go into thread's TLSData and release data for this key
} }
void destroyData(int key, void* data) // Set data to storage index
void setData(size_t slotIdx, void* pData)
{ {
cv::AutoLock lock(mutex_); CV_Assert(pData != NULL);
TLSDataContainer* k = tlsContainers_[key];
if (!k) ThreadData* threadData = (ThreadData*)tls.GetData();
return; if(!threadData)
try
{
k->deleteDataInstance(data);
}
catch (...)
{ {
CV_DbgAssert(k == NULL); // Debug this! threadData = new ThreadData;
tls.SetData((void*)threadData);
{
AutoLock guard(mtxGlobalAccess);
threadData->idx = threads.size();
threads.push_back(threadData);
}
} }
if(slotIdx >= threadData->slots.size())
threadData->slots.resize(slotIdx+1);
threadData->slots[slotIdx] = pData;
} }
private:
TlsAbstraction tls; // TLS abstraction layer instance
Mutex mtxGlobalAccess; // Shared objects operation guard
size_t tlsSlots; // TLS storage counter
std::vector<ThreadData*> threads; // Array for all allocated data. Thread data pointers are placed here to allow data cleanup
}; };
// This is a wrapper function that will ensure 'tlsContainerStorage' is constructed on first use. // Create global TLS storage object
// For more information: http://www.parashift.com/c++-faq/static-init-order-on-first-use.html static TlsStorage &getTlsStorage()
static TLSContainerStorage& getTLSContainerStorage()
{ {
CV_SINGLETON_LAZY_INIT_REF(TLSContainerStorage, new TLSContainerStorage()) CV_SINGLETON_LAZY_INIT_REF(TlsStorage, new TlsStorage())
} }
TLSDataContainer::TLSDataContainer() TLSDataContainer::TLSDataContainer()
: key_(-1)
{ {
key_ = getTLSContainerStorage().allocateKey(this); key_ = (int)getTlsStorage().reserveSlot(); // Reserve key from TLS storage
} }
TLSDataContainer::~TLSDataContainer() TLSDataContainer::~TLSDataContainer()
{ {
getTLSContainerStorage().releaseKey(key_, this); CV_Assert(key_ == -1); // Key must be released in child object
key_ = -1;
} }
void* TLSDataContainer::getData() const void TLSDataContainer::release()
{ {
CV_Assert(key_ >= 0); std::vector<void*> data;
TLSStorage* tlsData = TLSStorage::get(); data.reserve(32);
void* data = tlsData->getData(key_); getTlsStorage().releaseSlot(key_, data); // Release key and get stored data for proper destruction
if (!data) for(size_t i = 0; i < data.size(); i++) // Delete all assosiated data
{ deleteDataInstance(data[i]);
data = this->createDataInstance(); key_ = -1;
CV_DbgAssert(data != NULL);
tlsData->setData(key_, data);
}
return data;
} }
TLSStorage::~TLSStorage() void* TLSDataContainer::getData() const
{ {
for (int i = 0; i < (int)tlsData_.size(); i++) void* pData = getTlsStorage().getData(key_); // Check if data was already allocated
if(!pData)
{ {
void*& data = tlsData_[i]; // Create new data instance and save it to TLS storage
if (data) pData = createDataInstance();
{ getTlsStorage().setData(key_, pData);
getTLSContainerStorage().destroyData(i, data);
data = NULL;
}
} }
tlsData_.clear(); return pData;
} }
TLSData<CoreTLSData>& getCoreTlsData() TLSData<CoreTLSData>& getCoreTlsData()
{ {
CV_SINGLETON_LAZY_INIT_REF(TLSData<CoreTLSData>, new TLSData<CoreTLSData>()) CV_SINGLETON_LAZY_INIT_REF(TLSData<CoreTLSData>, new TLSData<CoreTLSData>())
} }
#if defined CVAPI_EXPORTS && defined WIN32 && !defined WINCE
#ifdef WINRT
#pragma warning(disable:4447) // Disable warning 'main' signature found without threading model
#endif
extern "C"
BOOL WINAPI DllMain(HINSTANCE, DWORD fdwReason, LPVOID lpReserved)
{
if (fdwReason == DLL_THREAD_DETACH || fdwReason == DLL_PROCESS_DETACH)
{
if (lpReserved != NULL) // called after ExitProcess() call
{
cv::__termination = true;
}
else
{
// Not allowed to free resources if lpReserved is non-null
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms682583.aspx
cv::deleteThreadAllocData();
cv::getTlsStorage().releaseThread();
}
}
return TRUE;
}
#endif
#ifdef CV_COLLECT_IMPL_DATA #ifdef CV_COLLECT_IMPL_DATA
ImplCollector& getImplData() ImplCollector& getImplData()

Write Preview
Loading…
Cancel
Save