cThreadLocalSys.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cThreadLocalSys_H
#define _INC_cThreadLocalSys_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "GrayCore.h"
#include "cDebugAssert.h"
 
#ifdef __linux__
#include <pthread.h>    // pthread_key_t
#endif
 
#if defined(_WIN32) && defined(__GNUC__)
typedef VOID (NTAPI *PFLS_CALLBACK_FUNCTION) ( PVOID lpFlsData );
WINBASEAPI DWORD WINAPI FlsAlloc( PFLS_CALLBACK_FUNCTION lpCallback );  // replace TlsAlloc()
WINBASEAPI BOOL WINAPI FlsFree( DWORD dwFlsIndex );
WINBASEAPI PVOID WINAPI FlsGetValue( DWORD dwFlsIndex );
WINBASEAPI BOOL WINAPI FlsSetValue( DWORD dwFlsIndex, PVOID lpFlsData );
#endif
 
namespace Gray
{
        DECLARE_INTERFACE(IThreadLocal)
        {
                IGNORE_WARN_INTERFACE(IThreadLocal);
                virtual void* GetDataNewV() = 0;
        };
 
        class cThreadLocalSys
        {
 
        public:
#ifdef _WIN32
#ifndef TLS_OUT_OF_INDEXES
#define TLS_OUT_OF_INDEXES 0xffffffff   // TLS_OUT_OF_INDEXES not defined on UNDER_CE
#endif
                typedef DWORD TYPESLOT_t;       
#elif defined(__linux__)
#define TLS_OUT_OF_INDEXES      ((pthread_key_t)-1)
#define NTAPI
                typedef pthread_key_t TYPESLOT_t;       
                typedef void (NTAPI *PFLS_CALLBACK_FUNCTION)(IN void *p);       // like FARPROC
#else
#error NOOS
#endif
 
        private:
                TYPESLOT_t m_nTypeSlot;         
 
        public:
                cThreadLocalSys(PFLS_CALLBACK_FUNCTION pDestruct = nullptr) noexcept
                {
#ifdef _WIN32
                        // Use newer FlsAlloc (has destructor) over old XP specific TlsAlloc. limited to 128 uses.
#if (_WIN32_WINNT >= 0x0600)
                        m_nTypeSlot = ::FlsAlloc(pDestruct);
#else
                        m_nTypeSlot = ::TlsAlloc();
#endif
#else // __linux__
                        int iRet = ::pthread_key_create( &m_nTypeSlot, pDestruct);
                        if (iRet!=0)
                        {
                                m_nTypeSlot = TLS_OUT_OF_INDEXES;       // failed for some reason.
                        }
#endif
                        DEBUG_CHECK(isInit());
                }
                ~cThreadLocalSys()
                {
                        DEBUG_CHECK(isInit());
#ifdef _WIN32
#if (_WIN32_WINNT >= 0x0600)
                        ::FlsFree(m_nTypeSlot);
#else
                        ::TlsFree(m_nTypeSlot);
#endif
#else // __linux__
                        int iRet = ::pthread_key_delete(m_nTypeSlot);
                        ASSERT(iRet==0);
                        UNREFERENCED_PARAMETER(iRet);
#endif
                }
                bool isInit() const noexcept
                {
#ifdef _WIN32
                        if (m_nTypeSlot == 0)
                                return false;
#endif
                        if (m_nTypeSlot == TLS_OUT_OF_INDEXES)
                                return false;
                        return true;
                }
 
                void* GetData() const noexcept
                {
                        if (!isInit())
                        {
                                // DEBUG_CHECK(0);
                                return nullptr; // Before static init!
                        }
#ifdef _WIN32
#if (_WIN32_WINNT >= 0x0600)
                        return ::FlsGetValue(m_nTypeSlot);
#else
                        return ::TlsGetValue(m_nTypeSlot);
#endif
#else // __linux__
                        return ::pthread_getspecific(m_nTypeSlot);
#endif
                }
 
                bool PutData(void* pData) noexcept
                {
                        DEBUG_CHECK(isInit()); // Before static init!
#ifdef _WIN32
#if (_WIN32_WINNT >= 0x0600)
                        return ::FlsSetValue(m_nTypeSlot, pData) ? true : false;
#else
                        return ::TlsSetValue(m_nTypeSlot, pData) ? true : false;
#endif
#else // __linux__
                        int iRet = ::pthread_setspecific(m_nTypeSlot, pData );
                        return iRet == 0 ;
#endif
                }
        };
 
        template <class TYPE>
        class cThreadLocalSysT : public cThreadLocalSys
        {
 
                typedef cThreadLocalSys SUPER_t;
 
        public:
                cThreadLocalSysT(PFLS_CALLBACK_FUNCTION pDestruct = nullptr) noexcept
                        : cThreadLocalSys(pDestruct) 
                {
                        STATIC_ASSERT(sizeof(TYPE) <= sizeof(void*), cThreadLocalSysT); // ?
                }
                TYPE GetData() const noexcept
                {
                        return (TYPE)SUPER_t::GetData();
                }
                bool PutData(TYPE nData) noexcept
                {
                        return SUPER_t::PutData((void*)nData);
                }
        };
 
        template <class TYPE>
        class cThreadLocalSysNew : public cThreadLocalSysT<TYPE*>, public IThreadLocal
        {
                typedef cThreadLocalSysT<TYPE*> SUPER_t;
 
        protected:
                static void NTAPI OnThreadClose(IN void* pData)
                {
                        ASSERT(pData != nullptr);
                        TYPE* pData2 = (TYPE*)pData;
                        delete pData2;
                }
 
        public:
                cThreadLocalSysNew() noexcept
                        : cThreadLocalSysT<TYPE*>(OnThreadClose)
                {
                }
 
                TYPE* GetDataNew() // GetData
                {
                        TYPE* pData = SUPER_t::GetData();
                        if (pData == nullptr)
                        {
                                pData = new TYPE;
                                SUPER_t::PutData(pData);
                        }
                        return pData;
                }
                virtual void* GetDataNewV()
                {
                        return GetDataNew();
                }
                void FreeDataManually()
                {
                        TYPE* pData = SUPER_t::GetData();
                        if (pData != nullptr)
                        {
                                SUPER_t::PutData(nullptr);
                                delete pData;
                        }
                }
        };
} 
#endif