PerThreadStorage.h

Go to the documentation of this file.

#ifndef GALOIS_RUNTIME_PERTHREADSTORAGE_H
#define GALOIS_RUNTIME_PERTHREADSTORAGE_H

#include "Galois/config.h"
#include "Galois/Runtime/ll/TID.h"
#include "Galois/Runtime/ll/HWTopo.h"
#include "Galois/Runtime/ThreadPool.h"
#include "Galois/Runtime/ActiveThreads.h"

#include <boost/utility.hpp>

#include <cassert>
#include <vector>

#include GALOIS_CXX11_STD_HEADER(utility)

namespace Galois {
namespace Runtime {

class PerBackend {
  static const unsigned MAX_SIZE = 30;
  static const unsigned MIN_SIZE = 3; // 8 bytes

  unsigned int nextLoc;
  std::vector<char*> heads;
  std::vector<std::vector<unsigned> > freeOffsets;

  void initCommon();

  static unsigned nextLog2(unsigned size);

public:
  PerBackend(): nextLoc(0) {
    freeOffsets.resize(MAX_SIZE);
  }

  char* initPerThread();
  char* initPerPackage();

#ifdef GALOIS_USE_EXP
  char* initPerThread_cilk ();
  char* initPerPackage_cilk ();
#endif // GALOIS_USE_EXP

  unsigned allocOffset(const unsigned size);
  void deallocOffset(const unsigned offset, const unsigned size);
  void* getRemote(unsigned thread, unsigned offset);
  void* getLocal(unsigned offset, char* base) {
    return &base[offset];
  }
  // faster when (1) you already know the id and (2) shared access to heads is
  // not to expensive; otherwise use getLocal(unsigned,char*)
  void* getLocal(unsigned offset, unsigned id) {
    return &heads[id][offset];
  }
};

extern __thread char* ptsBase;
PerBackend& getPTSBackend();

extern __thread char* ppsBase;
PerBackend& getPPSBackend();

void initPTS();

#ifdef GALOIS_USE_EXP
void initPTS_cilk ();
#endif // GALOIS_USE_EXP


template<typename T>
class PerThreadStorage: private boost::noncopyable {
protected:
  unsigned offset;
  PerBackend& b;

public:
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER <= 1310
  // ICC 13.1 doesn't detect the other constructor as the default constructor
  PerThreadStorage(): b(getPTSBackend()) {
    //in case we make one of these before initializing the thread pool
    //This will call initPTS for each thread if it hasn't already
    Galois::Runtime::getSystemThreadPool();

    offset = b.allocOffset(sizeof(T));
    for (unsigned n = 0; n < LL::getMaxThreads(); ++n)
      new (b.getRemote(n, offset)) T();
  }
#endif

  template<typename... Args>
  PerThreadStorage(Args&&... args) :b(getPTSBackend()) {
    //in case we make one of these before initializing the thread pool
    //This will call initPTS for each thread if it hasn't already
    Galois::Runtime::getSystemThreadPool();

    offset = b.allocOffset(sizeof(T));
    for (unsigned n = 0; n < LL::getMaxThreads(); ++n)
      new (b.getRemote(n, offset)) T(std::forward<Args>(args)...);
  }

  ~PerThreadStorage() {
    for (unsigned n = 0; n < LL::getMaxThreads(); ++n)
      reinterpret_cast<T*>(b.getRemote(n, offset))->~T();
    b.deallocOffset(offset, sizeof(T));
  }

  T* getLocal() const {
    void* ditem = b.getLocal(offset, ptsBase);
    return reinterpret_cast<T*>(ditem);
  }

  T* getLocal(unsigned int thread) const {
    void* ditem = b.getLocal(offset, thread);
    return reinterpret_cast<T*>(ditem);
  }

  T* getRemote(unsigned int thread) const {
    void* ditem = b.getRemote(thread, offset);
    return reinterpret_cast<T*>(ditem);
  }

  unsigned size() const {
    return LL::getMaxThreads();
  }
};

template<typename T>
class PerPackageStorage: private boost::noncopyable {
protected:
  unsigned offset;
  PerBackend& b;

public:
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER <= 1310
  // ICC 13.1 doesn't detect the other constructor as the default constructor
  PerPackageStorage(): b(getPPSBackend()) {
    //in case we make one of these before initializing the thread pool
    //This will call initPTS for each thread if it hasn't already
    Galois::Runtime::getSystemThreadPool();

    offset = b.allocOffset(sizeof(T));
    for (unsigned n = 0; n < LL::getMaxPackages(); ++n)
      new (b.getRemote(LL::getLeaderForPackage(n), offset)) T();
  }
#endif

  template<typename... Args>
  PerPackageStorage(Args&&... args) :b(getPPSBackend()) {
    //in case we make one of these before initializing the thread pool
    //This will call initPTS for each thread if it hasn't already
    Galois::Runtime::getSystemThreadPool();

    offset = b.allocOffset(sizeof(T));
    for (unsigned n = 0; n < LL::getMaxPackages(); ++n)
      new (b.getRemote(LL::getLeaderForPackage(n), offset)) T(std::forward<Args>(args)...);
  }

  ~PerPackageStorage() {
    for (unsigned n = 0; n < LL::getMaxPackages(); ++n)
      reinterpret_cast<T*>(b.getRemote(LL::getLeaderForPackage(n), offset))->~T();
    b.deallocOffset(offset, sizeof(T));
  }

  T* getLocal() const {
    void* ditem = b.getLocal(offset, ppsBase);
    return reinterpret_cast<T*>(ditem);
  }

  T* getLocal(unsigned int thread) const {
    void* ditem = b.getLocal(offset, thread);
    return reinterpret_cast<T*>(ditem);
  }

  T* getRemote(unsigned int thread) const {
    void* ditem = b.getRemote(thread, offset);
    return reinterpret_cast<T*>(ditem);
  }

  T* getRemoteByPkg(unsigned int pkg) const {
    void* ditem = b.getRemote(LL::getLeaderForPackage(pkg), offset);
    return reinterpret_cast<T*>(ditem);
  }

  unsigned size() const {
    return LL::getMaxThreads();
  }
};

}
} // end namespace Galois

#endif

---