func.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
#ifndef TTG_FUNC_H
#define TTG_FUNC_H
 
#include "ttg/fwd.h"
 
#include "ttg/edge.h"
#include "ttg/impl_selector.h"
#include "ttg/terminal.h"
#include "ttg/traverse.h"
#include "ttg/tt.h"
 
namespace ttg {
 
  namespace detail {
    template <ttg::Runtime Runtime>
    struct value_copy_handler {
      template <typename Value>
      inline constexpr decltype(auto) operator()(Value &&value) const {
        return std::forward<Value>(value);
      }
    };
 
    template <typename keyT, typename valueT>
    inline auto get_out_terminal(size_t i, const char *func) {
#ifndef NDEBUG
      auto *base_terminal_ptr = TTBase::get_outputs_tls_ptr()->at(i);
      auto *terminal_ptr = dynamic_cast<Out<std::decay_t<keyT>, std::decay_t<valueT>> *>(base_terminal_ptr);
      if (terminal_ptr == nullptr) {
        std::stringstream ss;
        ss << func
           << ": invalid type of ith output terminal, most likely due to mismatch between its type "
              "and the type of key/value; make sure that the arguments to "
           << func
           << "() match the types encoded in the output "
              "terminals, or pass the output terminal tuple to the task function explicitly";
        throw std::runtime_error(ss.str());
      }
#else
      auto *base_terminal_ptr = TTBase::get_outputs_tls_ptr()->operator[](i);
      auto *terminal_ptr = static_cast<Out<std::decay_t<keyT>, std::decay_t<valueT>> *>(base_terminal_ptr);
#endif
      return terminal_ptr;
    }
 
    template <typename keyT>
    inline auto get_out_base_terminal(size_t i, const char *func) {
#ifndef NDEBUG
      auto *base_terminal_ptr = TTBase::get_outputs_tls_ptr()->at(i);
      auto *terminal_ptr = dynamic_cast<OutTerminalBase<std::decay_t<keyT>> *>(base_terminal_ptr);
      if (terminal_ptr == nullptr) {
        std::stringstream ss;
        ss << func
           << ": invalid type of ith output terminal, most likely due to mismatch between its type "
              "and the type of key; make sure that the arguments to "
           << func
           << "() match the types encoded in the output "
              "terminals, or pass the output terminal tuple to the task function explicitly";
        throw std::runtime_error(ss.str());
      }
#else
      auto *base_terminal_ptr = TTBase::get_outputs_tls_ptr()->operator[](i);
      auto *terminal_ptr = static_cast<OutTerminalBase<std::decay_t<keyT>> *>(base_terminal_ptr);
#endif
      return terminal_ptr;
    }
 
  }  // namespace detail
 
  template <typename... TTBasePtrs>
  inline std::enable_if_t<(std::is_convertible_v<decltype(*(std::declval<TTBasePtrs>())), TTBase &> && ...), bool>
  make_graph_executable(TTBasePtrs &&...tts) {
    auto traverse = ttg::make_traverse([](auto &&x) { std::forward<decltype(x)>(x)->make_executable(); });
    auto ret = traverse(std::forward<TTBasePtrs>(tts)...);
    // make sure everyone has traversed the TT
    auto world = [&](auto&& tt0, auto&&... tts) { return tt0->get_world(); }(std::forward<TTBasePtrs>(tts)...);
    TTG_IMPL_NS::make_executable_hook(world);
    return ret;
  }
 
  template <typename keyT, typename valueT>
  inline void connect(ttg::Out<keyT, valueT> *out, ttg::In<keyT, valueT> *in) {
    out->connect(in);
  }
 
  inline void connect(ttg::TerminalBase *out, ttg::TerminalBase *in) { out->connect(in); }
 
  template <std::size_t outindex, std::size_t inindex, typename producer_tt_ptr, typename successor_tt_ptr>
  inline void connect(producer_tt_ptr &p, successor_tt_ptr &c) {
    connect(p->template out<outindex>(), c->template in<inindex>());
  }
 
  template <std::size_t outindex, std::size_t inindex, typename producer_tt_ptr, typename successor_tt_ptr>
  inline void connect(producer_tt_ptr *p, successor_tt_ptr *c) {
    connect(p->template out<outindex>(), c->template in<inindex>());
  }
 
  inline void connect(size_t outindex, size_t inindex, TTBase *producer, TTBase *consumer) {
    connect(producer->out(outindex), consumer->in(inindex));
  }
 
