execution.hh

Go to the documentation of this file.

/*
    @@@@@@@@  @@           @@@@@@   @@@@@@@@ @@
   /@@/////  /@@          @@////@@ @@////// /@@
   /@@       /@@  @@@@@  @@    // /@@       /@@
   /@@@@@@@  /@@ @@///@@/@@       /@@@@@@@@@/@@
   /@@////   /@@/@@@@@@@/@@       ////////@@/@@
   /@@       /@@/@@//// //@@    @@       /@@/@@
   /@@       @@@//@@@@@@ //@@@@@@  @@@@@@@@ /@@
   //       ///  //////   //////  ////////  //

   Copyright (c) 2016, Triad National Security, LLC
   All rights reserved.
                                                                              */
#pragma once

#if !defined(__FLECSI_PRIVATE__)
#define __FLECSI_PRIVATE__
#endif

#include <boost/optional.hpp>
#include <boost/optional/optional_io.hpp>
#include <boost/program_options.hpp>
#include <boost/smart_ptr/make_shared.hpp>

#include "flecsi/exec/backend.hh"
#include "flecsi/exec/fold.hh"
#include "flecsi/exec/launch.hh"
#include "flecsi/exec/task_attributes.hh"
#include "flecsi/flog.hh"
#include "flecsi/run/backend.hh"

/*----------------------------------------------------------------------------*
  Basic runtime interface
 *----------------------------------------------------------------------------*/

namespace flecsi {

inline int
initialize(int argc, char ** argv, bool dependent = true) {
  return run::context::instance().initialize(argc, argv, dependent);
}

inline int
start(const std::function<int()> & action) {
  return run::context::instance().start(action);
}

inline void
finalize() {
  run::context::instance().finalize();
}

enum option_attribute : size_t {
  option_default,
  option_implicit,
  option_zero,
  option_multi
}; // enum

/*
  Auxilliary type for program options.
 */

using any = boost::any;

template<typename ValueType>
ValueType
option_value(any const & v) {
  return boost::any_cast<boost::optional<ValueType>>(v).value();
}

template<typename ValueType>
struct program_option {

  struct initializer_value
    : public std::pair<option_attribute, boost::optional<ValueType>> {

    initializer_value(option_attribute key) : initializer_value::pair(key, {}) {
      flog_assert(key == option_zero || key == option_multi,
        "invalid constructor for initializer_value: "
          << (key == option_default ? "option_default" : "option_implicit")
          << " must take a value");
    }
    initializer_value(option_attribute key, ValueType value)
      : initializer_value::pair(key, value) {
      flog_assert(key == option_default || key == option_implicit,
        "invalid constructor for initializer_value: "
          << (key == option_zero ? "option_zero" : "option_multi")
          << " does not take a value");
    }
  };

  program_option(const char * section,
    const char * flag,
    const char * help,
    std::initializer_list<initializer_value> values = {},
    std::function<bool(const any &)> const & check = default_check) {

    auto semantic_ = boost::program_options::value(&value_);

    bool zero{false}, implicit{false};
    for(auto const & v : values) {
      if(v.first == option_default) {
        semantic_->default_value(v.second);
      }
      else if(v.first == option_implicit) {
        semantic_->implicit_value(v.second);
        implicit = true;
      }
      else if(v.first == option_zero) {
        semantic_->zero_tokens();
        zero = true;
      }
      else if(v.first == option_multi) {
        semantic_->multitoken();
      }
      else {
        flog_fatal("invalid value type");
      } // if
    } // for

    if(zero) {
      flog_assert(implicit, "option_zero specified without option_implicit");
    } // if

    auto option =
      boost::make_shared<boost::program_options::option_description>(
        flag, semantic_, help);

    run::context::instance()
      .descriptions_map()
      .try_emplace(section, section)
      .first->second.add(option);

    std::string sflag(flag);
    sflag = sflag.substr(0, sflag.find(','));

    run::context::instance().option_checks().try_emplace(sflag, false, check);
  } // program_option

  program_option(const char * name,
    const char * help,
    size_t count,
    std::function<bool(const any &)> const & check = default_check) {
    auto semantic_ = boost::program_options::value(&value_);
    semantic_->required();

    auto option =
      boost::make_shared<boost::program_options::option_description>(
        name, semantic_, help);

    auto & c = run::context::instance();
    c.positional_description().add(name, count);
    c.positional_help().try_emplace(name, help);
    c.hidden_options().add(option);
    c.option_checks().try_emplace(name, true, check);
  } // program_options

  ValueType value() const {
    return value_.value();
  }

  operator ValueType() const {
    return value();
  }

  bool has_value() const {
    return value_.has_value();
  }

private:
  static bool default_check(const boost::any &) {
    return true;
  }

  boost::optional<ValueType> value_{};

}; // struct program_option

inline std::string const &
program() {
  return run::context::instance().program();
}

inline size_t
process() {
  return run::context::instance().process();
}

inline size_t
processes() {
  return run::context::instance().processes();
}

inline size_t
threads_per_process() {
  return run::context::instance().threads_per_process();
}

inline size_t
threads() {
  return run::context::instance().threads();
}

inline size_t
color() {
  return run::context::instance().color();
}

inline size_t
colors() {
  return run::context::instance().colors();
}

template<auto & TASK,
  const exec::launch_domain & LAUNCH_DOMAIN,
  class REDUCTION_OPERATION,
  size_t ATTRIBUTES,
  typename... ARGS>
decltype(auto) reduce(ARGS &&... args);

template<auto & TASK,
  const exec::launch_domain & LAUNCH_DOMAIN = index,
  size_t ATTRIBUTES = flecsi::loc | flecsi::leaf,
  typename... ARGS>
decltype(auto)
execute(ARGS &&... args) {
  return reduce<TASK, LAUNCH_DOMAIN, void, ATTRIBUTES>(
    std::forward<ARGS>(args)...);
} // execute

template<auto & TASK,
  const exec::launch_domain & LAUNCH_DOMAIN = flecsi::index,
  size_t ATTRIBUTES = flecsi::loc | flecsi::leaf,
  typename... ARGS>
int
test(ARGS &&... args) {
  return reduce<TASK, LAUNCH_DOMAIN, exec::fold::sum<int>, ATTRIBUTES>(
    std::forward<ARGS>(args)...)
    .get();
} // test

} // namespace flecsi