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