From cb285cf82447705e7f34f75b06d54cb87df39b48 Mon Sep 17 00:00:00 2001
From: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
Date: Tue, 3 Sep 2024 18:15:10 -0400
Subject: [PATCH 1/6] Consolidate make_tt_tpl and make_tt

We can map make_tt_tpl onto the same mechanism we use for make_tt
by adding a template template parameter that signals whether arguments
are passed as tuple or unpacked.

Signed-off-by: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
---
 ttg/ttg/make_tt.h | 297 ++++++++++++++++------------------------------
 1 file changed, 103 insertions(+), 194 deletions(-)

diff --git a/ttg/ttg/make_tt.h b/ttg/ttg/make_tt.h
index 81897b816..7ba01b56d 100644
--- a/ttg/ttg/make_tt.h
+++ b/ttg/ttg/make_tt.h
@@ -3,127 +3,6 @@
 #ifndef TTG_MAKE_TT_H
 #define TTG_MAKE_TT_H
 
-// Class to wrap a callable with signature
-//
-// case 1 (keyT != void): void op(auto&& key, std::tuple<input_valuesT...>&&, std::tuple<output_terminalsT...>&)
-// case 2 (keyT == void): void op(std::tuple<input_valuesT...>&&, std::tuple<output_terminalsT...>&)
-//
-template <typename funcT, bool funcT_receives_outterm_tuple,
-          typename keyT, typename output_terminalsT,
-          typename... input_valuesT>
-class CallableWrapTT
-    : public TT<keyT, output_terminalsT,
-                CallableWrapTT<funcT, funcT_receives_outterm_tuple, keyT, output_terminalsT, input_valuesT...>,
-                ttg::typelist<input_valuesT...>> {
-  using baseT = typename CallableWrapTT::ttT;
-
-  using input_values_tuple_type = typename baseT::input_values_tuple_type;
-  using input_refs_tuple_type = typename baseT::input_refs_tuple_type;
-  using input_edges_type = typename baseT::input_edges_type;
-  using output_edges_type = typename baseT::output_edges_type;
-
-  using noref_funcT = std::remove_reference_t<funcT>;
-  std::conditional_t<std::is_function_v<noref_funcT>, std::add_pointer_t<noref_funcT>, noref_funcT> func;
-
-  template <typename Key, typename Tuple>
-  void call_func(Key &&key, Tuple &&args, output_terminalsT &out) {
-    if constexpr (funcT_receives_outterm_tuple)
-      func(std::forward<Key>(key), std::forward<Tuple>(args), out);
-    else {
-      auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
-      this->set_outputs_tls_ptr();
-      func(std::forward<Key>(key), std::forward<Tuple>(args));
-      this->set_outputs_tls_ptr(old_output_tls_ptr);
-    }
-  }
-
-  template <typename TupleOrKey>
-  void call_func(TupleOrKey &&args, output_terminalsT &out) {
-    if constexpr (funcT_receives_outterm_tuple)
-      func(std::forward<TupleOrKey>(args), out);
-    else {
-      auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
-      this->set_outputs_tls_ptr();
-      func(std::forward<TupleOrKey>(args));
-      this->set_outputs_tls_ptr(old_output_tls_ptr);
-    }
-  }
-
-  void call_func(output_terminalsT &out) {
-    if constexpr (funcT_receives_outterm_tuple)
-      func(std::tuple<>(), out);
-    else {
-      auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
-      this->set_outputs_tls_ptr();
-      func(std::tuple<>());
-      this->set_outputs_tls_ptr(old_output_tls_ptr);
-    }
-  }
-
- public:
-  template <typename funcT_>
-  CallableWrapTT(funcT_ &&f, const input_edges_type &inedges, const output_edges_type &outedges,
-                 const std::string &name, const std::vector<std::string> &innames,
-                 const std::vector<std::string> &outnames)
-      : baseT(inedges, outedges, name, innames, outnames), func(std::forward<funcT_>(f)) {}
-
-  template <typename funcT_>
-  CallableWrapTT(funcT_ &&f, const std::string &name, const std::vector<std::string> &innames,
-                 const std::vector<std::string> &outnames)
-      : baseT(name, innames, outnames), func(std::forward<funcT_>(f)) {}
-
-  template <typename Key, typename ArgsTuple>
-  std::enable_if_t<std::is_same_v<ArgsTuple, input_refs_tuple_type> && !ttg::meta::is_empty_tuple_v<ArgsTuple> &&
-                       !ttg::meta::is_void_v<Key>,
-                   void>
-  op(Key &&key, ArgsTuple &&args_tuple, output_terminalsT &out) {
-    call_func(std::forward<Key>(key), std::forward<ArgsTuple>(args_tuple), out);
-  }
-
-  template <typename ArgsTuple, typename Key = keyT>
-  std::enable_if_t<std::is_same_v<ArgsTuple, input_refs_tuple_type> && !ttg::meta::is_empty_tuple_v<ArgsTuple> &&
-                       ttg::meta::is_void_v<Key>,
-                   void>
-  op(ArgsTuple &&args_tuple, output_terminalsT &out) {
-    call_func(std::forward<ArgsTuple>(args_tuple), out);
-  }
-
-  template <typename Key, typename ArgsTuple = input_values_tuple_type>
-  std::enable_if_t<ttg::meta::is_empty_tuple_v<ArgsTuple> && !ttg::meta::is_void_v<Key>, void> op(
-      Key &&key, output_terminalsT &out) {
-    call_func(std::forward<Key>(key), out);
-  }
-
-  template <typename Key = keyT, typename ArgsTuple = input_values_tuple_type>
-  std::enable_if_t<ttg::meta::is_empty_tuple_v<ArgsTuple> && ttg::meta::is_void_v<Key>, void> op(
-      output_terminalsT &out) {
-    call_func(out);
-  }
-};
-
-template <typename funcT, bool funcT_receives_outterm_tuple,
-          typename keyT, typename output_terminalsT,
-          typename input_values_tupleT>
-struct CallableWrapTTUnwrapTypelist;
-
-template <typename funcT, bool funcT_receives_outterm_tuple,
-          typename keyT, typename output_terminalsT,
-          typename... input_valuesT>
-struct CallableWrapTTUnwrapTypelist<funcT, funcT_receives_outterm_tuple,
-                                    keyT, output_terminalsT,
-                                    std::tuple<input_valuesT...>> {
-  using type = CallableWrapTT<funcT, funcT_receives_outterm_tuple,
-                              keyT, output_terminalsT,
-                              std::remove_reference_t<input_valuesT>...>;
-};
-
-template <typename funcT, bool funcT_receives_outterm_tuple, typename keyT, typename output_terminalsT,
-          typename... input_valuesT>
-struct CallableWrapTTUnwrapTypelist<funcT, funcT_receives_outterm_tuple, keyT, output_terminalsT,
-                                    ttg::meta::typelist<input_valuesT...>> {
-  using type = CallableWrapTT<funcT, funcT_receives_outterm_tuple, keyT, output_terminalsT,
-                              std::remove_reference_t<input_valuesT>...>;
-};
 
 // Class to wrap a callable with signature
 //
