gmThreadLocalBuffer.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_BUFFER_H_
#define _GEMA_THREAD_LOCAL_BUFFER_H_
 
#include "gmMemory.h"
#include "gmThreadLocalStorage.h"
 
 
template <class T, bool Align> struct GmTLBuffer_Alloc {};
 
template <class T> struct GmTLBuffer_Alloc<T, false>
{ 
  static void alloc(int n, GmTLS<T*>& tls)
  {
    assert(GmThreadManager::maxWorkerThreads() >= 0);
 
    int nt = GmThreadManager::maxWorkerThreads() + 1; // +1 for the main thread
 
    T* buffer = new T[n * nt];
    for(int i = 0; i < nt; i++, buffer += n)
      tls.setLocalData(i, buffer);
  }
 
  static void free(int n, GmTLS<T*>& tls) { Q_UNUSED(n);  delete[] tls.localData(0); }
};
 
template <class T> struct GmTLBuffer_Alloc<T, true>
{
  static void alloc(int n, GmTLS<T*>& tls)
  {
    assert(GmThreadManager::maxWorkerThreads() >= 0);
 
    int nt    = GmThreadManager::maxWorkerThreads() + 1; // +1 for the main thread
    int tsize = ceil((n*sizeof(T))/(double)GM_CACHE_LINE_SIZE) * GM_CACHE_LINE_SIZE;
 
    // Alloc space
    char* rawbuffer = (char*)GmAlignedMallocThrow(nt * tsize, GM_CACHE_LINE_SIZE);
 
    // Store pointers
    for(int i = 0; i < nt; i++)
    {
      T* ptr = (T*)(rawbuffer + i*tsize);
      assert(GmIsCacheAligned(ptr));
 
      tls.setLocalData(i, ptr);
      GmConstructObjectsInMemory<T>(ptr, n); // Calls, if needed, the default object constructor for each buffer entry
    }
  }
  
  static void free(int n, GmTLS<T*>& tls) 
  { 
    assert(GmThreadManager::maxWorkerThreads() >= 0);
 
    int nt = GmThreadManager::maxWorkerThreads() + 1; // +1 for the main thread
    for(int i = 0; i<nt; i++)
      GmDestroyObjectsInMemory<T>(tls.localData(i), n); 
 
    GmAlignedFree(tls.localData(0));
  }
};
 
template <class T, bool Align = false> class GmTLBuffer
{
public:
 
  // The type used for allocating the stored data
  typedef GmTLBuffer_Alloc<T, Align> Alloc;
 
  GmTLBuffer() : _data(NULL), _n(0) {}
 
  GmTLBuffer(int n) { assert(n > 0); Alloc::alloc(n, _data); _n = n; }
  
  GmTLBuffer(int n, const T& defVal) { assert(n > 0); Alloc::alloc(n, _data); _n = n; init(defVal); }
 
  ~GmTLBuffer() { if(_n) Alloc::free(_n, _data); }
 
  void clear() { if(_n) { Alloc::free(_n, _data); _n = 0; _data.init(NULL); } }
 
  int size() const { return _n; }
 
  void setSize(int n) { assert(_n == 0); Alloc::alloc(n, _data); _n = n; }
 
  void setSize(int n, const T& defVal) { setSize(n); init(defVal); }
 
  void resize(int n) { if(n != _n) { clear(); setSize(n); } }
 
  T* localBuffer(int tid) { return _data.localData(tid); }
 
  const T* localBuffer(int tid) const { return _data.localData(tid); }
 
  T* localBuffer() { return _data.localData(GmThreadManager::currentId()); }
 
  const T* localBuffer() const { return _data.localData(GmThreadManager::currentId()); }
 
  void init(const T& defVal)
  {
    for(int i = 0; i < GmThreadManager::maxWorkerThreads() + 1; i++)
    {
      T* ptr = _data.localData(i);
      for(int j = 0; j < _n; j++)
        ptr[j] = defVal;
    }
  }
 
private:
  Q_DISABLE_COPY(GmTLBuffer)
 
  
  GmTLS<T*> _data; 
 
  int _n;  
};
 
 
#endif