actions_base¶

The contents of this module can be included with the header hpx/modules/actions_base.hpp. These headers may be used by user-code but are not guaranteed stable (neither header location nor contents). You are using these at your own risk. If you wish to use non-public functionality from a module we strongly suggest only including the module header hpx/modules/actions_base.hpp, not the particular header in which the functionality you would like to use is defined. See Public API for a list of names that are part of the public HPX API.

namespace hpx

namespace actions¶

Functions

template<typename Action> threads::thread_priority action_priority()¶

Defines

HPX_REGISTER_ACTION_DECLARATION(...)¶

Declare the necessary component action boilerplate code.

The macro HPX_REGISTER_ACTION_DECLARATION can be used to declare all the boilerplate code which is required for proper functioning of component actions in the context of HPX.

The parameter action is the type of the action to declare the boilerplate for.

This macro can be invoked with an optional second parameter. This parameter specifies a unique name of the action to be used for serialization purposes. The second parameter has to be specified if the first parameter is not usable as a plain (non-qualified) C++ identifier, i.e. the first parameter contains special characters which cannot be part of a C++ identifier, such as ‘<’, ‘>’, or ‘:’.

namespace app
{
    // Define a simple component exposing one action 'print_greeting'
    class HPX_COMPONENT_EXPORT server
      : public hpx::components::component_base<server>
    {
        void print_greeting ()
        {
            hpx::cout << "Hey, how are you?\n" << hpx::flush;
        }

        // Component actions need to be declared, this also defines the
        // type 'print_greeting_action' representing the action.
        HPX_DEFINE_COMPONENT_ACTION(server,
            print_greeting, print_greeting_action);
    };
}

// Declare boilerplate code required for each of the component actions.
HPX_REGISTER_ACTION_DECLARATION(app::server::print_greeting_action);

Example:

Note: This macro has to be used once for each of the component actions defined using one of the HPX_DEFINE_COMPONENT_ACTION macros. It has to be visible in all translation units using the action, thus it is recommended to place it into the header file defining the component.

HPX_REGISTER_ACTION_DECLARATION_(...)¶

HPX_REGISTER_ACTION_DECLARATION_1(action)¶

HPX_REGISTER_ACTION(...)¶

Define the necessary component action boilerplate code.

The macro HPX_REGISTER_ACTION can be used to define all the boilerplate code which is required for proper functioning of component actions in the context of HPX.

The parameter action is the type of the action to define the boilerplate for.

This macro can be invoked with an optional second parameter. This parameter specifies a unique name of the action to be used for serialization purposes. The second parameter has to be specified if the first parameter is not usable as a plain (non-qualified) C++ identifier, i.e. the first parameter contains special characters which cannot be part of a C++ identifier, such as ‘<’, ‘>’, or ‘:’.

Note: This macro has to be used once for each of the component actions defined using one of the HPX_DEFINE_COMPONENT_ACTION or HPX_DEFINE_PLAIN_ACTION macros. It has to occur exactly once for each of the actions, thus it is recommended to place it into the source file defining the component.
Note: Only one of the forms of this macro HPX_REGISTER_ACTION or HPX_REGISTER_ACTION_ID should be used for a particular action, never both.

HPX_REGISTER_ACTION_ID(action, actionname, actionid)¶

Define the necessary component action boilerplate code and assign a predefined unique id to the action.

The macro HPX_REGISTER_ACTION can be used to define all the boilerplate code which is required for proper functioning of component actions in the context of HPX.

The parameter action is the type of the action to define the boilerplate for.

The parameter actionname specifies an unique name of the action to be used for serialization purposes. The second parameter has to be usable as a plain (non-qualified) C++ identifier, it should not contain special characters which cannot be part of a C++ identifier, such as ‘<’, ‘>’, or ‘:’.

The parameter actionid specifies an unique integer value which will be used to represent the action during serialization.