@@ -131,12 +10,13 @@ struct CallableWrapTTUnwrapTypelist<funcT, funcT_receives_outterm_tuple, keyT, o
 // case 2 (keyT == void): returnT op(input_valuesT&&..., std::tuple<output_terminalsT...>&)
 //
 // returnT is void for funcT = synchronous (ordinary) function and the appropriate return type for funcT=coroutine
-template <typename funcT, typename returnT, bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
+template <typename funcT, typename returnT, bool funcT_receives_input_tuple,
+          bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
           typename keyT, typename output_terminalsT, typename... input_valuesT>
 class CallableWrapTTArgs
     : public TT<
           keyT, output_terminalsT,
-          CallableWrapTTArgs<funcT, returnT, funcT_receives_outterm_tuple, space, keyT, output_terminalsT, input_valuesT...>,
+          CallableWrapTTArgs<funcT, returnT, funcT_receives_input_tuple, funcT_receives_outterm_tuple, space, keyT, output_terminalsT, input_valuesT...>,
           ttg::typelist<input_valuesT...>> {
   using baseT = typename CallableWrapTTArgs::ttT;
 
@@ -224,104 +104,105 @@ class CallableWrapTTArgs
   template <typename Key, typename Tuple, std::size_t... S>
   auto call_func(Key &&key, Tuple &&args_tuple, output_terminalsT &out, std::index_sequence<S...>) {
     using func_args_t = ttg::meta::tuple_concat_t<std::tuple<const Key &>, input_refs_tuple_type, output_edges_type>;
-
-    if constexpr (funcT_receives_outterm_tuple) {
+    auto invoke_func_handle_ret = [&](auto&&... args){
       if constexpr (std::is_void_v<returnT>) {
-        func(std::forward<Key>(key),
-             baseT::template get<S, std::tuple_element_t<S + 1, func_args_t>>(std::forward<Tuple>(args_tuple))..., out);
-        return;
+        func(std::forward<Key>(key), std::forward<decltype(args)>(args)...);
       } else {
-        auto ret = func(
-            std::forward<Key>(key),
-            baseT::template get<S, std::tuple_element_t<S + 1, func_args_t>>(std::forward<Tuple>(args_tuple))..., out);
-
-        return process_return(std::move(ret), out);
+        return process_return(func(std::forward<Key>(key), std::forward<decltype(args)>(args)...), out);
+      }
+    };
+    auto unpack_input_tuple_if_needed = [&](auto&&... args){
+      static_assert(!funcT_receives_input_tuple);
+      if constexpr (funcT_receives_input_tuple) {
+        return invoke_func_handle_ret(std::forward<Tuple>(args_tuple), std::forward<decltype(args)>(args)...);
+      } else {
+        return invoke_func_handle_ret(baseT::template get<S, std::tuple_element_t<S + 1, func_args_t>>(std::forward<Tuple>(args_tuple))...,
+                  std::forward<decltype(args)>(args)...);
       }
+    };
+
+    if constexpr (funcT_receives_outterm_tuple) {
+      return unpack_input_tuple_if_needed(out);
     } else {
       auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
       this->set_outputs_tls_ptr();
-      if constexpr (std::is_void_v<returnT>) {
-        func(std::forward<Key>(key),
-             baseT::template get<S, std::tuple_element_t<S + 1, func_args_t>>(std::forward<Tuple>(args_tuple))...);
-        this->set_outputs_tls_ptr(old_output_tls_ptr);
-        return;
-      } else {
-        auto ret =
-            func(std::forward<Key>(key),
-                 baseT::template get<S, std::tuple_element_t<S + 1, func_args_t>>(std::forward<Tuple>(args_tuple))...);
-        this->set_outputs_tls_ptr(old_output_tls_ptr);
-        return process_return(std::move(ret), out);
-      }
+      // make sure the output tls is reset
+      auto _ = ttg::detail::finally([this, old_output_tls_ptr](){ this->set_outputs_tls_ptr(old_output_tls_ptr); });
+      return unpack_input_tuple_if_needed();
     }
   }
 
   template <typename Tuple, std::size_t... S>
   auto call_func(Tuple &&args_tuple, output_terminalsT &out, std::index_sequence<S...>) {
     using func_args_t = ttg::meta::tuple_concat_t<input_refs_tuple_type, output_edges_type>;
-    if constexpr (funcT_receives_outterm_tuple) {
+
+    auto invoke_func_handle_ret = [&](auto&&... args){
       if constexpr (std::is_void_v<returnT>) {
-        func(baseT::template get<S, std::tuple_element_t<S, func_args_t>>(std::forward<Tuple>(args_tuple))..., out);
+        func(std::forward<decltype(args)>(args)...);
+      } else {
+        return process_return(func(std::forward<decltype(args)>(args)...), out);
+      }
+    };
+    auto unpack_input_tuple_if_needed = [&](auto&& fn, auto&&... args){
+      if constexpr (funcT_receives_input_tuple) {
+        return fn(std::forward<Tuple>(args_tuple), std::forward<decltype(args)>(args)...);
       } else {
-        auto ret = func(baseT::template get<S, std::tuple_element_t<S, func_args_t>>(std::forward<Tuple>(args_tuple))..., out);
-        return process_return(std::move(ret), out);
+        return fn(baseT::template get<S, std::tuple_element_t<S + 1, func_args_t>>(std::forward<Tuple>(args_tuple))...,
+                  std::forward<decltype(args)>(args)...);
       }
+    };
+
+    if constexpr (funcT_receives_outterm_tuple) {
+      return unpack_input_tuple_if_needed(invoke_func_handle_ret, out);
     } else {
       auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
       this->set_outputs_tls_ptr();
-      if constexpr (std::is_void_v<returnT>) {
-        func(baseT::template get<S, std::tuple_element_t<S, func_args_t>>(std::forward<Tuple>(args_tuple))...);
-        this->set_outputs_tls_ptr(old_output_tls_ptr);
-      } else {
-        auto ret = func(baseT::template get<S, std::tuple_element_t<S, func_args_t>>(std::forward<Tuple>(args_tuple))...);
-        this->set_outputs_tls_ptr(old_output_tls_ptr);
-        return process_return(std::move(ret), out);
-      }
+      // make sure the output tls is reset
+      auto _ = ttg::detail::finally([this, old_output_tls_ptr](){ this->set_outputs_tls_ptr(old_output_tls_ptr); });
+      return unpack_input_tuple_if_needed(invoke_func_handle_ret);
     }
   }
 
   template <typename Key>
   auto call_func(Key &&key, output_terminalsT &out) {
-    if constexpr (funcT_receives_outterm_tuple) {
+    auto invoke_func_handle_ret = [&](auto&&... args){
       if constexpr (std::is_void_v<returnT>) {
-        func(std::forward<Key>(key), out);
+        func(std::forward<Key>(key), std::forward<decltype(args)>(args)...);
       } else {
-        auto ret = func(std::forward<Key>(key), out);
-        return process_return(std::move(ret), out);
+        return process_return(func(std::forward<Key>(key), std::forward<decltype(args)>(args)...), out);
       }
+    };
+
+    if constexpr (funcT_receives_outterm_tuple) {
+      invoke_func_handle_ret(out);
     } else {
       auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
       this->set_outputs_tls_ptr();
-      if constexpr (std::is_void_v<returnT>) {
-        func(std::forward<Key>(key));
-        this->set_outputs_tls_ptr(old_output_tls_ptr);
-      } else {
-        auto ret = func(std::forward<Key>(key));
-        this->set_outputs_tls_ptr(old_output_tls_ptr);
-        return process_return(std::move(ret), out);
-      }
+      // make sure the output tls is reset
+      auto _ = ttg::detail::finally([this, old_output_tls_ptr](){ this->set_outputs_tls_ptr(old_output_tls_ptr); });
+      return invoke_func_handle_ret();
     }
   }
 
   template <typename OutputTerminals>
   auto call_func(OutputTerminals &out) {
-    if constexpr (funcT_receives_outterm_tuple) {
+
+    auto invoke_func_handle_ret = [&](auto&&... args){
       if constexpr (std::is_void_v<returnT>) {
-        func(out);
+        func(std::forward<decltype(args)>(args)...);
       } else {
-        auto ret = func(out);
-        return process_return(std::move(ret), out);
+        return process_return(func(std::forward<decltype(args)>(args)...), out);
       }
+    };
+
+    if constexpr (funcT_receives_outterm_tuple) {
+      return invoke_func_handle_ret(out);
     } else {
       auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
       this->set_outputs_tls_ptr();
-      if constexpr (std::is_void_v<returnT>) {
-        func();
-        this->set_outputs_tls_ptr(old_output_tls_ptr);
-      } else {
-        auto ret = func(out);
-        this->set_outputs_tls_ptr(old_output_tls_ptr);
-        return process_return(std::move(ret), out);
-      }
+      // make sure the output tls is reset
+      auto _ = ttg::detail::finally([this, old_output_tls_ptr](){ this->set_outputs_tls_ptr(old_output_tls_ptr); });
+      return invoke_func_handle_ret();
     }
   }
 
@@ -378,23 +259,30 @@ class CallableWrapTTArgs
   };
 };
 
-template <typename funcT, typename returnT, bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
+template <typename funcT, typename returnT, bool funcT_receives_input_tuple,
+          bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
           typename keyT, typename output_terminalsT, typename input_values_typelistT>
 struct CallableWrapTTArgsAsTypelist;
 
-template <typename funcT, typename returnT, bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
+template <typename funcT, typename returnT, bool funcT_receives_input_tuple,
+          bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
           typename keyT, typename output_terminalsT, typename... input_valuesT>
-struct CallableWrapTTArgsAsTypelist<funcT, returnT, funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
+struct CallableWrapTTArgsAsTypelist<funcT, returnT, funcT_receives_input_tuple,
+                                    funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
                                     std::tuple<input_valuesT...>> {
-  using type = CallableWrapTTArgs<funcT, returnT, funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
+  using type = CallableWrapTTArgs<funcT, returnT, funcT_receives_input_tuple,
+                                  funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
                                   std::remove_reference_t<input_valuesT>...>;
 };
 
-template <typename funcT, typename returnT, bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
+template <typename funcT, typename returnT, bool funcT_receives_input_tuple,
+          bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
           typename keyT, typename output_terminalsT, typename... input_valuesT>
-struct CallableWrapTTArgsAsTypelist<funcT, returnT, funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
+struct CallableWrapTTArgsAsTypelist<funcT, returnT, funcT_receives_input_tuple,
+                                    funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
                                     ttg::meta::typelist<input_valuesT...>> {
-  using type = CallableWrapTTArgs<funcT, returnT, funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
+  using type = CallableWrapTTArgs<funcT, returnT, funcT_receives_input_tuple,
+                                  funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
                                   std::remove_reference_t<input_valuesT>...>;
 };
 
@@ -425,7 +313,11 @@ struct CallableWrapTTArgsAsTypelist<funcT, returnT, funcT_receives_outterm_tuple
 ///
 /// @note Handling of generic @p func is described in the documentation of make_tt()
 // clang-format on
-template <typename keyT = void, typename funcT, typename... input_edge_valuesT, typename... output_edgesT>
+template <ttg::ExecutionSpace space,
+          typename keyT = void,
+          typename funcT,
+          typename... input_edge_valuesT,
+          typename... output_edgesT>
 auto make_tt_tpl(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_valuesT>...> &inedges = std::tuple<>{},
                  const std::tuple<output_edgesT...> &outedges = std::tuple<>{}, const std::string &name = "wrapper",
                  const std::vector<std::string> &innames = std::vector<std::string>(sizeof...(input_edge_valuesT),
@@ -446,14 +338,17 @@ auto make_tt_tpl(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_value
       ttg::meta::candidate_argument_bindings_t<std::add_const_t<keyT>>,
       ttg::meta::candidate_argument_bindings_t<
           std::tuple<std::add_lvalue_reference_t<typename ttg::Edge<keyT, input_edge_valuesT>::value_type>...>>,
-      ttg::meta::typelist<output_terminals_type &, void>>;
+      ttg::meta::typelist<output_terminals_type &>>;
 
   // net list of candidate argument types excludes the empty typelists for void arguments
   using candidate_func_args_t = ttg::meta::filter_t<gross_candidate_func_args_t, ttg::meta::typelist_is_not_empty>;
 
   // compute list of argument types with which func can be invoked
   constexpr static auto func_is_generic = ttg::meta::is_generic_callable_v<funcT>;
-  using gross_func_args_t = decltype(ttg::meta::compute_arg_binding_types_r<void>(func, candidate_func_args_t{}));
+  using return_type_typelist_and_gross_func_args_t =
+      decltype(ttg::meta::compute_arg_binding_types(func, candidate_func_args_t{}));
+  using func_return_t = std::tuple_element_t<0, std::tuple_element_t<0, return_type_typelist_and_gross_func_args_t>>;
+  using gross_func_args_t = std::tuple_element_t<1, return_type_typelist_and_gross_func_args_t>;
   constexpr auto DETECTED_HOW_TO_INVOKE_GENERIC_FUNC =
       func_is_generic ? !std::is_same_v<gross_func_args_t, ttg::typelist<>> : true;
   static_assert(DETECTED_HOW_TO_INVOKE_GENERIC_FUNC,
@@ -499,14 +394,28 @@ auto make_tt_tpl(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_value
       "ref; this is illegal, should only pass arguments as const lvalue ref or (nonconst) rvalue ref");
   using input_args_t = std::decay_t<nondecayed_input_args_t>;
   using decayed_input_args_t = ttg::meta::decayed_typelist_t<input_args_t>;
-  using wrapT =
-      typename CallableWrapTTUnwrapTypelist<funcT, have_outterm_tuple, keyT, output_terminals_type, input_args_t>::type;
+  using wrapT = typename CallableWrapTTArgsAsTypelist<funcT, func_return_t, false, have_outterm_tuple, space, keyT,
+                                                      output_terminals_type, input_args_t>::type;
   static_assert(std::is_same_v<decayed_input_args_t, std::tuple<input_edge_valuesT...>>,
                 "ttg::make_tt_tpl(func, inedges, outedges): inedges value types do not match argument types of func");
 
   return std::make_unique<wrapT>(std::forward<funcT>(func), inedges, outedges, name, innames, outnames);
 }
 
+template <typename keyT = void,
+          typename funcT,
+          typename... input_edge_valuesT,
+          typename... output_edgesT>
+auto make_tt_tpl(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_valuesT>...> &inedges = std::tuple<>{},
+                 const std::tuple<output_edgesT...> &outedges = std::tuple<>{}, const std::string &name = "wrapper",
+                 const std::vector<std::string> &innames = std::vector<std::string>(sizeof...(input_edge_valuesT),
+                                                                                    "input"),
+                 const std::vector<std::string> &outnames = std::vector<std::string>(sizeof...(output_edgesT),
+                                                                                     "output"))
+{
+  return make_tt_tpl<ttg::ExecutionSpace::Host, keyT, funcT, input_edge_valuesT..., output_edgesT...>(
+      std::forward<funcT>(func), inedges, outedges, name, innames, outnames);
+}
 // clang-format off
 /// @brief Factory function to assist in wrapping a callable with signature
 ///
@@ -631,7 +540,7 @@ auto make_tt(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_valuesT>.
   using decayed_input_args_t = ttg::meta::decayed_typelist_t<input_args_t>;
   // 3. full_input_args_t = edge-types with non-void types replaced by input_args_t
   using full_input_args_t = ttg::meta::replace_nonvoid_t<input_edge_value_types, input_args_t>;
-  using wrapT = typename CallableWrapTTArgsAsTypelist<funcT, func_return_t, have_outterm_tuple, space, keyT,
+  using wrapT = typename CallableWrapTTArgsAsTypelist<funcT, func_return_t, false, have_outterm_tuple, space, keyT,
                                                       output_terminals_type, full_input_args_t>::type;
 
   return std::make_unique<wrapT>(std::forward<funcT>(func), inedges, outedges, name, innames, outnames);

From 81abc565b4924fb81aa5c2be36f08eee18c0fb05 Mon Sep 17 00:00:00 2001
From: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
Date: Tue, 29 Oct 2024 19:30:14 -0400
Subject: [PATCH 2/6] Add ttg::detail::finally, taken from GSL

Signed-off-by: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
---
 ttg/ttg/util/finally.h | 57 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 ttg/ttg/util/finally.h

diff --git a/ttg/ttg/util/finally.h b/ttg/ttg/util/finally.h
new file mode 100644
index 000000000..d37a94dc3
--- /dev/null
+++ b/ttg/ttg/util/finally.h
@@ -0,0 +1,57 @@
+#ifndef TTG_UTIL_FINALLY_H
+#define TTG_UTIL_FINALLY_H
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+namespace ttg::detail {
+
+    /* finally, taken from GSL: https://github.com/microsoft/GSL */
+
+    // final_action allows you to ensure something gets run at the end of a scope
+    template <class F>
+    class final_action
+    {
+    public:
+        explicit final_action(const F& ff) noexcept : f{ff} { }
+        explicit final_action(F&& ff) noexcept : f{std::move(ff)} { }
+
+        ~final_action() noexcept { if (invoke) f(); }
+
+        final_action(final_action&& other) noexcept
+            : f(std::move(other.f)), invoke(std::exchange(other.invoke, false))
+        { }
+
+        final_action(const final_action&)   = delete;
+        void operator=(const final_action&) = delete;
+        void operator=(final_action&&)      = delete;
+
+    private:
+        F f;
+        bool invoke = true;
+    };
+
+
+    // finally() - convenience function to generate a final_action
+    template <class F>
+    [[nodiscard]] auto finally(F&& f) noexcept
+    {
+        return final_action<std::decay_t<F>>{std::forward<F>(f)};
+    }
+
+} // namespace ttg::detail
+
+#endif // TTG_UTIL_FINALLY_H

From 899ba186ee37b4195e6f89c22bd8db523da8d09d Mon Sep 17 00:00:00 2001
From: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
Date: Wed, 30 Oct 2024 10:22:47 -0400
Subject: [PATCH 3/6] Replace finally with scope_exit

Signed-off-by: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
---
 ttg/CMakeLists.txt        |  1 +
 ttg/ttg/madness/ttg.h     |  1 +
 ttg/ttg/make_tt.h         | 20 +++++++++++---
 ttg/ttg/parsec/ttg.h      |  1 +
 ttg/ttg/util/finally.h    | 57 --------------------------------------
 ttg/ttg/util/scope_exit.h | 58 +++++++++++++++++++++++++++++++++++++++
 6 files changed, 77 insertions(+), 61 deletions(-)
 delete mode 100644 ttg/ttg/util/finally.h
 create mode 100644 ttg/ttg/util/scope_exit.h

diff --git a/ttg/CMakeLists.txt b/ttg/CMakeLists.txt
index b1fa72947..272f005ab 100644
--- a/ttg/CMakeLists.txt
+++ b/ttg/CMakeLists.txt
@@ -22,6 +22,7 @@ set(ttg-util-headers
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/util/meta.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/util/meta/callable.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/util/print.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/ttg/util/scope_exit.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/util/span.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/util/trace.h
         ${CMAKE_CURRENT_SOURCE_DIR}/ttg/util/tree.h
diff --git a/ttg/ttg/madness/ttg.h b/ttg/ttg/madness/ttg.h
index 5d2360cfb..85dee437f 100644
--- a/ttg/ttg/madness/ttg.h
+++ b/ttg/ttg/madness/ttg.h
@@ -22,6 +22,7 @@
 #include "ttg/util/macro.h"
 #include "ttg/util/meta.h"
 #include "ttg/util/meta/callable.h"
+#include "ttg/util/scope_exit.h"
 #include "ttg/util/void.h"
 #include "ttg/world.h"
 #include "ttg/coroutine.h"
diff --git a/ttg/ttg/make_tt.h b/ttg/ttg/make_tt.h
index 7ba01b56d..97e6dfccc 100644
--- a/ttg/ttg/make_tt.h
+++ b/ttg/ttg/make_tt.h
@@ -127,7 +127,10 @@ class CallableWrapTTArgs
       auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
       this->set_outputs_tls_ptr();
       // make sure the output tls is reset
-      auto _ = ttg::detail::finally([this, old_output_tls_ptr](){ this->set_outputs_tls_ptr(old_output_tls_ptr); });
+      auto _ = ttg::detail::scope_exit(
+        [this, old_output_tls_ptr](){
+          this->set_outputs_tls_ptr(old_output_tls_ptr);
+        });
       return unpack_input_tuple_if_needed();
     }
   }
@@ -158,7 +161,10 @@ class CallableWrapTTArgs
       auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
       this->set_outputs_tls_ptr();
       // make sure the output tls is reset
-      auto _ = ttg::detail::finally([this, old_output_tls_ptr](){ this->set_outputs_tls_ptr(old_output_tls_ptr); });
+      auto _ = ttg::detail::scope_exit(
+        [this, old_output_tls_ptr](){
+          this->set_outputs_tls_ptr(old_output_tls_ptr);
+        });
       return unpack_input_tuple_if_needed(invoke_func_handle_ret);
     }
   }
@@ -179,7 +185,10 @@ class CallableWrapTTArgs
       auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
       this->set_outputs_tls_ptr();
       // make sure the output tls is reset
-      auto _ = ttg::detail::finally([this, old_output_tls_ptr](){ this->set_outputs_tls_ptr(old_output_tls_ptr); });
+      auto _ = ttg::detail::scope_exit(
+        [this, old_output_tls_ptr](){
+          this->set_outputs_tls_ptr(old_output_tls_ptr);
+        });
       return invoke_func_handle_ret();
     }
   }
@@ -201,7 +210,10 @@ class CallableWrapTTArgs
       auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
       this->set_outputs_tls_ptr();
       // make sure the output tls is reset
-      auto _ = ttg::detail::finally([this, old_output_tls_ptr](){ this->set_outputs_tls_ptr(old_output_tls_ptr); });
+      auto _ = ttg::detail::scope_exit(
+        [this, old_output_tls_ptr](){
+          this->set_outputs_tls_ptr(old_output_tls_ptr);
+        });
       return invoke_func_handle_ret();
     }
   }