  template <typename keyT, typename... valuesT>
  inline auto fuse(const Edge<keyT, valuesT> &...args) {
    using valueT = std::tuple_element_t<0, std::tuple<valuesT...>>;  // grab first type
    return Edge<keyT, valueT>(args...);                              // This will force all valuesT to be the same
  }
 
  template <typename... inedgesT>
  inline auto edges(inedgesT &&...args) {
    return std::make_tuple(std::forward<inedgesT>(args)...);
  }
 
  // clang-format off
  // clang-format on
  template <typename keyT, typename valueT, typename output_terminalT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void send(const keyT &key, valueT &&value, ttg::Out<keyT, valueT> &t) {
    detail::value_copy_handler<Runtime> copy_handler;
    t.send(key, copy_handler(std::forward<valueT>(value)));
  }
 
  // clang-format off
  // clang-format on
  template <typename keyT>
  inline void sendk(const keyT &key, ttg::Out<keyT, void> &t) {
    t.sendk(key);
  }
 
  // clang-format off
  // clang-format on
  template <typename valueT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void sendv(valueT &&value, ttg::Out<void, valueT> &t) {
    detail::value_copy_handler<Runtime> copy_handler;
    t.sendv(copy_handler(std::forward<valueT>(value)));
  }
 
  // clang-format off
  // clang-format on
  inline void send(ttg::Out<void, void> &t) { t.send(); }
 
  // clang-format off
  // clang-format on
  template <size_t i, typename keyT, typename valueT, typename... out_keysT, typename... out_valuesT,
            ttg::Runtime Runtime = ttg::ttg_runtime>
  inline std::enable_if_t<meta::is_none_void_v<keyT, std::decay_t<valueT>>, void> send(
      const keyT &key, valueT &&value, std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    detail::value_copy_handler<Runtime> copy_handler;
    std::get<i>(t).send(key, copy_handler(std::forward<valueT>(value)));
  }
 
  // clang-format off
  // clang-format on
  template <typename keyT, typename valueT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline std::enable_if_t<meta::is_none_void_v<keyT, std::decay_t<valueT>>, void> send(size_t i, const keyT &key,
                                                                                       valueT &&value) {
    // to avoid mixups due to value being a terminal tuple
    static_assert(!meta::is_output_terminal_v<std::decay_t<valueT>> && !meta::is_output_terminal_tuple_v<std::decay_t<valueT>>, "ttg::send(i, key, x) - invalid invocation, x cannot be a terminal or a tuple of terminals; did you mean to call another version of send, e.g. sendk<i>(key, x)?");
    detail::value_copy_handler<Runtime> copy_handler;
    auto *terminal_ptr = detail::get_out_terminal<keyT, valueT>(i, "ttg::send(i, key, value)");
    terminal_ptr->send(key, copy_handler(std::forward<valueT>(value)));
  }
 
  // clang-format off
  // clang-format on
  template <size_t i, typename keyT, typename valueT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline std::enable_if_t<meta::is_none_void_v<keyT, std::decay_t<valueT>>, void> send(const keyT &key,
                                                                                       valueT &&value) {
    // to avoid mixups due to value being a terminal tuple
    static_assert(!meta::is_output_terminal_v<std::decay_t<valueT>> && !meta::is_output_terminal_tuple_v<std::decay_t<valueT>>, "ttg::send<i>(key, x) - invalid invocation, x cannot be a terminal or a tuple of terminals; did you mean to call another version of send, e.g. sendk<i>(key, x)?");
    send(i, key, std::forward<valueT>(value));
  }
 
  // clang-format off
  // clang-format on
  template <size_t i, typename keyT, typename... out_keysT, typename... out_valuesT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> sendk(const keyT &key,
                                                              std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    std::get<i>(t).sendk(key);
  }
 
  // clang-format off
  // clang-format on
  template <typename keyT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> sendk(std::size_t i, const keyT &key) {
    // to avoid mixups due to key being a terminal tuple
    static_assert(!meta::is_output_terminal_v<std::decay_t<keyT>> && !meta::is_output_terminal_tuple_v<std::decay_t<keyT>>, "ttg::sendk(i, x) - invalid invocation, x cannot be a terminal or a tuple of terminals; did you mean to call another version of send, e.g. send<i>(x)?");
    auto *terminal_ptr = detail::get_out_terminal<keyT, void>(i, "ttg::sendk(i, key)");
    terminal_ptr->sendk(key);
  }
 
