Class Executor

Inheritance Relationships

Derived Types

Class Documentation

class Executor

Coordinate the order and timing of available communication tasks.

Executor provides spin functions (including spin_node_once and spin_some). It coordinates the nodes and callback groups by looking for available work and completing it, based on the threading or concurrency scheme provided by the subclass implementation. An example of available work is executing a subscription callback, or a timer callback. The executor structure allows for a decoupling of the communication graph and the execution model. See SingleThreadedExecutor and MultiThreadedExecutor for examples of execution paradigms.

Subclassed by rclcpp::executors::MultiThreadedExecutor, rclcpp::executors::SingleThreadedExecutor, rclcpp::executors::StaticSingleThreadedExecutor, rclcpp::experimental::executors::EventsExecutor

Public Functions

explicit Executor(const rclcpp::ExecutorOptions &options = rclcpp::ExecutorOptions())

Default constructor.

Parameters:

options – [in] Options used to configure the executor.

virtual ~Executor()

Default destructor.

virtual void spin() = 0

Do work periodically as it becomes available to us. Blocking call, may block indefinitely.

virtual void add_callback_group(rclcpp::CallbackGroup::SharedPtr group_ptr, rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify = true)

Add a callback group to an executor.

An executor can have zero or more callback groups which provide work during spin functions. When an executor attempts to add a callback group, the executor checks to see if it is already associated with another executor, and if it has been, then an exception is thrown. Otherwise, the callback group is added to the executor.

Adding a callback group with this method does not associate its node with this executor in any way

Parameters:

  • group_ptr – [in] a shared ptr that points to a callback group

  • node_ptr – [in] a shared pointer that points to a node base interface

  • notify – [in] True to trigger the interrupt guard condition during this function. If the executor is blocked at the rmw layer while waiting for work and it is notified that a new callback group was added, it will wake up.

Throws:

std::runtime_error – if the callback group is associated to an executor

virtual std::vector<rclcpp::CallbackGroup::WeakPtr> get_all_callback_groups()

Get callback groups that belong to executor.

This function returns a vector of weak pointers that point to callback groups that were associated with the executor. The callback groups associated with this executor may have been added with add_callback_group, or added when a node was added to the executor with add_node, or automatically added when it created by a node already associated with this executor and the automatically_add_to_executor_with_node parameter was true.

Returns:

a vector of weak pointers that point to callback groups that are associated with the executor

virtual std::vector<rclcpp::CallbackGroup::WeakPtr> get_manually_added_callback_groups()

Get callback groups that belong to executor.

This function returns a vector of weak pointers that point to callback groups that were associated with the executor. The callback groups associated with this executor have been added with add_callback_group.

Returns:

a vector of weak pointers that point to callback groups that are associated with the executor

virtual std::vector<rclcpp::CallbackGroup::WeakPtr> get_automatically_added_callback_groups_from_nodes()

Get callback groups that belong to executor.

This function returns a vector of weak pointers that point to callback groups that were added from a node that is associated with the executor. The callback groups are added when a node is added to the executor with add_node, or automatically if they are created in the future by that node and have the automatically_add_to_executor_with_node argument set to true.

Returns:

a vector of weak pointers that point to callback groups from a node associated with the executor

virtual void remove_callback_group(rclcpp::CallbackGroup::SharedPtr group_ptr, bool notify = true)

Remove a callback group from the executor.

The callback group is removed from and disassociated with the executor. If the callback group removed was the last callback group from the node that is associated with the executor, the interrupt guard condition is triggered and node’s guard condition is removed from the executor.

This function only removes a callback group that was manually added with rclcpp::Executor::add_callback_group. To remove callback groups that were added from a node using rclcpp::Executor::add_node, use rclcpp::Executor::remove_node instead.

Parameters:

  • group_ptr – [in] Shared pointer to the callback group to be added.

  • notify – [in] True to trigger the interrupt guard condition during this function. If the executor is blocked at the rmw layer while waiting for work and it is notified that a callback group was removed, it will wake up.

