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