Static executor implementation. More...

#include <rclcpp/executors/static_single_threaded_executor.hpp>

Inheritance diagram for rclcpp::executors::StaticSingleThreadedExecutor:

Collaboration diagram for rclcpp::executors::StaticSingleThreadedExecutor:

[legend]

Public Member Functions
RCLCPP_PUBLIC	StaticSingleThreadedExecutor (const rclcpp::ExecutorOptions &options=rclcpp::ExecutorOptions())
	Default constructor. See the default constructor for Executor.

virtual RCLCPP_PUBLIC	~StaticSingleThreadedExecutor ()
	Default destructor.

RCLCPP_PUBLIC void	spin () override
	Static executor implementation of spin. More...

RCLCPP_PUBLIC void	spin_some (std::chrono::nanoseconds max_duration=std::chrono::nanoseconds(0)) override
	Static executor implementation of spin some. More...

RCLCPP_PUBLIC void	spin_all (std::chrono::nanoseconds max_duration) override
	Static executor implementation of spin all. More...

Public Member Functions inherited from rclcpp::Executor
RCLCPP_PUBLIC	Executor (const rclcpp::ExecutorOptions &options=rclcpp::ExecutorOptions())
	Default constructor. More...

virtual RCLCPP_PUBLIC	~Executor ()
	Default destructor.

virtual RCLCPP_PUBLIC 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. More...

virtual RCLCPP_PUBLIC std::vector< rclcpp::CallbackGroup::WeakPtr >	get_all_callback_groups ()
	Get callback groups that belong to executor. More...

virtual RCLCPP_PUBLIC std::vector< rclcpp::CallbackGroup::WeakPtr >	get_manually_added_callback_groups ()
	Get callback groups that belong to executor. More...

virtual RCLCPP_PUBLIC std::vector< rclcpp::CallbackGroup::WeakPtr >	get_automatically_added_callback_groups_from_nodes ()
	Get callback groups that belong to executor. More...

virtual RCLCPP_PUBLIC void	remove_callback_group (rclcpp::CallbackGroup::SharedPtr group_ptr, bool notify=true)
	Remove a callback group from the executor. More...

virtual RCLCPP_PUBLIC void	add_node (rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify=true)
	Add a node to the executor. More...

virtual RCLCPP_PUBLIC void	add_node (std::shared_ptr< rclcpp::Node > node_ptr, bool notify=true)
	Convenience function which takes Node and forwards NodeBaseInterface. More...

virtual RCLCPP_PUBLIC void	remove_node (rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify=true)
	Remove a node from the executor. More...

virtual RCLCPP_PUBLIC void	remove_node (std::shared_ptr< rclcpp::Node > node_ptr, bool notify=true)
	Convenience function which takes Node and forwards NodeBaseInterface. More...

template<typename RepT = int64_t, typename T = std::milli>
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. More...

template<typename NodeT = rclcpp::Node, typename RepT = int64_t, typename T = std::milli>
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 RCLCPP_PUBLIC void	spin_node_some (rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node)
	Add a node, complete all immediately available work, and remove the node. More...

virtual RCLCPP_PUBLIC void	spin_node_some (std::shared_ptr< rclcpp::Node > node)
	Convenience function which takes Node and forwards NodeBaseInterface.

virtual RCLCPP_PUBLIC 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. More...

virtual RCLCPP_PUBLIC void	spin_node_all (std::shared_ptr< rclcpp::Node > node, std::chrono::nanoseconds max_duration)
	Convenience function which takes Node and forwards NodeBaseInterface.

virtual RCLCPP_PUBLIC void	spin_once (std::chrono::nanoseconds timeout=std::chrono::nanoseconds(-1))
	Collect work once and execute the next available work, optionally within a duration. More...

template<typename FutureT , typename TimeRepT = int64_t, typename TimeT = std::milli>
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. More...

virtual RCLCPP_PUBLIC void	cancel ()
	Cancel any running spin* function, causing it to return. More...

