ityr.hpp

Go to the documentation of this file.

#pragma once
 
#include "ityr/common/util.hpp"
#include "ityr/common/options.hpp"
#include "ityr/common/topology.hpp"
#include "ityr/common/wallclock.hpp"
#include "ityr/common/profiler.hpp"
#include "ityr/ito/ito.hpp"
#include "ityr/ori/ori.hpp"
#include "ityr/pattern/count_iterator.hpp"
#include "ityr/pattern/root_exec.hpp"
#include "ityr/pattern/parallel_invoke.hpp"
#include "ityr/pattern/parallel_loop.hpp"
#include "ityr/pattern/parallel_reduce.hpp"
#include "ityr/pattern/parallel_filter.hpp"
#include "ityr/pattern/parallel_merge.hpp"
#include "ityr/pattern/parallel_sort.hpp"
#include "ityr/pattern/parallel_search.hpp"
#include "ityr/pattern/parallel_shuffle.hpp"
#include "ityr/pattern/random.hpp"
#include "ityr/pattern/reducer_extra.hpp"
#include "ityr/container/global_span.hpp"
#include "ityr/container/global_vector.hpp"
#include "ityr/container/checkout_span.hpp"
#include "ityr/container/workhint.hpp"
#include "ityr/container/unique_file_ptr.hpp"
 
namespace ityr {
 
namespace internal {
 
class ityr {
public:
  ityr(MPI_Comm comm)
    : mi_(comm),
      topo_(comm),
      ito_(comm),
      ori_(comm) {}
 
private:
  common::mpi_initializer                                    mi_;
  common::runtime_options                                    opts_;
  common::singleton_initializer<common::topology::instance>  topo_;
  common::singleton_initializer<common::wallclock::instance> clock_;
  common::singleton_initializer<common::profiler::instance>  prof_;
  common::singleton_initializer<ito::instance>               ito_;
  common::singleton_initializer<ori::instance>               ori_;
};
 
using instance = common::singleton<ityr>;
 
}
 
inline void init(MPI_Comm comm = MPI_COMM_WORLD) {
  internal::instance::init(comm);
}
 
inline void fini() {
  internal::instance::fini();
}
 
using rank_t = common::topology::rank_t;
 
inline rank_t my_rank() {
  return common::topology::my_rank();
}
 
inline rank_t n_ranks() {
  return common::topology::n_ranks();
}
 
inline bool is_master() {
  return my_rank() == 0;
}
 
inline bool is_root() {
  return ito::is_root();
}
 
inline void migrate_to(rank_t target_rank) {
  ito::migrate_to(target_rank, [] { ori::release(); }, [] { ori::acquire(); });
}
 
inline void migrate_to_master() {
  ito::migrate_to(0, [] { ori::release(); }, [] { ori::acquire(); });
}
 
inline bool is_spmd() {
  return ito::is_spmd();
}
 
inline void barrier() {
  ITYR_CHECK(is_spmd());
  ori::release();
  common::mpi_barrier(common::topology::mpicomm());
  ori::acquire();
}
 
using wallclock_t = common::wallclock::wallclock_t;
 
inline wallclock_t gettime_ns() {
  return common::wallclock::gettime_ns();
}
 
inline void profiler_begin() {
  ITYR_CHECK(is_spmd());
  ori::cache_prof_begin();
  ito::dag_prof_begin();
  common::profiler::begin();
#if ITYR_DEBUG_UCX
  common::ityr_ucx_log_enable(1);
  ucs_info("Itoyori profiler begin");
#endif
}
 
inline void profiler_end() {
  ITYR_CHECK(is_spmd());
#if ITYR_DEBUG_UCX
  ucs_info("Itoyori profiler end");
  common::ityr_ucx_log_enable(0);
#endif
  common::profiler::end();
  ito::dag_prof_end();
  ori::cache_prof_end();
}
 
inline void profiler_flush() {
  ITYR_CHECK(is_spmd());
#if ITYR_DEBUG_UCX
  common::ityr_ucx_log_flush();
#endif
  common::profiler::flush();
  ito::dag_prof_print();
  ori::cache_prof_print();
}
 
inline void print_compile_options() {
  common::print_compile_options();
  ito::print_compile_options();
  ori::print_compile_options();
}
 
inline void print_runtime_options() {
  common::print_runtime_options();
}
 
}