Pre-decay template arguments early

..to reduce the number of redudant instantiations
STEllAR-GROUP · Dec 17, 2017 · d3c0163 · d3c0163
1 parent a7717bf
commit d3c0163
Show file tree

Hide file tree

Showing 8 changed files with 135 additions and 100 deletions.
diff --git a/hpx/lcos/detail/async_colocated.hpp b/hpx/lcos/detail/async_colocated.hpp
@@ -37,10 +37,9 @@ namespace hpx { namespace detail
         typedef
             util::tuple<
                 hpx::util::detail::bound<
-                    hpx::util::functional::extract_locality(
-                        hpx::util::detail::placeholder<2ul> const&
-                      , hpx::id_type&&
-                    )
+                    hpx::util::functional::extract_locality
+                  , hpx::util::detail::placeholder<2ul>
+                  , hpx::id_type
                 >
               , Ts...
             >

diff --git a/hpx/runtime/actions/basic_action.hpp b/hpx/runtime/actions/basic_action.hpp
@@ -112,7 +112,9 @@ namespace hpx { namespace actions
             naming::id_type target_;
             continuation_type cont_;
             naming::address::address_type lva_;
-            util::detail::deferred<F(Ts&&...)> f_;
+            util::detail::deferred<
+                typename std::decay<F>::type,
+                typename std::decay<Ts>::type...> f_;
         };
 
         ///////////////////////////////////////////////////////////////////////

diff --git a/hpx/runtime/applier/register_apply_colocated.hpp b/hpx/runtime/applier/register_apply_colocated.hpp
@@ -25,10 +25,9 @@ namespace hpx { namespace detail
         typedef
             util::tuple<
                 hpx::util::detail::bound<
-                    hpx::util::functional::extract_locality(
-                        hpx::util::detail::placeholder<2ul> const&
-                      , hpx::id_type&&
-                    )
+                    hpx::util::functional::extract_locality
+                  , hpx::util::detail::placeholder<2ul>
+                  , hpx::id_type
                 >
               , Ts...
             >

diff --git a/hpx/util/annotated_function.hpp b/hpx/util/annotated_function.hpp
@@ -14,7 +14,6 @@
 #include <hpx/traits/get_function_address.hpp>
 #include <hpx/traits/get_function_annotation.hpp>
 #include <hpx/util/decay.hpp>
-#include <hpx/util/deferred_call.hpp>
 #include <hpx/util/invoke.hpp>
 #include <hpx/util/thread_description.hpp>
 
@@ -138,7 +137,8 @@ namespace hpx { namespace util
 
         public:
             template <typename ... Ts>
-            typename invoke_deferred_result<F, Ts...>::type
+            typename invoke_result<
+                typename util::decay_unwrap<F>::type, Ts...>::type
             operator()(Ts && ... ts)
             {
                 annotate_function func(name_);
@@ -170,10 +170,14 @@ namespace hpx { namespace util
     }
 
     template <typename F>
-    detail::annotated_function<F>
+    detail::annotated_function<typename std::decay<F>::type>
     annotated_function(F && f, char const* name = nullptr)
     {
-        return detail::annotated_function<F>(std::forward<F>(f), name);
+        typedef detail::annotated_function<
+            typename std::decay<F>::type
+        > result_type;
+
+        return result_type(std::forward<F>(f), name);
     }
 
 #else

diff --git a/hpx/util/bind.hpp b/hpx/util/bind.hpp
@@ -254,18 +254,19 @@ namespace hpx { namespace util
             return util::invoke(std::move(f), std::move(util::get<Is>(bound))...);
         }
 
-        template <typename T>
-        class bound;
-
         template <typename F, typename ...Ts>
-        class bound<F(Ts...)>
+        class bound
         {
         public:
             bound() {} // needed for serialization
 
-            explicit bound(F&& f, Ts&&... vs)
-              : _f(std::forward<F>(f))
-              , _args(std::forward<Ts>(vs)...)
+            template <typename F_, typename ...Ts_, typename =
+                typename std::enable_if<
+                    !std::is_same<typename std::decay<F_>::type, bound>::value
+                >::type>
+            explicit bound(F_&& f, Ts_&&... vs)
+              : _f(std::forward<F_>(f))
+              , _args(std::forward<Ts_>(vs)...)
             {}
 
 #if !defined(__NVCC__) && !defined(__CUDACC__)
@@ -358,14 +359,20 @@ namespace hpx { namespace util
 
     ///////////////////////////////////////////////////////////////////////////
     template <typename F, typename ...Ts>
-    inline typename std::enable_if<
+    typename std::enable_if<
         !traits::is_action<typename util::decay<F>::type>::value
-      , detail::bound<F(Ts&&...)>
+      , detail::bound<
+            typename std::decay<F>::type,
+            typename std::decay<Ts>::type...>
     >::type
     bind(F&& f, Ts&&... vs)
     {
-        return detail::bound<F(Ts&&...)>(
-            std::forward<F>(f), std::forward<Ts>(vs)...);
+        typedef detail::bound<
+            typename std::decay<F>::type,
+            typename std::decay<Ts>::type...
+        > result_type;
+
+        return result_type(std::forward<F>(f), std::forward<Ts>(vs)...);
     }
 
     ///////////////////////////////////////////////////////////////////////////
@@ -488,8 +495,8 @@ namespace hpx { namespace util
 namespace hpx { namespace traits
 {
     ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct is_bind_expression<util::detail::bound<T> >
+    template <typename F, typename ...Ts>
+    struct is_bind_expression<util::detail::bound<F, Ts...> >
       : std::true_type
     {};
 
@@ -501,11 +508,11 @@ namespace hpx { namespace traits
 
     ///////////////////////////////////////////////////////////////////////////
 #if defined(HPX_HAVE_THREAD_DESCRIPTION)
-    template <typename Sig>
-    struct get_function_address<util::detail::bound<Sig> >
+    template <typename F, typename ...Ts>
+    struct get_function_address<util::detail::bound<F, Ts...> >
     {
         static std::size_t
-            call(util::detail::bound<Sig> const& f) noexcept
+            call(util::detail::bound<F, Ts...> const& f) noexcept
         {
             return f.get_function_address();
         }
@@ -522,11 +529,11 @@ namespace hpx { namespace traits
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    template <typename Sig>
-    struct get_function_annotation<util::detail::bound<Sig> >
+    template <typename F, typename ...Ts>
+    struct get_function_annotation<util::detail::bound<F, Ts...> >
     {
         static char const*
-            call(util::detail::bound<Sig> const& f) noexcept
+            call(util::detail::bound<F, Ts...> const& f) noexcept
         {
             return f.get_function_annotation();
         }
@@ -543,11 +550,11 @@ namespace hpx { namespace traits
     };
 
 #if HPX_HAVE_ITTNOTIFY != 0 && !defined(HPX_HAVE_APEX)
-    template <typename Sig>
-    struct get_function_annotation_itt<util::detail::bound<Sig> >
+    template <typename F, typename ...Ts>
+    struct get_function_annotation_itt<util::detail::bound<F, Ts...> >
     {
         static util::itt::string_handle
-            call(util::detail::bound<Sig> const& f) noexcept
+            call(util::detail::bound<F, Ts...> const& f) noexcept
         {
             return f.get_function_annotation_itt();
         }
@@ -570,10 +577,10 @@ namespace hpx { namespace traits
 namespace hpx { namespace serialization
 {
     // serialization of the bound object
-    template <typename Archive, typename T>
+    template <typename Archive, typename F, typename ...Ts>
     void serialize(
         Archive& ar
-      , ::hpx::util::detail::bound<T>& bound
+      , ::hpx::util::detail::bound<F, Ts...>& bound
       , unsigned int const version = 0)
     {
         bound.serialize(ar, version);

diff --git a/hpx/util/bind_back.hpp b/hpx/util/bind_back.hpp
@@ -74,18 +74,19 @@ namespace hpx { namespace util
         }
 
         ///////////////////////////////////////////////////////////////////////
-        template <typename T>
-        struct bound_back;
-
         template <typename F, typename ...Ts>
-        struct bound_back<F(Ts...)>
+        struct bound_back
         {
         public:
             bound_back() {} // needed for serialization
 
-            explicit bound_back(F&& f, Ts&&... vs)
-              : _f(std::forward<F>(f))
-              , _args(std::forward<Ts>(vs)...)
+            template <typename F_, typename ...Ts_, typename =
+                typename std::enable_if<
+                    !std::is_same<typename std::decay<F_>::type, bound_back>::value
+                >::type>
+            explicit bound_back(F_&& f, Ts_&&... vs)
+              : _f(std::forward<F_>(f))
+              , _args(std::forward<Ts_>(vs)...)
             {}
 
 #if !defined(__NVCC__) && !defined(__CUDACC__)
@@ -203,10 +204,16 @@ namespace hpx { namespace util
     }
 
     template <typename F, typename ...Ts>
-    detail::bound_back<F(Ts&&...)>
+    detail::bound_back<
+        typename std::decay<F>::type,
+        typename std::decay<Ts>::type...>
     bind_back(F&& f, Ts&&... vs) {
-        return detail::bound_back<F(Ts&&...)>(
-            std::forward<F>(f), std::forward<Ts>(vs)...);
+        typedef detail::bound_back<
+            typename std::decay<F>::type,
+            typename std::decay<Ts>::type...
+        > result_type;
+
+        return result_type(std::forward<F>(f), std::forward<Ts>(vs)...);
     }
 }}
 
@@ -215,33 +222,33 @@ namespace hpx { namespace traits
 {
     ///////////////////////////////////////////////////////////////////////////
 #if defined(HPX_HAVE_THREAD_DESCRIPTION)
-    template <typename Sig>
-    struct get_function_address<util::detail::bound_back<Sig> >
+    template <typename F, typename ...Ts>
+    struct get_function_address<util::detail::bound_back<F, Ts...> >
     {
         static std::size_t
-            call(util::detail::bound_back<Sig> const& f) noexcept
+            call(util::detail::bound_back<F, Ts...> const& f) noexcept
         {
             return f.get_function_address();
         }
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    template <typename Sig>
-    struct get_function_annotation<util::detail::bound_back<Sig> >
+    template <typename F, typename ...Ts>
+    struct get_function_annotation<util::detail::bound_back<F, Ts...> >
     {
         static char const*
-            call(util::detail::bound_back<Sig> const& f) noexcept
+            call(util::detail::bound_back<F, Ts...> const& f) noexcept
         {
             return f.get_function_annotation();
         }
     };
 
 #if HPX_HAVE_ITTNOTIFY != 0 && !defined(HPX_HAVE_APEX)
-    template <typename Sig>
-    struct get_function_annotation_itt<util::detail::bound_back<Sig> >
+    template <typename F, typename ...Ts>
+    struct get_function_annotation_itt<util::detail::bound_back<F, Ts...> >
     {
         static util::itt::string_handle
-            call(util::detail::bound_back<Sig> const& f) noexcept
+            call(util::detail::bound_back<F, Ts...> const& f) noexcept
         {
             return f.get_function_annotation_itt();
         }
@@ -254,10 +261,10 @@ namespace hpx { namespace traits
 namespace hpx { namespace serialization
 {
     // serialization of the bound_back object
-    template <typename Archive, typename T>
+    template <typename Archive, typename F, typename ...Ts>
     void serialize(
         Archive& ar
-      , ::hpx::util::detail::bound_back<T>& bound
+      , ::hpx::util::detail::bound_back<F, Ts...>& bound
       , unsigned int const version = 0)
     {
         bound.serialize(ar, version);