RCLCPP_PUBLIC bool	is_spinning ()
	Returns true if the executor is currently spinning. More...

Protected Member Functions
bool	execute_ready_executables (const rclcpp::executors::ExecutorEntitiesCollection &collection, rclcpp::WaitResult< rclcpp::WaitSet > &wait_result, bool spin_once)
	Executes ready executables from wait set. More...

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

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

std::optional< rclcpp::WaitResult< rclcpp::WaitSet > >	collect_and_wait (std::chrono::nanoseconds timeout)

Protected Member Functions inherited from rclcpp::Executor
	Executor (const std::shared_ptr< rclcpp::Context > &context)
	Constructor that will not initialize any non-trivial members. More...

RCLCPP_PUBLIC 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. More...

virtual RCLCPP_PUBLIC 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. More...

RCLCPP_PUBLIC void	spin_some_impl (std::chrono::nanoseconds max_duration, bool exhaustive)
	Collect work and execute available work, optionally within a duration. More...

RCLCPP_PUBLIC void	execute_any_executable (AnyExecutable &any_exec)
	Find the next available executable and do the work associated with it. More...

RCLCPP_PUBLIC void	collect_entities ()
	Gather all of the waitable entities from associated nodes and callback groups.

RCLCPP_PUBLIC void	wait_for_work (std::chrono::nanoseconds timeout=std::chrono::nanoseconds(-1))
	Block until more work becomes avilable or timeout is reached. More...

RCLCPP_PUBLIC bool	get_next_ready_executable (AnyExecutable &any_executable)
	Check for executable in ready state and populate union structure. More...

RCLCPP_PUBLIC 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. More...

void	trigger_entity_recollect (bool notify)
	This function triggers a recollect of all entities that are registered to the executor. More...

rclcpp::WaitSet wait_set_	RCPPUTILS_TSA_GUARDED_BY (mutex_)
	WaitSet to be waited on.

std::optional< rclcpp::WaitResult< rclcpp::WaitSet > > wait_result_	RCPPUTILS_TSA_GUARDED_BY (mutex_)

rclcpp::executors::ExecutorEntitiesCollection current_collection_	RCPPUTILS_TSA_GUARDED_BY (mutex_)
	Hold the current state of the collection being waited on by the waitset.

std::shared_ptr< rclcpp::executors::ExecutorNotifyWaitable > current_notify_waitable_	RCPPUTILS_TSA_GUARDED_BY (mutex_)
	Hold the current state of the notify waitable being waited on by the waitset.

Additional Inherited Members
Static Protected Member Functions inherited from rclcpp::Executor
static RCLCPP_PUBLIC void	execute_subscription (rclcpp::SubscriptionBase::SharedPtr subscription)
	Run subscription executable. More...

static RCLCPP_PUBLIC void	execute_timer (rclcpp::TimerBase::SharedPtr timer, const std::shared_ptr< void > &data_ptr)
	Run timer executable. More...

static RCLCPP_PUBLIC void	execute_service (rclcpp::ServiceBase::SharedPtr service)
	Run service server executable. More...

static RCLCPP_PUBLIC void	execute_client (rclcpp::ClientBase::SharedPtr client)
	Run service client executable. More...

Protected Attributes inherited from rclcpp::Executor
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.

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. More...

std::atomic_bool	entities_need_rebuild_

rclcpp::executors::ExecutorEntitiesCollector	collector_
	Collector used to associate executable entities from nodes and guard conditions.

rclcpp::OnShutdownCallbackHandle	shutdown_callback_handle_
	shutdown callback handle registered to Context

std::unique_ptr< ExecutorImplementation >	impl_
	Pointer to implementation.

Detailed Description

Static executor implementation.

This executor is a static version of the original single threaded executor. It's static because it doesn't reconstruct the executable list for every iteration. All nodes, callbackgroups, timers, subscriptions etc. are created before spin() is called, and modified only when an entity is added/removed to/from a node.