Throws:

  • std::runtime_error – if node is deleted before callback group

  • std::runtime_error – if the callback group is not associated with the executor

virtual void add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify = true)

Add a node to the executor.

Nodes have associated callback groups, and this method adds any of those callback groups to this executor which have their automatically_add_to_executor_with_node parameter true. The node is also associated with the executor so that future callback groups which are created on the node with the automatically_add_to_executor_with_node parameter set to true are also automatically associated with this executor.

Callback groups with the automatically_add_to_executor_with_node parameter set to false must be manually added to an executor using the rclcpp::Executor::add_callback_group method.

If a node is already associated with an executor, this method throws an exception.

Parameters:

  • node_ptr – [in] Shared pointer to the node to be added.

  • notify – [in] True to trigger the interrupt guard condition during this function. If the executor is blocked at the rmw layer while waiting for work and it is notified that a new node was added, it will wake up.

Throws:

std::runtime_error – if a node is already associated to an executor

virtual void add_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true)

Convenience function which takes Node and forwards NodeBaseInterface.

See also

rclcpp::Executor::add_node

virtual void remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify = true)

Remove a node from the executor.

Any callback groups automatically added when this node was added with rclcpp::Executor::add_node are automatically removed, and the node is no longer associated with this executor.

This also means that future callback groups created by the given node are no longer automatically added to this executor.

Parameters:

  • node_ptr – [in] Shared pointer to the node to remove.

  • notify – [in] True to trigger the interrupt guard condition and wake up the executor. This is useful if the last node was removed from the executor while the executor was blocked waiting for work in another thread, because otherwise the executor would never be notified.

Throws:

  • std::runtime_error – if the node is not associated with an executor.

  • std::runtime_error – if the node is not associated with this executor.

virtual void remove_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true)

Convenience function which takes Node and forwards NodeBaseInterface.

See also

rclcpp::Executor::remove_node

template<typename RepT = int64_t, typename T = std::milli>
inline void spin_node_once(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node, std::chrono::duration<RepT, T> timeout = std::chrono::duration<RepT, T>(-1))

Add a node to executor, execute the next available unit of work, and remove the node.

Parameters:

  • node – [in] Shared pointer to the node to add.

  • timeout – [in] How long to wait for work to become available. Negative values cause spin_node_once to block indefinitely (the default behavior). A timeout of 0 causes this function to be non-blocking.

template<typename NodeT = rclcpp::Node, typename RepT = int64_t, typename T = std::milli>
inline void spin_node_once(std::shared_ptr<NodeT> node, std::chrono::duration<RepT, T> timeout = std::chrono::duration<RepT, T>(-1))

Convenience function which takes Node and forwards NodeBaseInterface.

virtual void spin_node_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node)

Add a node, complete all immediately available work, and remove the node.

Parameters:

node – [in] Shared pointer to the node to add.

virtual void spin_node_some(std::shared_ptr<rclcpp::Node> node)

Convenience function which takes Node and forwards NodeBaseInterface.

virtual void spin_some(std::chrono::nanoseconds max_duration = std::chrono::nanoseconds(0))

Collect work once and execute all available work, optionally within a max duration.

This function can be overridden. The default implementation is suitable for a single-threaded model of execution. Adding subscriptions, timers, services, etc. with blocking or long running callbacks may cause the function exceed the max_duration significantly.

If there is no work to be done when this called, it will return immediately because the collecting of available work is non-blocking. Before each piece of ready work is executed this function checks if the max_duration has been exceeded, and if it has it returns without starting the execution of the next piece of work.

If a max_duration of 0 is given, then all of the collected work will be executed before the function returns.

Parameters:

max_duration – [in] The maximum amount of time to spend executing work, or 0 for no limit.

virtual void spin_node_all(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node, std::chrono::nanoseconds max_duration)

Add a node, complete all immediately available work exhaustively, and remove the node.

Parameters:

node – [in] Shared pointer to the node to add.

virtual void spin_node_all(std::shared_ptr<rclcpp::Node> node, std::chrono::nanoseconds max_duration)

Convenience function which takes Node and forwards NodeBaseInterface.

