threadlocal.h

#pragma once

/*    Copyright 2014 MongoDB Inc.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

#include "mongo/client/undef_macros.h"
#include <boost/thread/tss.hpp>
#include "mongo/client/redef_macros.h"


namespace mongo {

/* thread local "value" rather than a pointer
   good for things which have copy constructors (and the copy constructor is fast enough)
   e.g.
     ThreadLocalValue<int> myint;
*/
template <class T>
class ThreadLocalValue {
public:
    ThreadLocalValue(T def = 0) : _default(def) {}

    T get() const {
        T* val = _val.get();
        if (val)
            return *val;
        return _default;
    }

    void set(const T& i) {
        T* v = _val.get();
        if (v) {
            *v = i;
            return;
        }
        v = new T(i);
        _val.reset(v);
    }

    T& getRef() {
        T* v = _val.get();
        if (v) {
            return *v;
        }
        v = new T(_default);
        _val.reset(v);
        return *v;
    }

private:
    boost::thread_specific_ptr<T> _val;
    const T _default;
};

/* TSP
   These macros use intrinsics which are faster than boost::thread_specific_ptr.
   However the intrinsics don't free up objects on thread closure. Thus we use
   a combination here, with the assumption that reset's are infrequent, so that
   get's are fast.
*/
#if defined(MONGO_HAVE___THREAD) || defined(MONGO_HAVE___DECLSPEC_THREAD)

template <class T>
struct TSP {
    boost::thread_specific_ptr<T> tsp;

public:
    T* get() const;
    void reset(T* v);
    T* getMake() {
        T* t = get();
        if (t == 0)
            reset(t = new T());
        return t;
    }
};

#if defined(MONGO_HAVE___DECLSPEC_THREAD)

#define TSP_DECLARE(T, p) extern TSP<T> p;

#define TSP_DEFINE(T, p)        \
    __declspec(thread) T* _##p; \
    TSP<T> p;                   \
    template <>                 \
    T* TSP<T>::get() const {    \
        return _##p;            \
    }                           \
    void TSP<T>::reset(T* v) {  \
        tsp.reset(v);           \
        _##p = v;               \
    }
#else

#define TSP_DECLARE(T, p)           \
    extern __thread T* _##p;        \
    template <>                     \
    inline T* TSP<T>::get() const { \
        return _##p;                \
    }                               \
    extern TSP<T> p;

#define TSP_DEFINE(T, p)       \
    __thread T* _##p;          \
    template <>                \
    void TSP<T>::reset(T* v) { \
        tsp.reset(v);          \
        _##p = v;              \
    }                          \
    TSP<T> p;
#endif

#elif defined(_POSIX_THREADS) && (_POSIX_THREADS >= 0)
template <class T>
struct TSP {
    pthread_key_t _key;

public:
    TSP() {
        verify(pthread_key_create(&_key, TSP::dodelete) == 0);
    }

    ~TSP() {
        pthread_key_delete(_key);
    }

    static void dodelete(void* x) {
        T* t = reinterpret_cast<T*>(x);
        delete t;
    }

    T* get() const {
        return reinterpret_cast<T*>(pthread_getspecific(_key));
    }

    void reset(T* v) {
        T* old = get();
        delete old;
        verify(pthread_setspecific(_key, v) == 0);
    }

    T* getMake() {
        T* t = get();
        if (t == 0) {
            t = new T();
            reset(t);
        }
        return t;
    }
};

#define TSP_DECLARE(T, p) extern TSP<T> p;

#define TSP_DEFINE(T, p) TSP<T> p;

#else

template <class T>
struct TSP {
    boost::thread_specific_ptr<T> tsp;

public:
    T* get() const {
        return tsp.get();
    }
    void reset(T* v) {
        tsp.reset(v);
    }
    T* getMake() {
        T* t = get();
        if (t == 0)
            reset(t = new T());
        return t;
    }
};

#define TSP_DECLARE(T, p) extern TSP<T> p;

#define TSP_DEFINE(T, p) TSP<T> p;

#endif
}