Note: This macro has to be used once for each of the component actions defined using one of the HPX_DEFINE_COMPONENT_ACTION or global actions HPX_DEFINE_PLAIN_ACTION macros. It has to occur exactly once for each of the actions, thus it is recommended to place it into the source file defining the component.
Note: Only one of the forms of this macro HPX_REGISTER_ACTION or HPX_REGISTER_ACTION_ID should be used for a particular action, never both.

namespace hpx

namespace actions

template<typename Component, typename Signature, typename Derived> struct basic_action¶

#include <basic_action_fwd.hpp>

Template Parameters

Component: component type
Signature: return type and arguments
Derived: derived action class

Defines

HPX_DEFINE_COMPONENT_ACTION(...)¶

Registers a member function of a component as an action type with HPX.

The macro HPX_DEFINE_COMPONENT_ACTION can be used to register a member function of a component as an action type named action_type.

The parameter component is the type of the component exposing the member function func which should be associated with the newly defined action type. The parameter action_type is the name of the action type to register with HPX.

namespace app
{
    // Define a simple component exposing one action 'print_greeting'
    class HPX_COMPONENT_EXPORT server
      : public hpx::components::component_base<server>
    {
        void print_greeting() const
        {
            hpx::cout << "Hey, how are you?\n" << hpx::flush;
        }

        // Component actions need to be declared, this also defines the
        // type 'print_greeting_action' representing the action.
        HPX_DEFINE_COMPONENT_ACTION(server, print_greeting,
            print_greeting_action);
    };
}

Example:

The first argument must provide the type name of the component the action is defined for.

The second argument must provide the member function name the action should wrap.

The default value for the third argument (the typename of the defined action) is derived from the name of the function (as passed as the second argument) by appending ‘_action’. The third argument can be omitted only if the second argument with an appended suffix ‘_action’ resolves to a valid, unqualified C++ type name.

Note: The macro HPX_DEFINE_COMPONENT_ACTION can be used with 2 or 3 arguments. The third argument is optional.

Defines

HPX_DEFINE_PLAIN_ACTION(...)¶

Defines a plain action type.

namespace app
{
    void some_global_function(double d)
    {
        cout << d;
    }

    // This will define the action type 'app::some_global_action' which
    // represents the function 'app::some_global_function'.
    HPX_DEFINE_PLAIN_ACTION(some_global_function, some_global_action);
}

Example:

Note: Usually this macro will not be used in user code unless the intent is to avoid defining the action_type in global namespace. Normally, the use of the macro HPX_PLAIN_ACTION is recommended.
Note: The macro HPX_DEFINE_PLAIN_ACTION can be used with 1 or 2 arguments. The second argument is optional. The default value for the second argument (the typename of the defined action) is derived from the name of the function (as passed as the first argument) by appending ‘_action’. The second argument can be omitted only if the first argument with an appended suffix ‘_action’ resolves to a valid, unqualified C++ type name.

HPX_DECLARE_PLAIN_ACTION(...)¶: Declares a plain action type.

HPX_PLAIN_ACTION(...)¶

Defines a plain action type based on the given function func and registers it with HPX.

The macro HPX_PLAIN_ACTION can be used to define a plain action (e.g. an action encapsulating a global or free function) based on the given function func. It defines the action type name representing the given function. This macro additionally registers the newly define action type with HPX.

The parameter func is a global or free (non-member) function which should be encapsulated into a plain action. The parameter name is the name of the action type defined by this macro.

namespace app
{
    void some_global_function(double d)
    {
        cout << d;
    }
}

// This will define the action type 'some_global_action' which represents
// the function 'app::some_global_function'.
HPX_PLAIN_ACTION(app::some_global_function, some_global_action);

Example:

Note: The macro HPX_PLAIN_ACTION has to be used at global namespace even if the wrapped function is located in some other namespace. The newly defined action type is placed into the global namespace as well.
Note: The macro HPX_PLAIN_ACTION_ID can be used with 1, 2, or 3 arguments. The second and third arguments are optional. The default value for the second argument (the typename of the defined action) is derived from the name of the function (as passed as the first argument) by appending ‘_action’. The second argument can be omitted only if the first argument with an appended suffix ‘_action’ resolves to a valid, unqualified C++ type name. The default value for the third argument is hpx::components::factory_check.
Note: Only one of the forms of this macro HPX_PLAIN_ACTION or HPX_PLAIN_ACTION_ID should be used for a particular action, never both.

