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