diff --git a/ttg/ttg/parsec/ttg.h b/ttg/ttg/parsec/ttg.h
index 0a0ddefcb..2fc62bd91 100644
--- a/ttg/ttg/parsec/ttg.h
+++ b/ttg/ttg/parsec/ttg.h
@@ -33,6 +33,7 @@
 #include "ttg/util/meta.h"
 #include "ttg/util/meta/callable.h"
 #include "ttg/util/print.h"
+#include "ttg/util/scope_exit.h"
 #include "ttg/util/trace.h"
 #include "ttg/util/typelist.h"
 #ifdef TTG_HAVE_DEVICE
diff --git a/ttg/ttg/util/finally.h b/ttg/ttg/util/finally.h
deleted file mode 100644
index d37a94dc3..000000000
--- a/ttg/ttg/util/finally.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef TTG_UTIL_FINALLY_H
-#define TTG_UTIL_FINALLY_H
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-namespace ttg::detail {
-
-    /* finally, taken from GSL: https://github.com/microsoft/GSL */
-
-    // final_action allows you to ensure something gets run at the end of a scope
-    template <class F>
-    class final_action
-    {
-    public:
-        explicit final_action(const F& ff) noexcept : f{ff} { }
-        explicit final_action(F&& ff) noexcept : f{std::move(ff)} { }
-
-        ~final_action() noexcept { if (invoke) f(); }
-
-        final_action(final_action&& other) noexcept
-            : f(std::move(other.f)), invoke(std::exchange(other.invoke, false))
-        { }
-
-        final_action(const final_action&)   = delete;
-        void operator=(const final_action&) = delete;
-        void operator=(final_action&&)      = delete;
-
-    private:
-        F f;
-        bool invoke = true;
-    };
-
-
-    // finally() - convenience function to generate a final_action
-    template <class F>
-    [[nodiscard]] auto finally(F&& f) noexcept
-    {
-        return final_action<std::decay_t<F>>{std::forward<F>(f)};
-    }
-
-} // namespace ttg::detail
-
-#endif // TTG_UTIL_FINALLY_H
diff --git a/ttg/ttg/util/scope_exit.h b/ttg/ttg/util/scope_exit.h
new file mode 100644
index 000000000..5e5fe6722
--- /dev/null
+++ b/ttg/ttg/util/scope_exit.h
@@ -0,0 +1,58 @@
+#ifndef TTG_UTIL_SCOPE_EXIT_H
+#define TTG_UTIL_SCOPE_EXIT_H
+
+//
+// N4189: Scoped Resource - Generic RAII Wrapper for the Standard Library
+// Peter Sommerlad and Andrew L. Sandoval
+// Adopted from https://github.com/tandasat/ScopedResource/tree/master
+//
+
+#include <type_traits>
+
+namespace ttg::detail {
+  template <typename EF>
+  struct scope_exit
+  {
+    // construction
+    explicit
+    scope_exit(EF &&f)
+    : exit_function(std::move(f))
+    , execute_on_destruction{ true }
+    { }
+
+    // move
+    scope_exit(scope_exit &&rhs)
+    : exit_function(std::move(rhs.exit_function))
+    , execute_on_destruction{ rhs.execute_on_destruction }
+    {
+      rhs.release();
+    }
+
+    // release
+    ~scope_exit()
+    {
+      if (execute_on_destruction) this->exit_function();
+    }
+
+    void release()
+    {
+      this->execute_on_destruction = false;
+    }
+
+  private:
+    scope_exit(scope_exit const &) = delete;
+    void operator=(scope_exit const &) = delete;
+    scope_exit& operator=(scope_exit &&) = delete;
+    EF exit_function;
+    bool execute_on_destruction; // exposition only
+  };
+
+  template <typename EF>
+  auto make_scope_exit(EF &&exit_function)
+  {
+    return scope_exit<std::remove_reference_t<EF>>(std::forward<EF>(exit_function));
+  }
+
+} // namespace ttg::detail
+
+#endif // TTG_UTIL_SCOPE_EXIT_H
\ No newline at end of file