HPX_PLAIN_ACTION_ID(func, name, id)¶

Defines a plain action type based on the given function func and registers it with HPX.

The macro HPX_PLAIN_ACTION_ID can be used to define a plain action (e.g. an action encapsulating a global or free function) based on the given function func. It defines the action type actionname representing the given function. The parameter actionid

The parameter actionid specifies an unique integer value which will be used to represent the action during serialization.

The parameter func is a global or free (non-member) function which should be encapsulated into a plain action. The parameter name is the name of the action type defined by this macro.

The second parameter has to be usable as a plain (non-qualified) C++ identifier, it should not contain special characters which cannot be part of a C++ identifier, such as ‘<’, ‘>’, or ‘:’.

namespace app
{
    void some_global_function(double d)
    {
        cout << d;
    }
}

// This will define the action type 'some_global_action' which represents
// the function 'app::some_global_function'.
HPX_PLAIN_ACTION_ID(app::some_global_function, some_global_action,
  some_unique_id);

Example:

Note: The macro HPX_PLAIN_ACTION_ID has to be used at global namespace even if the wrapped function is located in some other namespace. The newly defined action type is placed into the global namespace as well.
Note: Only one of the forms of this macro HPX_PLAIN_ACTION or HPX_PLAIN_ACTION_ID should be used for a particular action, never both.

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct action_continuation¶

Public Types

template<> using type = hpx::actions::typed_continuation<typename Action::local_result_type, typename Action::remote_result_type>¶

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct action_decorate_continuation¶

Public Types

template<> using continuation_type = typename hpx::traits::action_continuation<Action>::type¶

Public Static Functions

static constexpr bool call(continuation_type&)¶

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct action_does_termination_detection¶

Public Static Functions

static constexpr bool call()¶

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct action_is_target_valid¶

Public Static Functions

static bool call(naming::id_type const &id)¶

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct action_priority¶

Public Static Attributes

constexpr threads::thread_priority value = threads::thread_priority::default_¶

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct action_schedule_thread¶

Public Static Functions

static void call(naming::address_type lva, naming::component_type comptype, threads::thread_init_data &data)¶

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct action_select_direct_execution¶

Public Static Functions

static constexpr launch call(launch policy, naming::address_type lva)¶

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct action_stacksize¶

Public Static Attributes

constexpr threads::thread_stacksize value = threads::thread_stacksize::default_¶

namespace hpx

namespace traits

template<typename Continuation, typename Enable = void> struct action_trigger_continuation¶

Public Static Functions

template<typename F, typename ...Ts> static void call(Continuation&&, F&&, Ts&&...)¶

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct action_was_object_migrated¶

Public Static Functions

static std::pair<bool, components::pinned_ptr> call(hpx::naming::gid_type const &id, naming::address_type lva)¶

static std::pair<bool, components::pinned_ptr> call(hpx::naming::id_type const &id, naming::address_type lva)¶

namespace hpx

namespace traits

template<typename Action, typename Enable = void> struct extract_action¶

Public Types

template<> using type = typename Action::derived_type¶

template<> using result_type = typename type::result_type¶

template<> using local_result_type = typename type::local_result_type¶

template<> using remote_result_type = typename type::remote_result_type¶

namespace hpx

namespace traits

Variables

template<typename T> constexpr bool is_client_v = is_client<T>::value¶

template<typename T> constexpr bool is_client_or_client_array_v = is_client_or_client_array<T>::value¶

namespace hpx

namespace traits

template<typename Policy, typename Enable = void> struct num_container_partitions¶

Public Static Functions

static std::size_t call(Policy const &policy)¶