run.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
//
// Created by Eduard Valeyev on 11/5/21.
//
 
#ifndef TTG_RUN_H
#define TTG_RUN_H
 
#include "ttg/fwd.h"
 
#include "ttg/util/bug.h"
#include "ttg/util/env.h"
#include "ttg/world.h"
 
namespace ttg {
 
  namespace detail {
    inline bool& initialized_accessor() {
      static bool flag = false;
      return flag;
    }
    inline bool& finalized_accessor() {
      static bool flag = false;
      return flag;
    }
  }
 
  inline bool initialized() {
    return detail::initialized_accessor();
  }
 
  inline bool finalized() {
    return detail::finalized_accessor();
  }
 
 
  template <typename... RestOfArgs>
  inline void initialize(int argc, char** argv, int num_threads, RestOfArgs&&... args) {
    if (!initialized()) {
      if (finalized()) {
        throw std::runtime_error("ttg::initialize(): TTG already finalized, cannot be re-initialized");
      }
 
      // if requested by user, create a Debugger object
      if (auto debugger_cstr = std::getenv("TTG_DEBUGGER")) {
        using ttg::Debugger;
        auto debugger = std::make_shared<Debugger>();
        Debugger::set_default_debugger(debugger);
        debugger->set_exec(argv[0]);
        debugger->set_cmd(debugger_cstr);
      }
 
      if (num_threads < 1) num_threads = detail::num_threads();
      TTG_IMPL_NS::ttg_initialize(argc, argv, num_threads, std::forward<RestOfArgs>(args)...);
 
      // finish setting up the Debugger, if needed
      if (ttg::Debugger::default_debugger())
        ttg::Debugger::default_debugger()->set_prefix(ttg::default_execution_context().rank());
 
      detail::initialized_accessor() = true;
    }
    else
      throw std::runtime_error("ttg::initialize(): TTG already initialized");
  }
 
 
  inline void finalize() {
    if (initialized()) {
      TTG_IMPL_NS::ttg_finalize();
      detail::initialized_accessor() = false;
      detail::finalized_accessor() = true;
    }
    else
      throw std::runtime_error("ttg::finalize(): TTG has not been initialized yet");
  }
 
  [[noreturn]]
  inline void abort() { TTG_IMPL_NS::ttg_abort(); }
 
 
  inline World default_execution_context() { return TTG_IMPL_NS::ttg_default_execution_context(); }
 
 
  inline void execute(World world = default_execution_context()) { TTG_IMPL_NS::ttg_execute(world); }
 
 
  inline void fence(World world = default_execution_context()) { TTG_IMPL_NS::ttg_fence(world); }
 
  inline int rank(World world = default_execution_context()) { return world.rank(); }
 
  inline int size(World world = default_execution_context()) { return world.size(); }
 
  template <typename TT>
  inline void invoke_once(TT& tt) {
    if (tt.keymap() == tt.get_world().rank()) {
      tt.invoke();
    }
  }
 
  template <typename TT, typename Key>
  inline void invoke_once(TT&& tt, Key&& key) {
    if (tt.keymap(key) == tt.get_world().rank()) {
      tt.invoke(std::forward<Key>(key));
    }
  }
 
}  // namespace ttg
 
#endif  // TTG_RUN_H