From fb55a37a6623bc3124211725f04a3425bb83b3e6 Mon Sep 17 00:00:00 2001
From: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
Date: Wed, 30 Oct 2024 10:23:09 -0400
Subject: [PATCH 4/6] Fix tuple_element index in make_tt

Signed-off-by: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
---
 ttg/ttg/make_tt.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ttg/ttg/make_tt.h b/ttg/ttg/make_tt.h
index 97e6dfccc..f999677d6 100644
--- a/ttg/ttg/make_tt.h
+++ b/ttg/ttg/make_tt.h
@@ -150,7 +150,7 @@ class CallableWrapTTArgs
       if constexpr (funcT_receives_input_tuple) {
         return fn(std::forward<Tuple>(args_tuple), std::forward<decltype(args)>(args)...);
       } else {
-        return fn(baseT::template get<S, std::tuple_element_t<S + 1, func_args_t>>(std::forward<Tuple>(args_tuple))...,
+        return fn(baseT::template get<S, std::tuple_element_t<S, func_args_t>>(std::forward<Tuple>(args_tuple))...,
                   std::forward<decltype(args)>(args)...);
       }
     };

From 70a1f0e024852ee078d5f07b1272f1e307ef101f Mon Sep 17 00:00:00 2001
From: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
Date: Wed, 30 Oct 2024 12:06:21 -0400
Subject: [PATCH 5/6] make_tt: fixes for passing empty tuple to callback