  // clang-format off
  // clang-format on
  template <size_t i, typename keyT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> sendk(const keyT &key) {
    // to avoid mixups due to key being a terminal tuple
    static_assert(!meta::is_output_terminal_v<std::decay_t<keyT>> && !meta::is_output_terminal_tuple_v<std::decay_t<keyT>>, "ttg::sendk<i>(x) - invalid invocation, x cannot be a terminal or a tuple of terminals; did you mean to call another version of send, e.g. send<i>(x)?");
    sendk(i, key);
  }
 
  // clang-format off
  // clang-format on
  template <size_t i, typename valueT, typename... out_keysT, typename... out_valuesT,
            ttg::Runtime Runtime = ttg::ttg_runtime>
  inline std::enable_if_t<!meta::is_void_v<std::decay_t<valueT>>, void> sendv(
      valueT &&value, std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    detail::value_copy_handler<Runtime> copy_handler;
    std::get<i>(t).sendv(copy_handler(std::forward<valueT>(value)));
  }
 
  // clang-format off
  // clang-format on
  template <typename valueT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline std::enable_if_t<!meta::is_void_v<std::decay_t<valueT>>, void> sendv(std::size_t i, valueT &&value) {
    // to avoid mixups due to key being a terminal tuple
    static_assert(!meta::is_output_terminal_v<std::decay_t<valueT>> && !meta::is_output_terminal_tuple_v<std::decay_t<valueT>>, "ttg::sendv(i, x) - invalid invocation, x cannot be a terminal or a tuple of terminals; did you mean to call another version of send, e.g. send<i>(x)?");
    detail::value_copy_handler<Runtime> copy_handler;
    auto *terminal_ptr = detail::get_out_terminal<void, valueT>(i, "ttg::sendv(i, value)");
    terminal_ptr->sendv(copy_handler(std::forward<valueT>(value)));
  }
 
  // clang-format off
  // clang-format on
  template <size_t i, typename valueT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline std::enable_if_t<!meta::is_void_v<std::decay_t<valueT>>, void> sendv(valueT &&value) {
    // to avoid mixups due to key being a terminal tuple
    static_assert(!meta::is_output_terminal_v<std::decay_t<valueT>> && !meta::is_output_terminal_tuple_v<std::decay_t<valueT>>, "ttg::sendv<i>(x) - invalid invocation, x cannot be a terminal or a tuple of terminals; did you mean to call another version of send, e.g. send<i>(x)?");
    sendv(i, std::forward<valueT>(value));
  }
 
  // clang-format off
  // clang-format on
  template <size_t i, typename... out_keysT, typename... out_valuesT>
  inline void send(std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    std::get<i>(t).send();
  }
 
  // clang-format off
  // clang-format on
  inline void send(std::size_t i) {
    auto *terminal_ptr = detail::get_out_terminal<void, void>(i, "ttg::send(i)");
    terminal_ptr->send();
  }
 
  // clang-format off
  // clang-format on
  template <size_t i>
  inline void send() {
    send(i);
  }
 
  namespace detail {
    template <size_t KeyId, size_t i, size_t... I, typename... RangesT, typename valueT, typename... out_keysT,
              typename... out_valuesT>
    inline void broadcast(const std::tuple<RangesT...> &keylists, valueT &&value,
                          std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
      if constexpr (ttg::meta::is_iterable_v<std::tuple_element_t<KeyId, std::tuple<RangesT...>>>) {
        if (std::distance(std::begin(std::get<KeyId>(keylists)), std::end(std::get<KeyId>(keylists))) > 0) {
          std::get<i>(t).broadcast(std::get<KeyId>(keylists), value);
        }
      } else {
        std::get<i>(t).broadcast(std::get<KeyId>(keylists), value);
      }
      if constexpr (sizeof...(I) > 0) {
        detail::broadcast<KeyId + 1, I...>(keylists, value, t);
      }
    }
 
    template <size_t KeyId, size_t i, size_t... I, typename... RangesT, typename valueT>
    inline void broadcast(const std::tuple<RangesT...> &keylists, valueT &&value) {
      if constexpr (ttg::meta::is_iterable_v<std::tuple_element_t<KeyId, std::tuple<RangesT...>>>) {
        if (std::distance(std::begin(std::get<KeyId>(keylists)), std::end(std::get<KeyId>(keylists))) > 0) {
          using key_t = decltype(*std::begin(std::get<KeyId>(keylists)));
          auto *terminal_ptr = detail::get_out_terminal<key_t, valueT>(i, "ttg::broadcast(keylists, value)");
          terminal_ptr->broadcast(std::get<KeyId>(keylists), value);
        }
      } else {
        using key_t = decltype(std::get<KeyId>(keylists));
        auto *terminal_ptr = detail::get_out_terminal<key_t, valueT>(i, "ttg::broadcast(keylists, value)");
        terminal_ptr->broadcast(std::get<KeyId>(keylists), value);
      }
      if constexpr (sizeof...(I) > 0) {
        detail::broadcast<KeyId + 1, I...>(keylists, value);
      }
    }
 
