Galois.h

Go to the documentation of this file.

#ifndef GALOIS_GALOIS_H
#define GALOIS_GALOIS_H

#include "Galois/config.h"
#include "Galois/WorkList/WorkList.h"
#include "Galois/UserContext.h"
#include "Galois/Threads.h"
#include "Galois/Runtime/ParallelWork.h"
#include "Galois/Runtime/DoAll.h"
#include "Galois/Runtime/DeterministicWork.h"
#include "Galois/Runtime/OrderedWork.h"

#ifdef GALOIS_USE_EXP
#include "Galois/Runtime/ParallelWorkInline.h"
#include "Galois/Runtime/ParaMeter.h"
#endif

#include GALOIS_CXX11_STD_HEADER(utility)
#include GALOIS_CXX11_STD_HEADER(type_traits)
#include GALOIS_CXX11_STD_HEADER(tuple)

namespace Galois {

struct loopname {
  const char* n;
  loopname(const char* n = 0) :n(n) {}
};

struct do_all_steal {
  bool b;
  do_all_steal(bool b = false) :b(b) {}
};

struct wl_tag {};

template<typename WLTy>
struct wl : public wl_tag {
  typedef WLTy WL;
};


namespace HIDDEN {

static constexpr unsigned GALOIS_DEFAULT_CHUNK_SIZE = 32;
typedef WorkList::dChunkedFIFO<GALOIS_DEFAULT_CHUNK_SIZE> defaultWL;

template <typename T, typename S, int i = std::tuple_size<T>::value - 1>
struct tuple_index {
  enum {
    value = std::is_base_of<S, typename std::tuple_element<i, T>::type>::value 
    || std::is_same<S, typename std::tuple_element<i, T>::type>::value
    ? i : tuple_index<T, S, i-1>::value
  };
};

template <typename T, typename S>
struct tuple_index<T, S, -1> {
  enum { value = -1 };
};

template<typename RangeTy, typename FunctionTy, typename Tuple>
void for_each_gen(RangeTy r, FunctionTy fn, Tuple tpl) {
  typedef Tuple tupleType;
  static_assert(-1 == tuple_index<tupleType, char*>::value, "old loopname");
  static_assert(-1 == tuple_index<tupleType, char const*>::value, "old loopname");
  static_assert(-1 == tuple_index<tupleType, bool>::value, "old steal");
  // std::cout << tuple_index<tupleType, char*>::value << " "
  //           << tuple_index<tupleType, char const*>::value << "\n";
  constexpr unsigned iloopname = tuple_index<tupleType, loopname>::value;
  constexpr unsigned iwl = tuple_index<tupleType, wl_tag>::value;
  const char* ln = std::get<iloopname>(tpl).n;
  typedef typename std::tuple_element<iwl,tupleType>::type::WL WLTy;
  Runtime::for_each_impl<WLTy>(r, fn, ln);
}

template<typename RangeTy, typename FunctionTy, typename Tuple>
FunctionTy do_all_gen(RangeTy r, FunctionTy fn, Tuple tpl) {
  typedef Tuple tupleType;
  static_assert(-1 == tuple_index<tupleType, char*>::value, "old loopname");
  static_assert(-1 == tuple_index<tupleType, char const*>::value, "old loopname");
  static_assert(-1 == tuple_index<tupleType, bool>::value, "old steal");
  // std::cout << tuple_index<tupleType, char*>::value << " "
  //           << tuple_index<tupleType, char const*>::value << "\n";
  constexpr unsigned iloopname = tuple_index<tupleType, loopname>::value;
  constexpr unsigned isteal = tuple_index<tupleType, do_all_steal>::value;
  const char* ln = std::get<iloopname>(tpl).n;
  bool steal = std::get<isteal>(tpl).b;
  return Runtime::do_all_impl(r, fn, ln, steal);
}

} // namespace HIDDEN

// Foreach

template<typename IterTy, typename FunctionTy, typename... Args>
void for_each(IterTy b, IterTy e, FunctionTy fn, Args... args) {
  HIDDEN::for_each_gen(Runtime::makeStandardRange(b,e), fn, std::make_tuple(loopname(), wl<HIDDEN::defaultWL>(), args...));
}

template<typename ItemTy, typename FunctionTy, typename... Args>
void for_each(ItemTy i, FunctionTy fn, Args... args) {
  ItemTy iwl[1] = {i};
  HIDDEN::for_each_gen(Runtime::makeStandardRange(&iwl[0], &iwl[1]), fn, std::make_tuple(loopname(), wl<HIDDEN::defaultWL>(), args...));
}

template<typename ConTy, typename FunctionTy, typename... Args>
void for_each_local(ConTy& c, FunctionTy fn, Args... args) {
  HIDDEN::for_each_gen(Runtime::makeLocalRange(c), fn, std::make_tuple(loopname(), wl<HIDDEN::defaultWL>(), args...));
}

template<typename IterTy,typename FunctionTy, typename... Args>
FunctionTy do_all(const IterTy& b, const IterTy& e, FunctionTy fn, Args... args) {
  return HIDDEN::do_all_gen(Runtime::makeStandardRange(b, e), fn, std::make_tuple(loopname(), do_all_steal(), args...));
}

template<typename ConTy,typename FunctionTy, typename... Args>
FunctionTy do_all_local(ConTy& c, FunctionTy fn, Args... args) {
  return HIDDEN::do_all_gen(Runtime::makeLocalRange(c), fn, std::make_tuple(loopname(), do_all_steal(), args...));
}

template<typename FunctionTy>
static inline void on_each(FunctionTy fn, const char* loopname = 0) {
  Runtime::on_each_impl(fn, loopname);
}

static inline void preAlloc(int num) {
  Runtime::preAlloc_impl(num);
}

static inline void reportPageAlloc(const char* label) {
  Runtime::reportPageAlloc(label);
}

template<typename Iter, typename Cmp, typename NhFunc, typename OpFunc>
void for_each_ordered(Iter b, Iter e, const Cmp& cmp, const NhFunc& nhFunc, const OpFunc& fn, const char* loopname=0) {
  Runtime::for_each_ordered_impl(b, e, cmp, nhFunc, fn, loopname);
}

template<typename Iter, typename Cmp, typename NhFunc, typename OpFunc, typename StableTest>
void for_each_ordered(Iter b, Iter e, const Cmp& cmp, const NhFunc& nhFunc, const OpFunc& fn, const StableTest& stabilityTest, const char* loopname=0) {
  Runtime::for_each_ordered_impl(b, e, cmp, nhFunc, fn, stabilityTest, loopname);
}

} //namespace Galois
#endif

---