Signed-off-by: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
---
 ttg/ttg/make_tt.h | 25 ++++++++++++++++++++-----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/ttg/ttg/make_tt.h b/ttg/ttg/make_tt.h
index f999677d6..5f49edfd8 100644
--- a/ttg/ttg/make_tt.h
+++ b/ttg/ttg/make_tt.h
@@ -112,7 +112,6 @@ class CallableWrapTTArgs
       }
     };
     auto unpack_input_tuple_if_needed = [&](auto&&... args){
-      static_assert(!funcT_receives_input_tuple);
       if constexpr (funcT_receives_input_tuple) {
         return invoke_func_handle_ret(std::forward<Tuple>(args_tuple), std::forward<decltype(args)>(args)...);
       } else {
@@ -179,6 +178,14 @@ class CallableWrapTTArgs
       }
     };
 
+    auto invoke_func_empty_tuple = [&](auto&&... args){
+      if constexpr(funcT_receives_input_tuple) {
+        invoke_func_handle_ret(std::tuple<>{}, std::forward<decltype(args)>(args)...);
+      } else {
+        invoke_func_handle_ret(std::forward<decltype(args)>(args)...);
+      }
+    };
+
     if constexpr (funcT_receives_outterm_tuple) {
       invoke_func_handle_ret(out);
     } else {
@@ -204,8 +211,16 @@ class CallableWrapTTArgs
       }
     };
 