    template <size_t KeyId, size_t i, size_t... I, typename... RangesT, typename... out_keysT, typename... out_valuesT>
    inline void broadcast(const std::tuple<RangesT...> &keylists, std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
      if constexpr (ttg::meta::is_iterable_v<std::tuple_element_t<KeyId, std::tuple<RangesT...>>>) {
        if (std::distance(std::begin(std::get<KeyId>(keylists)), std::end(std::get<KeyId>(keylists))) > 0) {
          std::get<i>(t).broadcast(std::get<KeyId>(keylists));
        }
      } else {
        std::get<i>(t).broadcast(std::get<KeyId>(keylists));
      }
      if constexpr (sizeof...(I) > 0) {
        detail::broadcast<KeyId + 1, I...>(keylists, t);
      }
    }
 
    template <size_t KeyId, size_t i, size_t... I, typename... RangesT>
    inline void broadcast(const std::tuple<RangesT...> &keylists) {
      if constexpr (ttg::meta::is_iterable_v<std::tuple_element_t<KeyId, std::tuple<RangesT...>>>) {
        if (std::distance(std::begin(std::get<KeyId>(keylists)), std::end(std::get<KeyId>(keylists))) > 0) {
          using key_t = decltype(*std::begin(std::get<KeyId>(keylists)));
          auto *terminal_ptr = detail::get_out_terminal<key_t, void>(i, "ttg::broadcast(keylists)");
          terminal_ptr->broadcast(std::get<KeyId>(keylists));
        }
      } else {
        using key_t = decltype(std::get<KeyId>(keylists));
        auto *terminal_ptr = detail::get_out_terminal<key_t, void>(i, "ttg::broadcast(keylists)");
        terminal_ptr->broadcast(std::get<KeyId>(keylists));
      }
      if constexpr (sizeof...(I) > 0) {
        detail::broadcast<KeyId + 1, I...>(keylists);
      }
    }
  }  // namespace detail
 
  template <size_t i, typename rangeT, typename valueT, typename... out_keysT, typename... out_valuesT,
            ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcast(const rangeT &keylist, valueT &&value, std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    detail::value_copy_handler<Runtime> copy_handler;
    std::get<i>(t).broadcast(keylist, copy_handler(std::forward<valueT>(value)));
  }
 
  template <typename rangeT, typename valueT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcast(std::size_t i, const rangeT &keylist, valueT &&value) {
    detail::value_copy_handler<Runtime> copy_handler;
    using key_t = decltype(*std::begin(keylist));
    auto *terminal_ptr = detail::get_out_terminal<key_t, valueT>(i, "ttg::broadcast(keylist, value)");
    terminal_ptr->broadcast(keylist, copy_handler(std::forward<valueT>(value)));
  }
 
  template <size_t i, typename rangeT, typename valueT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcast(const rangeT &keylist, valueT &&value) {
    broadcast(i, keylist, std::forward<valueT>(value));
  }
 
  template <size_t i, size_t... I, typename... RangesT, typename valueT, typename... out_keysT, typename... out_valuesT,
            ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcast(const std::tuple<RangesT...> &keylists, valueT &&value,
                        std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    static_assert(sizeof...(I) + 1 == sizeof...(RangesT),
                  "Number of selected output terminals must match the number of keylists!");
    detail::value_copy_handler<Runtime> copy_handler;
    detail::broadcast<0, i, I...>(keylists, copy_handler(std::forward<valueT>(value)), t);
  }
 
  template <size_t i, size_t... I, typename... RangesT, typename valueT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcast(const std::tuple<RangesT...> &keylists, valueT &&value) {
    static_assert(sizeof...(I) + 1 == sizeof...(RangesT),
                  "Number of selected output terminals must match the number of keylists!");
    detail::value_copy_handler<Runtime> copy_handler;
    detail::broadcast<0, i, I...>(keylists, copy_handler(std::forward<valueT>(value)));
  }
 