virtual void spin_all(std::chrono::nanoseconds max_duration)

Collect and execute work repeatedly within a duration or until no more work is available.

This function can be overridden. The default implementation is suitable for a single-threaded model of execution. Adding subscriptions, timers, services, etc. with blocking callbacks will cause this function to block (which may have unintended consequences). If the time that waitables take to be executed is longer than the period on which new waitables become ready, this method will execute work repeatedly until max_duration has elapsed.

Parameters:

max_duration – [in] The maximum amount of time to spend executing work, must be >= 0. 0 is potentially block forever until no more work is available.

Throws:

std::invalid_argument – if max_duration is less than 0. Note that spin_all() may take longer than this time as it only returns once max_duration has been exceeded.

virtual void spin_once(std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1))

Collect work once and execute the next available work, optionally within a duration.

This function can be overridden. The default implementation is suitable for a single-thread model of execution. Adding subscriptions, timers, services, etc. with blocking callbacks will cause this function to block (which may have unintended consequences).

Parameters:

timeout – [in] The maximum amount of time to spend waiting for work. -1 is potentially block forever waiting for work.

template<typename FutureT, typename TimeRepT = int64_t, typename TimeT = std::milli>
inline FutureReturnCode spin_until_future_complete(const FutureT &future, std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))

Spin (blocking) until the future is complete, it times out waiting, or rclcpp is interrupted.

Parameters:

  • future – [in] The future to wait on. If this function returns SUCCESS, the future can be accessed without blocking (though it may still throw an exception).

  • timeout – [in] Optional timeout parameter, which gets passed to Executor::spin_node_once. -1 is block forever, 0 is non-blocking. If the time spent inside the blocking loop exceeds this timeout, return a TIMEOUT return code.

Returns:

The return code, one of SUCCESS, INTERRUPTED, or TIMEOUT.

virtual void cancel()

Cancel any running spin* function, causing it to return.

This function can be called asynchonously from any thread.

Throws:

std::runtime_error – if there is an issue triggering the guard condition

bool is_spinning()

Returns true if the executor is currently spinning.

This function can be called asynchronously from any thread.

Returns:

True if the executor is currently spinning.

Protected Functions

explicit Executor(const std::shared_ptr<rclcpp::Context> &context)

Constructor that will not initialize any non-trivial members.

This constructor is intended to be used by any derived executor that explicitly does not want to use the default implementation provided by this class.

void spin_node_once_nanoseconds(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node, std::chrono::nanoseconds timeout)

Add a node to executor, execute the next available unit of work, and remove the node.

Implementation of spin_node_once using std::chrono::nanoseconds

Parameters:

  • node – [in] Shared pointer to the node to add.

  • timeout – [in] How long to wait for work to become available. Negative values cause spin_node_once to block indefinitely (the default behavior). A timeout of 0 causes this function to be non-blocking.

virtual FutureReturnCode spin_until_future_complete_impl(std::chrono::nanoseconds timeout, const std::function<std::future_status(std::chrono::nanoseconds wait_time)> &wait_for_future)

Spin (blocking) until the future is complete, it times out waiting, or rclcpp is interrupted.

See also

spin_until_future_complete() The only difference with spin_until_future_complete() is that the future’s type is obscured through a std::function which lets you wait on it reguardless of type.

Parameters:

  • timeout – [in] see spin_until_future_complete() for details

  • wait_for_future – [in] function to wait on the future and get the status after waiting

void spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)

Collect work and execute available work, optionally within a duration.

Implementation of spin_some and spin_all. The exhaustive flag controls if the function will re-collect available work within the duration.

Parameters:

  • max_duration – [in] The maximum amount of time to spend executing work, or 0 for no limit.

  • exhaustive – [in] when set to true, continue to collect work and execute (spin_all) when set to false, return when all collected work is executed (spin_some)

void execute_any_executable(AnyExecutable &any_exec)

Find the next available executable and do the work associated with it.

Parameters:

any_exec – [in] Union structure that can hold any executable type (timer, subscription, service, client).