+    auto invoke_func_empty_tuple = [&](auto&&... args){
+      if constexpr(funcT_receives_input_tuple) {
+        invoke_func_handle_ret(std::tuple<>{}, std::forward<decltype(args)>(args)...);
+      } else {
+        invoke_func_handle_ret(std::forward<decltype(args)>(args)...);
+      }
+    };
+
     if constexpr (funcT_receives_outterm_tuple) {
-      return invoke_func_handle_ret(out);
+      return invoke_func_empty_tuple(out);
     } else {
       auto old_output_tls_ptr = this->outputs_tls_ptr_accessor();
       this->set_outputs_tls_ptr();
@@ -214,7 +229,7 @@ class CallableWrapTTArgs
         [this, old_output_tls_ptr](){
           this->set_outputs_tls_ptr(old_output_tls_ptr);
         });
-      return invoke_func_handle_ret();
+      return invoke_func_empty_tuple();
     }
   }
 
@@ -406,7 +421,7 @@ auto make_tt_tpl(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_value
       "ref; this is illegal, should only pass arguments as const lvalue ref or (nonconst) rvalue ref");
   using input_args_t = std::decay_t<nondecayed_input_args_t>;
   using decayed_input_args_t = ttg::meta::decayed_typelist_t<input_args_t>;
-  using wrapT = typename CallableWrapTTArgsAsTypelist<funcT, func_return_t, false, have_outterm_tuple, space, keyT,
+  using wrapT = typename CallableWrapTTArgsAsTypelist<funcT, func_return_t, true, have_outterm_tuple, space, keyT,
                                                       output_terminals_type, input_args_t>::type;
   static_assert(std::is_same_v<decayed_input_args_t, std::tuple<input_edge_valuesT...>>,
                 "ttg::make_tt_tpl(func, inedges, outedges): inedges value types do not match argument types of func");