  template <size_t i, typename rangeT, typename... out_keysT, typename... out_valuesT,
            ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcastk(const rangeT &keylist, std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    std::get<i>(t).broadcast(keylist);
  }
 
  template <typename rangeT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcastk(std::size_t i, const rangeT &keylist) {
    using key_t = decltype(*std::begin(keylist));
    auto *terminal_ptr = detail::get_out_terminal<key_t, void>(i, "ttg::broadcastk(keylist)");
    terminal_ptr->broadcast(keylist);
  }
 
  template <size_t i, typename rangeT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcastk(const rangeT &keylist) {
    broadcastk(i, keylist);
  }
 
  template <size_t i, size_t... I, typename... RangesT, typename... out_keysT, typename... out_valuesT,
            ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcastk(const std::tuple<RangesT...> &keylists, std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    static_assert(sizeof...(I) + 1 == sizeof...(RangesT),
                  "Number of selected output terminals must match the number of keylists!");
    detail::broadcast<0, i, I...>(keylists, t);
  }
 
  template <size_t i, size_t... I, typename... RangesT, ttg::Runtime Runtime = ttg::ttg_runtime>
  inline void broadcastk(const std::tuple<RangesT...> &keylists) {
    static_assert(sizeof...(I) + 1 == sizeof...(RangesT),
                  "Number of selected output terminals must match the number of keylists!");
    detail::broadcast<0, i, I...>(keylists);
  }
 
  template <typename keyT, typename out_valueT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> set_size(const keyT &key, const std::size_t size,
                                                                 ttg::Out<keyT, out_valueT> &t) {
    t.set_size(key, size);
  }
 
  template <size_t i, typename keyT, typename... out_keysT, typename... out_valuesT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> set_size(const keyT &key, const std::size_t size,
                                                                 std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    std::get<i>(t).set_size(key, size);
  }
 
  template <typename keyT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> set_size(std::size_t i, const keyT &key,
                                                                 const std::size_t size) {
    auto *terminal_ptr = detail::get_out_base_terminal<keyT>(i, "ttg::set_size(i, key, size)");
    terminal_ptr->set_size(size);
  }
 
  template <size_t i, typename keyT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> set_size(const keyT &key, const std::size_t size) {
    set_size(i, key, size);
  }
 
  template <typename out_keyT, typename out_valueT>
  inline void set_size(const std::size_t size, ttg::Out<out_keyT, out_valueT> &t) {
    t.set_size(size);
  }
 
  template <size_t i, typename... out_keysT, typename... out_valuesT>
  inline void set_size(const std::size_t size, std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    std::get<i>(t).set_size(size);
  }
 
  inline void set_size(std::size_t i, const std::size_t size) {
    auto *terminal_ptr = detail::get_out_base_terminal<void>(i, "ttg::set_size(i, size)");
    terminal_ptr->set_size(size);
  }
 
  template <std::size_t i>
  inline void set_size(const std::size_t size) {
    set_size(i, size);
  }
 
  template <typename keyT, typename out_keyT, typename out_valueT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> finalize(const keyT &key, ttg::Out<out_keyT, out_valueT> &t) {
    t.finalize(key);
  }
 
  template <size_t i, typename keyT, typename... out_keysT, typename... out_valuesT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> finalize(const keyT &key,
                                                                 std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    std::get<i>(t).finalize(key);
  }
 
  template <typename keyT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> finalize(std::size_t i, const keyT &key) {
    auto *terminal_ptr = detail::get_out_base_terminal<keyT>(i, "ttg::finalize(i, key)");
    terminal_ptr->finalize(key);
  }
 
  template <std::size_t i, typename keyT>
  inline std::enable_if_t<!meta::is_void_v<keyT>, void> finalize(const keyT &key) {
    finalize(i, key);
  }
 
  template <typename out_keyT, typename out_valueT>
  inline void finalize(ttg::Out<out_keyT, out_valueT> &t) {
    t.finalize();
  }
 
  template <size_t i, typename... out_keysT, typename... out_valuesT>
  inline void finalize(std::tuple<ttg::Out<out_keysT, out_valuesT>...> &t) {
    std::get<i>(t).finalize();
  }
 
  inline void finalize(std::size_t i) {
    auto *terminal_ptr = detail::get_out_base_terminal<void>(i, "ttg::finalize(i)");
    terminal_ptr->finalize();
  }
 
  template <std::size_t i>
  inline void finalize() {
    finalize(i);
  }
 
}  // namespace ttg
 
#endif  // TTG_FUNC_H