Enhacement of the macro functionalities within hpx

[andreichalapco]

Hi,

I've currently analyzed a bit the examples in the tutorials and I found the macros for creating the boiler plate code for remote actions (e.g HPX_PLAIN_ACTION).

#include <hpx/include/actions.hpp>

std::uint64_t fibonacci(std::uint64_t n);

HPX_PLAIN_ACTION(fibonacci, fibonacci_action)

I found this macro implementation is really hard to debug or also understand for the first comers on the hpx project and I wanted to start an initial issues for enhancement ... maybe with a follow-up pull request based on this.

I used the cpp preprocessor to expand the above example and came to the following macro expansion:

struct fibonacci_action
    : hpx::actions::make_action_t<decltype(&fibonacci), &fibonacci,
                                  fibonacci_action> {};
namespace hpx::actions::detail {
template <>
__attribute__((visibility("default"))) char const *
get_action_name<fibonacci_action>() noexcept;
}
namespace hpx::actions {
extern template struct __attribute__((visibility("default")))
transfer_action<fibonacci_action>;
extern template struct __attribute__((visibility("default")))
transfer_continuation_action<fibonacci_action>;
} // namespace hpx::actions
namespace hpx::traits {
template <> struct is_action<fibonacci_action> : std::true_type {};
template <>
struct needs_automatic_registration<fibonacci_action> : std::false_type {};
} // namespace hpx::traits
namespace hpx::actions::detail {
template <>
__attribute__((visibility("default"))) char const *
get_action_name<fibonacci_action>() noexcept {
  return "fibonacci_action";
}
} // namespace hpx::actions::detail
namespace hpx {
namespace actions {
namespace detail {
template register_action_invocation_count<fibonacci_action>
    register_action_invocation_count<fibonacci_action>::instance;
}
} // namespace actions
} // namespace hpx
namespace hpx::actions {
template struct transfer_action<fibonacci_action>;
template struct transfer_continuation_action<fibonacci_action>;
} // namespace hpx::actions

My question are:

• Does this macro expansion include everything that a hpx plain action should include?
• Woud template<auto fn> work for replacing this entire macro?

[hkaiser]

My question are:

• Does this macro expansion include everything that a hpx plain action should include?

I think so, yes.

• Woud template<auto fn> work for replacing this entire macro?

Part of this could be replaced with a solution relying on the template <auto F> facility.

[andreichalapco]

I have this minimal example impl:

#include <hpx/include/actions.hpp>

std::uint64_t fibonacci(std::uint64_t n) { return n; };

template<auto F>
struct f_action : hpx::actions::make_action_t<decltype(F), F, f_action<F>> {
};

namespace hpx::actions::detail {
    template<auto F>
    __attribute__((visibility("default")))
    constexpr const char *get_action_name(f_action <F>) noexcept {
      return typeid(f_action < F > ).name();
    }

} // namespace hpx::actions::detail

namespace hpx::traits {
    // should be a specialization
    template<auto F>
    struct is_action<f_action < F>> : std::true_type {
};
template<auto F>
struct needs_automatic_registration<f_action<F>> : std::false_type {
};
} // namespace hpx::traits

namespace hpx::actions {
    template<auto F>
    struct __attribute__((visibility("default"))) transfer_action<f_action < F>>;
    template<auto F>
    struct __attribute__((visibility("default"))) transfer_continuation_action<f_action < F>>;
} // namespace hpx::actions

Is there potential for a pull request here?

[hkaiser]

Sure, that's a first step in the right direction. Please however don't use any compiler specific constructs (like the __attribute__()). I'm also tagging @NK-Nikunj for him to chime in.

[NK-Nikunj]

@andreichalapco with template <auto Fn>, you would not need the necessary fibonacci_action struct. One can integrate fibonacci function directly with hpx::async as we use a different set of overloads for async. That was the initial idea behind the project. One can achieve this behavior by sending hpx::async<fibonacci>(args...). Of course, this isn't the end of it, or I would've implemented it long ago. The next step would be to add respective type traits to gather all action-related properties from Fn to create an equivalent of an action object on the fly and call it from async (essentially hiding it from the user).
A basic caller (albeit synchronous) scheme using template <auto Fn>: https://godbolt.org/z/36P7x9KvP. This API for hpx::async is very much doable. For a more complicated example, see: https://github.com/UIUC-PPL/charmlite/blob/main/include/charmlite/core/ep.hpp#L30