@@ -425,7 +440,7 @@ auto make_tt_tpl(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_value
                  const std::vector<std::string> &outnames = std::vector<std::string>(sizeof...(output_edgesT),
                                                                                      "output"))
 {
-  return make_tt_tpl<ttg::ExecutionSpace::Host, keyT, funcT, input_edge_valuesT..., output_edgesT...>(
+  return make_tt_tpl<ttg::ExecutionSpace::Host, keyT>(
       std::forward<funcT>(func), inedges, outedges, name, innames, outnames);
 }
 // clang-format off

From 19c23c43514a5eeb479efc521616d2c061211e7b Mon Sep 17 00:00:00 2001
From: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
Date: Thu, 31 Oct 2024 09:02:58 -0400
Subject: [PATCH 6/6] Rename CallableWrapTTArgs to CallableWrapTT and fix
 mrattg example

Signed-off-by: Joseph Schuchart <joseph.schuchart@stonybrook.edu>
---
 examples/madness/mrattg.cc | 12 ++++++++----
 ttg/ttg/make_tt.h          | 32 ++++++++++++++++----------------
 2 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/examples/madness/mrattg.cc b/examples/madness/mrattg.cc
index 2341ba864..8fcc2c6a9 100644
--- a/examples/madness/mrattg.cc
+++ b/examples/madness/mrattg.cc
@@ -177,7 +177,8 @@ namespace detail {
     using compress_out_type = std::tuple<Rout, Rout, cnodeOut<T, K, 1>>;
     using compress_in_type = std::tuple<Rin, Rin>;
     template <typename compfuncT>
-    using compwrap_type = ttg::CallableWrapTT<compfuncT, true, Key<1>, compress_out_type, Rin, Rin>;
+    using compwrap_type = ttg::CallableWrapTT<compfuncT, void, true, true, ttg::ExecutionSpace::Host,
+                                              Key<1>, compress_out_type, Rin, Rin>;
   };
 
   template <typename T, size_t K>
@@ -187,7 +188,8 @@ namespace detail {
     using compress_out_type = std::tuple<Rout, Rout, Rout, Rout, cnodeOut<T, K, 2>>;
     using compress_in_type = std::tuple<Rin, Rin, Rin, Rin>;
     template <typename compfuncT>
-    using compwrap_type = ttg::CallableWrapTT<compfuncT, true, Key<2>, compress_out_type, Rin, Rin, Rin, Rin>;
+    using compwrap_type = ttg::CallableWrapTT<compfuncT, void, true, true, ttg::ExecutionSpace::Host,
+                                              Key<2>, compress_out_type, Rin, Rin, Rin, Rin>;
   };
 
   template <typename T, size_t K>
@@ -198,7 +200,8 @@ namespace detail {
     using compress_in_type = std::tuple<Rin, Rin, Rin, Rin, Rin, Rin, Rin, Rin>;
     template <typename compfuncT>
     using compwrap_type =
-        ttg::CallableWrapTT<compfuncT, true, Key<3>, compress_out_type, Rin, Rin, Rin, Rin, Rin, Rin, Rin, Rin>;
+        ttg::CallableWrapTT<compfuncT, void, true, true, ttg::ExecutionSpace::Host,
+                            Key<3>, compress_out_type, Rin, Rin, Rin, Rin, Rin, Rin, Rin, Rin>;
   };
 };  // namespace detail
 