Throws:

std::runtime_error – if there is an issue triggering the guard condition

void collect_entities()

Gather all of the waitable entities from associated nodes and callback groups.

void wait_for_work(std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1))

Block until more work becomes avilable or timeout is reached.

Builds a set of waitable entities, which are passed to the middleware. After building wait set, waits on middleware to notify.

Parameters:

timeout – [in] duration to wait for new work to become available.

Throws:

std::runtime_error – if the wait set can be cleared

bool get_next_ready_executable(AnyExecutable &any_executable)

Check for executable in ready state and populate union structure.

Parameters:

any_executable – [out] populated union structure of ready executable

Returns:

true if an executable was ready and any_executable was populated, otherwise false

bool get_next_executable(AnyExecutable &any_executable, std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1))

Wait for executable in ready state and populate union structure.

If an executable is ready, it will return immediately, otherwise block based on the timeout for work to become ready.

Parameters:

  • any_executable – [out] populated union structure of ready executable

  • timeout – [in] duration of time to wait for work, a negative value (the defualt behavior), will make this function block indefinitely

Returns:

true if an executable was ready and any_executable was populated, otherwise false

virtual void handle_updated_entities(bool notify)

This function triggers a recollect of all entities that are registered to the executor.

Calling this function is thread safe.

Parameters:

notify – [in] if true will execute a trigger that will wake up a waiting executor

virtual void spin_once_impl(std::chrono::nanoseconds timeout)

Protected Attributes

std::atomic_bool spinning

Spinning state, used to prevent multi threaded calls to spin and to cancel blocking spins.

std::shared_ptr<rclcpp::GuardCondition> interrupt_guard_condition_

Guard condition for signaling the rmw layer to wake up for special events.

std::shared_ptr<rclcpp::GuardCondition> shutdown_guard_condition_

Guard condition for signaling the rmw layer to wake up for system shutdown.

mutable std::mutex mutex_
std::shared_ptr<rclcpp::Context> context_

The context associated with this executor.

std::shared_ptr<rclcpp::executors::ExecutorNotifyWaitable> notify_waitable_

Waitable containing guard conditions controlling the executor flow.

This waitable contains the interrupt and shutdown guard condition, as well as the guard condition associated with each node and callback group. By default, if any change is detected in the monitored entities, the notify waitable will awake the executor and rebuild the collections.

std::atomic_bool entities_need_rebuild_
rclcpp::executors::ExecutorEntitiesCollector collector_

Collector used to associate executable entities from nodes and guard conditions.

rclcpp::WaitSet wait_set_

WaitSet to be waited on.

std::optional<rclcpp::WaitResult<rclcpp::WaitSet>> wait_result_
rclcpp::executors::ExecutorEntitiesCollection current_collection_

Hold the current state of the collection being waited on by the waitset.

std::shared_ptr<rclcpp::executors::ExecutorNotifyWaitable> current_notify_waitable_

Hold the current state of the notify waitable being waited on by the waitset.

rclcpp::OnShutdownCallbackHandle shutdown_callback_handle_

shutdown callback handle registered to Context

std::unique_ptr<ExecutorImplementation> impl_

Pointer to implementation.

Protected Static Functions

static void execute_subscription(rclcpp::SubscriptionBase::SharedPtr subscription)

Run subscription executable.

Do necessary setup and tear-down as well as executing the subscription.

Parameters:

subscription – [in] Subscription to execute

static void execute_timer(rclcpp::TimerBase::SharedPtr timer, const std::shared_ptr<void> &data_ptr)

Run timer executable.

Do necessary setup and tear-down as well as executing the timer callback.

Parameters:

timer – [in] Timer to execute

static void execute_service(rclcpp::ServiceBase::SharedPtr service)

Run service server executable.

Do necessary setup and tear-down as well as executing the service server callback.

Parameters:

service – [in] Service to execute

static void execute_client(rclcpp::ClientBase::SharedPtr client)

Run service client executable.

Do necessary setup and tear-down as well as executing the service client callback.

Parameters:

service – [in] Service to execute