gmThreadLocalStorage.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/

#ifndef _GEMA_THREAD_LOCAL_STORAGE_H_
#define _GEMA_THREAD_LOCAL_STORAGE_H_

#include "gmMemory.h"
#include "gmThreadManager.h"


template <class T, bool Align> struct GmTLS_DataT {};

template <class T> struct GmTLS_DataT<T, false> { typedef T BaseT; T _value; };

template <class T> struct GmTLS_DataT<T, true> { typedef T BaseT;  GM_CACHE_ALIGNED T _value; };

template <class DataT, bool Align> struct GmTLS_Alloc {};

template <class DataT> struct GmTLS_Alloc<DataT, false>
{
  static_assert(sizeof(DataT) == sizeof(typename DataT::BaseT), "Unexpected type size for unaligned GmTLS_Alloc");

  static DataT* alloc()
  {
    assert(GmThreadManager::maxWorkerThreads() >= 0);
    return new DataT[GmThreadManager::maxWorkerThreads()+1];
  }

  static void free(DataT* ptr) { delete[] ptr; }
};

template <class DataT> struct GmTLS_Alloc<DataT, true>
{
  static_assert(sizeof(DataT) % GM_CACHE_LINE_SIZE == 0, "Unexpected type size for aligned GmTLS_Alloc");

  static DataT* alloc()
  {
    assert(GmThreadManager::maxWorkerThreads() >= 0);

    int    nt  = GmThreadManager::maxWorkerThreads() + 1;
    DataT* ptr = (DataT*)GmAlignedMallocThrow(nt*sizeof(DataT), GM_CACHE_LINE_SIZE);
    assert(GmIsCacheAligned(ptr));

    // Calls, if needed, the default object constructor for each thread entry
    GmConstructAlignedObjectsInMemory<typename DataT::BaseT>((typename DataT::BaseT*)ptr, GM_CACHE_LINE_SIZE, nt);
    return ptr;
  }

  static void free(DataT* ptr) 
  { 
    assert(GmThreadManager::maxWorkerThreads() >= 0);

    int nt = GmThreadManager::maxWorkerThreads() + 1;
    GmDestroyAlignedObjectsInMemory<typename DataT::BaseT>((typename DataT::BaseT*)ptr, GM_CACHE_LINE_SIZE, nt);
    GmAlignedFree(ptr);
  }
};


template <class T, bool Align = false> class GmTLS
{
public:

  // The type used for storing data
  typedef GmTLS_DataT<T, Align> DataT;

  // The type used for allocating the stored data
  typedef GmTLS_Alloc<DataT, Align> Alloc;

  static_assert(!Align || (sizeof(DataT)%GM_CACHE_LINE_SIZE) == 0, "Unexpected type size for aligned TLS");

  GmTLS() { _data = Alloc::alloc(); }

  GmTLS(const T& defVal) { _data = Alloc::alloc(); init(defVal); }

  ~GmTLS() { Alloc::free(_data); }

  void init(const T& val)
  {
    for(int i = 0; i<GmThreadManager::maxWorkerThreads()+1; i++)
      _data[i]._value = val;
  }

  int size() const { return GmThreadManager::maxWorkerThreads() + 1; }

  T& localData(int tid)
  {
    assert(tid >= 0 && tid <= GmThreadManager::maxWorkerThreads());
    return _data[tid]._value;
  }

  const T& localData(int tid) const
  {
    assert(tid >= 0 && tid <= GmThreadManager::maxWorkerThreads());
    return _data[tid]._value;
  }

  T& localData() { return localData(GmThreadManager::currentId()); }

  const T& localData() const { return localData(GmThreadManager::currentId()); }

  void setLocalData(int tid, const T& data) { _data[tid]._value = data; }

  void setLocalData(const T& data) { setLocalData(GmThreadManager::currentId(), data); }

private:
  Q_DISABLE_COPY(GmTLS)

  DataT* _data;  
};

#endif