@@ -277,7 +280,8 @@ auto make_compress(rnodeEdge<T, K, NDIM>& in, cnodeEdge<T, K, NDIM>& out, const
 
   using sendfuncT = decltype(&send_leaves_up<T, K, NDIM>);
   using sendwrapT =
-      ttg::CallableWrapTT<sendfuncT, true, Key<NDIM>, typename ::detail::tree_types<T, K, NDIM>::compress_out_type,
+      ttg::CallableWrapTT<sendfuncT, void, true, true, ttg::ExecutionSpace::Host,
+                          Key<NDIM>, typename ::detail::tree_types<T, K, NDIM>::compress_out_type,
                           FunctionReconstructedNode<T, K, NDIM>>;
   using compfuncT = decltype(&do_compress<T, K, NDIM>);
   using compwrapT = typename ::detail::tree_types<T, K, NDIM>::template compwrap_type<compfuncT>;
diff --git a/ttg/ttg/make_tt.h b/ttg/ttg/make_tt.h
index 5f49edfd8..d3912576a 100644
--- a/ttg/ttg/make_tt.h
+++ b/ttg/ttg/make_tt.h
@@ -13,12 +13,12 @@
 template <typename funcT, typename returnT, bool funcT_receives_input_tuple,
           bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
           typename keyT, typename output_terminalsT, typename... input_valuesT>
-class CallableWrapTTArgs
+class CallableWrapTT
     : public TT<
           keyT, output_terminalsT,
-          CallableWrapTTArgs<funcT, returnT, funcT_receives_input_tuple, funcT_receives_outterm_tuple, space, keyT, output_terminalsT, input_valuesT...>,
+          CallableWrapTT<funcT, returnT, funcT_receives_input_tuple, funcT_receives_outterm_tuple, space, keyT, output_terminalsT, input_valuesT...>,
           ttg::typelist<input_valuesT...>> {
-  using baseT = typename CallableWrapTTArgs::ttT;
+  using baseT = typename CallableWrapTT::ttT;
 
   using input_values_tuple_type = typename baseT::input_values_tuple_type;
   using input_refs_tuple_type = typename baseT::input_refs_tuple_type;
@@ -54,7 +54,7 @@ class CallableWrapTTArgs
   template<typename ReturnT>
   auto process_return(ReturnT&& ret, output_terminalsT &out) {
     static_assert(std::is_same_v<std::remove_reference_t<decltype(ret)>, returnT>,
-                  "CallableWrapTTArgs<funcT,returnT,...>: returnT does not match the actual return type of funcT");
+                  "CallableWrapTT<funcT,returnT,...>: returnT does not match the actual return type of funcT");
     if constexpr (!std::is_void_v<returnT>) {  // protect from compiling for void returnT
 #ifdef TTG_HAVE_COROUTINE
       if constexpr (std::is_same_v<returnT, ttg::resumable_task>) {
@@ -83,10 +83,10 @@ class CallableWrapTTArgs
 #endif
       {
         static_assert(std::tuple_size_v<std::remove_reference_t<decltype(out)>> == 1,
-                      "CallableWrapTTArgs<funcT,returnT,funcT_receives_outterm_tuple=true,...): funcT can return a "
+                      "CallableWrapTT<funcT,returnT,funcT_receives_outterm_tuple=true,...): funcT can return a "
                       "value only if there is only 1 out terminal");
         static_assert(std::tuple_size_v<returnT> <= 2,
-                      "CallableWrapTTArgs<funcT,returnT,funcT_receives_outterm_tuple=true,...): funcT can return a "
+                      "CallableWrapTT<funcT,returnT,funcT_receives_outterm_tuple=true,...): funcT can return a "
                       "value only if it is a plain value (then sent with null key), a tuple-like containing a single "
                       "key (hence value is void), or a tuple-like containing a key and a value");
         if constexpr (std::tuple_size_v<returnT> == 0)
@@ -241,13 +241,13 @@ class CallableWrapTTArgs
 
  public:
   template <typename funcT_>
-  CallableWrapTTArgs(funcT_ &&f, const input_edges_type &inedges, const typename baseT::output_edges_type &outedges,
+  CallableWrapTT(funcT_ &&f, const input_edges_type &inedges, const typename baseT::output_edges_type &outedges,
                      const std::string &name, const std::vector<std::string> &innames,
                      const std::vector<std::string> &outnames)
       : baseT(inedges, outedges, name, innames, outnames), func(std::forward<funcT_>(f)) {}
 
   template <typename funcT_>
-  CallableWrapTTArgs(funcT_ &&f, const std::string &name, const std::vector<std::string> &innames,
+  CallableWrapTT(funcT_ &&f, const std::string &name, const std::vector<std::string> &innames,
                      const std::vector<std::string> &outnames)
       : baseT(name, innames, outnames), func(std::forward<funcT_>(f)) {}
 
@@ -289,15 +289,15 @@ class CallableWrapTTArgs
 template <typename funcT, typename returnT, bool funcT_receives_input_tuple,
           bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
           typename keyT, typename output_terminalsT, typename input_values_typelistT>
-struct CallableWrapTTArgsAsTypelist;
+struct CallableWrapTTAsTypelist;
 
 template <typename funcT, typename returnT, bool funcT_receives_input_tuple,
           bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
           typename keyT, typename output_terminalsT, typename... input_valuesT>
-struct CallableWrapTTArgsAsTypelist<funcT, returnT, funcT_receives_input_tuple,
+struct CallableWrapTTAsTypelist<funcT, returnT, funcT_receives_input_tuple,
                                     funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
                                     std::tuple<input_valuesT...>> {
-  using type = CallableWrapTTArgs<funcT, returnT, funcT_receives_input_tuple,
+  using type = CallableWrapTT<funcT, returnT, funcT_receives_input_tuple,
                                   funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
                                   std::remove_reference_t<input_valuesT>...>;
 };
@@ -305,10 +305,10 @@ struct CallableWrapTTArgsAsTypelist<funcT, returnT, funcT_receives_input_tuple,
 template <typename funcT, typename returnT, bool funcT_receives_input_tuple,
           bool funcT_receives_outterm_tuple, ttg::ExecutionSpace space,
           typename keyT, typename output_terminalsT, typename... input_valuesT>
-struct CallableWrapTTArgsAsTypelist<funcT, returnT, funcT_receives_input_tuple,
+struct CallableWrapTTAsTypelist<funcT, returnT, funcT_receives_input_tuple,
                                     funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
                                     ttg::meta::typelist<input_valuesT...>> {
-  using type = CallableWrapTTArgs<funcT, returnT, funcT_receives_input_tuple,
+  using type = CallableWrapTT<funcT, returnT, funcT_receives_input_tuple,
                                   funcT_receives_outterm_tuple, space, keyT, output_terminalsT,
                                   std::remove_reference_t<input_valuesT>...>;
 };
@@ -421,7 +421,7 @@ auto make_tt_tpl(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_value
       "ref; this is illegal, should only pass arguments as const lvalue ref or (nonconst) rvalue ref");
   using input_args_t = std::decay_t<nondecayed_input_args_t>;
   using decayed_input_args_t = ttg::meta::decayed_typelist_t<input_args_t>;
-  using wrapT = typename CallableWrapTTArgsAsTypelist<funcT, func_return_t, true, have_outterm_tuple, space, keyT,
+  using wrapT = typename CallableWrapTTAsTypelist<funcT, func_return_t, true, have_outterm_tuple, space, keyT,
                                                       output_terminals_type, input_args_t>::type;
   static_assert(std::is_same_v<decayed_input_args_t, std::tuple<input_edge_valuesT...>>,
                 "ttg::make_tt_tpl(func, inedges, outedges): inedges value types do not match argument types of func");
@@ -552,7 +552,7 @@ auto make_tt(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_valuesT>.
       OUTTERM_TUPLE_PASSED_AS_NONCONST_LVALUE_REF,
       "ttg::make_tt(func, ...): if given to func, the output terminal tuple must be passed by nonconst lvalue ref");
 
-  // TT needs actual types of arguments to func ... extract them and pass to CallableWrapTTArgs
+  // TT needs actual types of arguments to func ... extract them and pass to CallableWrapTT
   using input_edge_value_types = ttg::meta::typelist<std::decay_t<input_edge_valuesT>...>;
   // input_args_t = {input_valuesT&&...}
   using input_args_t = typename ttg::meta::take_first_n<
@@ -567,7 +567,7 @@ auto make_tt(funcT &&func, const std::tuple<ttg::Edge<keyT, input_edge_valuesT>.
   using decayed_input_args_t = ttg::meta::decayed_typelist_t<input_args_t>;
   // 3. full_input_args_t = edge-types with non-void types replaced by input_args_t
   using full_input_args_t = ttg::meta::replace_nonvoid_t<input_edge_value_types, input_args_t>;
-  using wrapT = typename CallableWrapTTArgsAsTypelist<funcT, func_return_t, false, have_outterm_tuple, space, keyT,
+  using wrapT = typename CallableWrapTTAsTypelist<funcT, func_return_t, false, have_outterm_tuple, space, keyT,
                                                       output_terminals_type, full_input_args_t>::type;
 
   return std::make_unique<wrapT>(std::forward<funcT>(func), inedges, outedges, name, innames, outnames);