UserContext.h

Go to the documentation of this file.

#ifndef GALOIS_USERCONTEXT_H
#define GALOIS_USERCONTEXT_H

#include "Galois/Mem.h"
#include "Galois/gdeque.h"

#include "Galois/Runtime/Context.h"
#include "Galois/Runtime/MethodFlags.h"

namespace Galois {

template<typename T>
class UserContext: private boost::noncopyable {
protected:
// TODO: move to a separate class for dedicated for sepculative executors
#ifdef GALOIS_USE_EXP
  using Closure = std::function<void (void)>;
  using UndoLog = Galois::gdeque<Closure, 8>;
  using CommitLog = UndoLog;

  UndoLog undoLog;
  CommitLog commitLog;
#endif 

  IterAllocBaseTy IterationAllocatorBase;
  PerIterAllocTy PerIterationAllocator;

  void __resetAlloc() {
    IterationAllocatorBase.clear();
  }

#ifdef GALOIS_USE_EXP
  void __rollback() {
    for (auto ii = undoLog.end (), ei = undoLog.begin(); ii != ei; ) {
      --ii;
      (*ii)();
    }
  }

  void __commit() {
    for (auto ii = commitLog.begin (), ei = commitLog.end(); ii != ei; ++ii) {
      (*ii)();
    }
  }

  void __resetUndoLog() {
    undoLog.clear();
  }

  void __resetCommitLog() {
    commitLog.clear();
  }
#endif 

  typedef gdeque<T> PushBufferTy;
  PushBufferTy pushBuffer;

  PushBufferTy& __getPushBuffer() {
    return pushBuffer;
  }
  
  void __resetPushBuffer() {
    pushBuffer.clear();
  }

  void* localState;
  bool localStateUsed;
  void __setLocalState(void *p, bool used) {
    localState = p;
    localStateUsed = used;
  }

  static const unsigned int fastPushBackLimit = 64;

  typedef std::function<void(PushBufferTy&)> FastPushBack; 
  FastPushBack fastPushBack;
  void __setFastPushBack(FastPushBack f) {
    fastPushBack = f;
  }

  bool* didBreak;

public:
  UserContext()
    :IterationAllocatorBase(), 
     PerIterationAllocator(&IterationAllocatorBase),
     didBreak(0)
  { }

  void breakLoop() {
    *didBreak = true;
  }

  PerIterAllocTy& getPerIterAlloc() {
    return PerIterationAllocator;
  }

  template<typename... Args>
  void push(Args&&... args) {
    Galois::Runtime::checkWrite(MethodFlag::WRITE, true);
    pushBuffer.emplace_back(std::forward<Args>(args)...);
    if (fastPushBack && pushBuffer.size() > fastPushBackLimit)
      fastPushBack(pushBuffer);
  }

  void abort() { Galois::Runtime::forceAbort(); }

  void* getLocalState(bool& used) { used = localStateUsed; return localState; }
 
#ifdef GALOIS_USE_EXP
  void addUndoAction(const Closure& f) {
    undoLog.push_back(f);
  }

  void addCommitAction(const Closure& f) {
    commitLog.push_back(f);
  }
#endif 
};

}

#endif

---