tls.hpp

// This file is part of OpenCV project.




// It is subject to the license terms in the LICENSE file found in the top-level directory




// of this distribution and at http://opencv.org/license.html.








#ifndef OPENCV_UTILS_TLS_HPP




#define OPENCV_UTILS_TLS_HPP








#ifndef OPENCV_CORE_UTILITY_H




#error "tls.hpp must be included after opencv2/core/utility.hpp or opencv2/core.hpp"




#endif








namespace

cv
{











namespace
details {
class
TlsStorage; }







class
CV_EXPORTS
TLSDataContainer



{



protected:



TLSDataContainer();



virtual
~TLSDataContainer();







void
gatherData(std::vector<void*> &data)
const;



void
detachData(std::vector<void*>& data);







void* getData()
const;



void
release();







protected:



virtual
void* createDataInstance()
const
= 0;



virtual
void
deleteDataInstance(void* pData)
const
= 0;







private:



int
key_;







friend
class
cv::details::TlsStorage;
// core/src/system.cpp








public:



void
cleanup();








private:



// Disable copy/assign (noncopyable pattern)




TLSDataContainer(TLSDataContainer
&) =
delete;



TLSDataContainer& operator =(const
TLSDataContainer
&) =
delete;


};











template
<typename
T>



class

TLSData
:
protected
TLSDataContainer



{



public:



inline
TLSData() {}



inline
~TLSData() { release(); }







inline
T*
get()
const
{
return
(T*)getData(); }




inline
T&
getRef()
const
{ T* ptr = (T*)getData();
CV_DbgAssert(ptr);
return
*ptr; }








inline
void
cleanup()



{



TLSDataContainer::cleanup();



}







protected:



virtual
void*
createDataInstance() const CV_OVERRIDE {
return
new
T; }



virtual
void
deleteDataInstance(void* pData)
const
CV_OVERRIDE {
delete
(T*)pData; }


};











template
<typename
T>



class

TLSDataAccumulator
:
public
TLSData<T>


{



mutable
cv::Mutex mutex;



mutable
std::vector<T*> dataFromTerminatedThreads;



std::vector<T*> detachedData;



bool
cleanupMode;



public:



TLSDataAccumulator() : cleanupMode(false) {}



~TLSDataAccumulator()



{



release();



}







void
gather(std::vector<T*> &data)
const





{



CV_Assert(cleanupMode ==
false);
// state is not valid




CV_Assert(data.empty());



{



std::vector<void*> &dataVoid =
reinterpret_cast<std::vector<void*>&>(data);



TLSDataContainer::gatherData(dataVoid);



}



{



AutoLock lock(mutex);



data.reserve(data.size() + dataFromTerminatedThreads.size());



for
(typename
std::vector<T*>::const_iterator i = dataFromTerminatedThreads.begin(); i != dataFromTerminatedThreads.end(); ++i)



{



data.push_back((T*)*i);



}



}



}







std::vector<T*>&
detachData()



{



CV_Assert(cleanupMode ==
false);
// state is not valid




std::vector<void*> dataVoid;



{



TLSDataContainer::detachData(dataVoid);



}



{



AutoLock lock(mutex);



detachedData.reserve(dataVoid.size() + dataFromTerminatedThreads.size());



for
(typename
std::vector<T*>::const_iterator i = dataFromTerminatedThreads.begin(); i != dataFromTerminatedThreads.end(); ++i)



{



detachedData.push_back((T*)*i);



}



dataFromTerminatedThreads.clear();



for
(typename
std::vector<void*>::const_iterator i = dataVoid.begin(); i != dataVoid.end(); ++i)



{



detachedData.push_back((T*)(void*)*i);



}



}



dataVoid.clear();



return
detachedData;



}







void
cleanupDetachedData()



{



AutoLock lock(mutex);



cleanupMode =
true;



_cleanupDetachedData();



cleanupMode =
false;



}







void
cleanup()



{



cleanupMode =
true;



TLSDataContainer::cleanup();







AutoLock lock(mutex);



_cleanupDetachedData();



_cleanupTerminatedData();



cleanupMode =
false;



}







void
release()



{



cleanupMode =
true;



TLSDataContainer::release();



{



AutoLock lock(mutex);



_cleanupDetachedData();



_cleanupTerminatedData();



}



}







protected:



// synchronized




void
_cleanupDetachedData()



{



for
(typename
std::vector<T*>::iterator i = detachedData.begin(); i != detachedData.end(); ++i)



{



deleteDataInstance((T*)*i);



}



detachedData.clear();



}







// synchronized




void
_cleanupTerminatedData()



{



for
(typename
std::vector<T*>::iterator i = dataFromTerminatedThreads.begin(); i != dataFromTerminatedThreads.end(); ++i)



{



deleteDataInstance((T*)*i);



}



dataFromTerminatedThreads.clear();



}







protected:



virtual
void*
createDataInstance() const CV_OVERRIDE



{



// Note: we can collect all allocated data here, but this would require raced mutex locks




return
new
T;



}



virtual
void
deleteDataInstance(void* pData)
const
CV_OVERRIDE



{



if
(cleanupMode)



{



delete
(T*)pData;



}



else




{



AutoLock lock(mutex);



dataFromTerminatedThreads.push_back((T*)pData);



}



}


};














}
// namespace








#endif

// OPENCV_UTILS_TLS_HPP