To run this executor instead of SingleThreadedExecutor replace: rclcpp::executors::SingleThreadedExecutor exec; by rclcpp::executors::StaticSingleThreadedExecutor exec; in your source code and spin node(s) in the following way: exec.add_node(node); exec.spin(); exec.remove_node(node);

Definition at line 47 of file static_single_threaded_executor.hpp.

Member Function Documentation

◆ execute_ready_executables()

bool StaticSingleThreadedExecutor::execute_ready_executables	(	const rclcpp::executors::ExecutorEntitiesCollection &	collection,
		rclcpp::WaitResult< rclcpp::WaitSet > &	wait_result,
		bool	spin_once
	)

protected

Executes ready executables from wait set.

Parameters

collection	entities to evaluate for ready executables.
wait_result	result to check for ready executables.
spin_once	if true executes only the first ready executable.

Returns: true if any executable was ready.

Definition at line 154 of file static_single_threaded_executor.cpp.

References rclcpp::WaitResult< WaitSetT >::clear_timer_with_index(), rclcpp::executors::ExecutorEntitiesCollection::clients, rclcpp::Executor::execute_client(), rclcpp::Executor::execute_service(), rclcpp::Executor::execute_subscription(), rclcpp::Executor::execute_timer(), rclcpp::WaitResult< WaitSetT >::kind(), rclcpp::WaitResult< WaitSetT >::next_ready_client(), rclcpp::WaitResult< WaitSetT >::next_ready_service(), rclcpp::WaitResult< WaitSetT >::next_ready_subscription(), rclcpp::WaitResult< WaitSetT >::next_ready_waitable(), rclcpp::WaitResult< WaitSetT >::peek_next_ready_timer(), rclcpp::executors::ExecutorEntitiesCollection::services, rclcpp::Executor::spin_once(), rclcpp::executors::ExecutorEntitiesCollection::subscriptions, rclcpp::executors::ExecutorEntitiesCollection::timers, and rclcpp::executors::ExecutorEntitiesCollection::waitables.

Here is the call graph for this function:

◆ spin()

void StaticSingleThreadedExecutor::spin ( )

overridevirtual

Static executor implementation of spin.

This function will block until work comes in, execute it, and keep blocking. It will only be interrupted by a CTRL-C (managed by the global signal handler).

Exceptions

std::runtime_error when spin() called while already spinning

Implements rclcpp::Executor.

Definition at line 31 of file static_single_threaded_executor.cpp.

References rclcpp::Executor::context_, rclcpp::ok(), and rclcpp::Executor::spinning.

Here is the call graph for this function:

◆ spin_all()

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

overridevirtual

Static executor implementation of spin all.

This non-blocking function will execute entities until timeout (must be >= 0) or no more work available. If timeout is 0, potentially it blocks forever until no more work is available. If new entities get ready while executing work available, they will be executed as long as the timeout hasn't expired.

Example: while(condition) { spin_all(); sleep(); // User should have some sync work or // sleep to avoid a 100% CPU usage }

Reimplemented from rclcpp::Executor.

Definition at line 57 of file static_single_threaded_executor.cpp.

◆ spin_some()

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

overridevirtual

Static executor implementation of spin some.

This non-blocking function will execute entities that were ready when this API was called, until timeout or no more work available. Entities that got ready while executing work, won't be taken into account here.

Example: while(condition) { spin_some(); sleep(); // User should have some sync work or // sleep to avoid a 100% CPU usage }

Reimplemented from rclcpp::Executor.

Definition at line 47 of file static_single_threaded_executor.cpp.

The documentation for this class was generated from the following files:

rclcpp/include/rclcpp/executors/static_single_threaded_executor.hpp
rclcpp/src/rclcpp/executors/static_single_threaded_executor.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ execute_ready_executables()

◆ spin()

◆ spin_all()

◆ spin_some()