diff --git a/rclcpp/include/rclcpp/executor.hpp b/rclcpp/include/rclcpp/executor.hpp index 7ddcc57..5353a37 100644 --- a/rclcpp/include/rclcpp/executor.hpp +++ b/rclcpp/include/rclcpp/executor.hpp @@ -344,8 +344,8 @@ protected: /// Guard condition for signaling the rmw layer to wake up for special events. rcl_guard_condition_t interrupt_guard_condition_ = rcl_get_zero_initialized_guard_condition(); - /// Waitset for managing entities that the rmw layer waits on. - rcl_wait_set_t waitset_ = rcl_get_zero_initialized_wait_set(); + /// Wait set for managing entities that the rmw layer waits on. + rcl_wait_set_t wait_set_ = rcl_get_zero_initialized_wait_set(); /// The memory strategy: an interface for handling user-defined memory allocation strategies. memory_strategy::MemoryStrategy::SharedPtr memory_strategy_; diff --git a/rclcpp/include/rclcpp/memory_strategy.hpp b/rclcpp/include/rclcpp/memory_strategy.hpp index bc9c87b..4e1523d 100644 --- a/rclcpp/include/rclcpp/memory_strategy.hpp +++ b/rclcpp/include/rclcpp/memory_strategy.hpp @@ -51,7 +51,7 @@ public: virtual size_t number_of_ready_timers() const = 0; virtual size_t number_of_guard_conditions() const = 0; - virtual bool add_handles_to_waitset(rcl_wait_set_t * wait_set) = 0; + virtual bool add_handles_to_wait_set(rcl_wait_set_t * wait_set) = 0; virtual void clear_handles() = 0; virtual void remove_null_handles(rcl_wait_set_t * wait_set) = 0; diff --git a/rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp b/rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp index 68e6644..cdbab7c 100644 --- a/rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp +++ b/rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp @@ -183,39 +183,39 @@ public: return has_invalid_weak_nodes; } - bool add_handles_to_waitset(rcl_wait_set_t * wait_set) + bool add_handles_to_wait_set(rcl_wait_set_t * wait_set) { for (auto subscription : subscription_handles_) { if (rcl_wait_set_add_subscription(wait_set, subscription) != RCL_RET_OK) { - fprintf(stderr, "Couldn't add subscription to waitset: %s\n", rcl_get_error_string_safe()); + fprintf(stderr, "Couldn't add subscription to wait set: %s\n", rcl_get_error_string_safe()); return false; } } for (auto client : client_handles_) { if (rcl_wait_set_add_client(wait_set, client) != RCL_RET_OK) { - fprintf(stderr, "Couldn't add client to waitset: %s\n", rcl_get_error_string_safe()); + fprintf(stderr, "Couldn't add client to wait set: %s\n", rcl_get_error_string_safe()); return false; } } for (auto service : service_handles_) { if (rcl_wait_set_add_service(wait_set, service) != RCL_RET_OK) { - fprintf(stderr, "Couldn't add service to waitset: %s\n", rcl_get_error_string_safe()); + fprintf(stderr, "Couldn't add service to wait set: %s\n", rcl_get_error_string_safe()); return false; } } for (auto timer : timer_handles_) { if (rcl_wait_set_add_timer(wait_set, timer) != RCL_RET_OK) { - fprintf(stderr, "Couldn't add timer to waitset: %s\n", rcl_get_error_string_safe()); + fprintf(stderr, "Couldn't add timer to wait set: %s\n", rcl_get_error_string_safe()); return false; } } for (auto guard_condition : guard_conditions_) { if (rcl_wait_set_add_guard_condition(wait_set, guard_condition) != RCL_RET_OK) { - fprintf(stderr, "Couldn't add guard_condition to waitset: %s\n", + fprintf(stderr, "Couldn't add guard_condition to wait set: %s\n", rcl_get_error_string_safe()); return false; } diff --git a/rclcpp/include/rclcpp/utilities.hpp b/rclcpp/include/rclcpp/utilities.hpp index ab8750b..36879a2 100644 --- a/rclcpp/include/rclcpp/utilities.hpp +++ b/rclcpp/include/rclcpp/utilities.hpp @@ -75,32 +75,32 @@ on_shutdown(std::function callback); /// Get a handle to the rmw guard condition that manages the signal handler. /** - * The first time that this function is called for a given waitset a new guard + * The first time that this function is called for a given wait set a new guard * condition will be created and returned; thereafter the same guard condition - * will be returned for the same waitset. This mechanism is designed to ensure - * that the same guard condition is not reused across waitsets (e.g., when + * will be returned for the same wait set. This mechanism is designed to ensure + * that the same guard condition is not reused across wait sets (e.g., when * using multiple executors in the same process). Will throw an exception if * initialization of the guard condition fails. - * \param waitset Pointer to the rcl_wait_set_t that will be using the + * \param wait_set Pointer to the rcl_wait_set_t that will be using the * resulting guard condition. * \return Pointer to the guard condition. */ RCLCPP_PUBLIC rcl_guard_condition_t * -get_sigint_guard_condition(rcl_wait_set_t * waitset); +get_sigint_guard_condition(rcl_wait_set_t * wait_set); /// Release the previously allocated guard condition that manages the signal handler. /** - * If you previously called get_sigint_guard_condition() for a given waitset + * If you previously called get_sigint_guard_condition() for a given wait set * to get a sigint guard condition, then you should call release_sigint_guard_condition() * when you're done, to free that condition. Will throw an exception if - * get_sigint_guard_condition() wasn't previously called for the given waitset. - * \param waitset Pointer to the rcl_wait_set_t that was using the + * get_sigint_guard_condition() wasn't previously called for the given wait set. + * \param wait_set Pointer to the rcl_wait_set_t that was using the * resulting guard condition. */ RCLCPP_PUBLIC void -release_sigint_guard_condition(rcl_wait_set_t * waitset); +release_sigint_guard_condition(rcl_wait_set_t * wait_set); /// Use the global condition variable to block for the specified amount of time. /** diff --git a/rclcpp/src/rclcpp/executor.cpp b/rclcpp/src/rclcpp/executor.cpp index f2cc48d..6334b5b 100644 --- a/rclcpp/src/rclcpp/executor.cpp +++ b/rclcpp/src/rclcpp/executor.cpp @@ -50,24 +50,24 @@ Executor::Executor(const ExecutorArgs & args) // and one for the executor's guard cond (interrupt_guard_condition_) // Put the global ctrl-c guard condition in - memory_strategy_->add_guard_condition(rclcpp::utilities::get_sigint_guard_condition(&waitset_)); + memory_strategy_->add_guard_condition(rclcpp::utilities::get_sigint_guard_condition(&wait_set_)); // Put the executor's guard condition in memory_strategy_->add_guard_condition(&interrupt_guard_condition_); rcl_allocator_t allocator = memory_strategy_->get_allocator(); if (rcl_wait_set_init( - &waitset_, 0, 2, 0, 0, 0, allocator) != RCL_RET_OK) + &wait_set_, 0, 2, 0, 0, 0, allocator) != RCL_RET_OK) { fprintf(stderr, - "[rclcpp::error] failed to create waitset: %s\n", rcl_get_error_string_safe()); + "[rclcpp::error] failed to create wait set: %s\n", rcl_get_error_string_safe()); rcl_reset_error(); if (rcl_guard_condition_fini(&interrupt_guard_condition_) != RCL_RET_OK) { fprintf(stderr, "[rclcpp::error] failed to destroy guard condition: %s\n", rcl_get_error_string_safe()); rcl_reset_error(); } - throw std::runtime_error("Failed to create waitset in Executor constructor"); + throw std::runtime_error("Failed to create wait set in Executor constructor"); } } @@ -83,10 +83,10 @@ Executor::~Executor() } weak_nodes_.clear(); - // Finalize the waitset. - if (rcl_wait_set_fini(&waitset_) != RCL_RET_OK) { + // Finalize the wait set. + if (rcl_wait_set_fini(&wait_set_) != RCL_RET_OK) { fprintf(stderr, - "[rclcpp::error] failed to destroy waitset: %s\n", rcl_get_error_string_safe()); + "[rclcpp::error] failed to destroy wait set: %s\n", rcl_get_error_string_safe()); rcl_reset_error(); } // Finalize the interrupt guard condition. @@ -97,8 +97,8 @@ Executor::~Executor() } // Remove and release the sigint guard condition memory_strategy_->remove_guard_condition( - rclcpp::utilities::get_sigint_guard_condition(&waitset_)); - rclcpp::utilities::release_sigint_guard_condition(&waitset_); + rclcpp::utilities::get_sigint_guard_condition(&wait_set_)); + rclcpp::utilities::release_sigint_guard_condition(&wait_set_); } void @@ -378,74 +378,74 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout) } if (rcl_wait_set_resize_subscriptions( - &waitset_, memory_strategy_->number_of_ready_subscriptions()) != RCL_RET_OK) + &wait_set_, memory_strategy_->number_of_ready_subscriptions()) != RCL_RET_OK) { throw std::runtime_error( - std::string("Couldn't resize the number of subscriptions in waitset : ") + + std::string("Couldn't resize the number of subscriptions in wait set : ") + rcl_get_error_string_safe()); } if (rcl_wait_set_resize_services( - &waitset_, memory_strategy_->number_of_ready_services()) != RCL_RET_OK) + &wait_set_, memory_strategy_->number_of_ready_services()) != RCL_RET_OK) { throw std::runtime_error( - std::string("Couldn't resize the number of services in waitset : ") + + std::string("Couldn't resize the number of services in wait set : ") + rcl_get_error_string_safe()); } if (rcl_wait_set_resize_clients( - &waitset_, memory_strategy_->number_of_ready_clients()) != RCL_RET_OK) + &wait_set_, memory_strategy_->number_of_ready_clients()) != RCL_RET_OK) { throw std::runtime_error( - std::string("Couldn't resize the number of clients in waitset : ") + + std::string("Couldn't resize the number of clients in wait set : ") + rcl_get_error_string_safe()); } if (rcl_wait_set_resize_guard_conditions( - &waitset_, memory_strategy_->number_of_guard_conditions()) != RCL_RET_OK) + &wait_set_, memory_strategy_->number_of_guard_conditions()) != RCL_RET_OK) { throw std::runtime_error( - std::string("Couldn't resize the number of guard_conditions in waitset : ") + + std::string("Couldn't resize the number of guard_conditions in wait set : ") + rcl_get_error_string_safe()); } if (rcl_wait_set_resize_timers( - &waitset_, memory_strategy_->number_of_ready_timers()) != RCL_RET_OK) + &wait_set_, memory_strategy_->number_of_ready_timers()) != RCL_RET_OK) { throw std::runtime_error( - std::string("Couldn't resize the number of timers in waitset : ") + + std::string("Couldn't resize the number of timers in wait set : ") + rcl_get_error_string_safe()); } - if (!memory_strategy_->add_handles_to_waitset(&waitset_)) { - throw std::runtime_error("Couldn't fill waitset"); + if (!memory_strategy_->add_handles_to_wait_set(&wait_set_)) { + throw std::runtime_error("Couldn't fill wait set"); } rcl_ret_t status = - rcl_wait(&waitset_, std::chrono::duration_cast(timeout).count()); + rcl_wait(&wait_set_, std::chrono::duration_cast(timeout).count()); if (status == RCL_RET_WAIT_SET_EMPTY) { - fprintf(stderr, "Warning: empty waitset received in rcl_wait(). This should never happen.\n"); + fprintf(stderr, "Warning: empty wait set received in rcl_wait(). This should never happen.\n"); } else if (status != RCL_RET_OK && status != RCL_RET_TIMEOUT) { using rclcpp::exceptions::throw_from_rcl_error; throw_from_rcl_error(status, "rcl_wait() failed"); } - // check the null handles in the waitset and remove them from the handles in memory strategy + // check the null handles in the wait set and remove them from the handles in memory strategy // for callback-based entities - memory_strategy_->remove_null_handles(&waitset_); - if (rcl_wait_set_clear_subscriptions(&waitset_) != RCL_RET_OK) { - throw std::runtime_error("Couldn't clear subscriptions from waitset"); + memory_strategy_->remove_null_handles(&wait_set_); + if (rcl_wait_set_clear_subscriptions(&wait_set_) != RCL_RET_OK) { + throw std::runtime_error("Couldn't clear subscriptions from wait set"); } - if (rcl_wait_set_clear_services(&waitset_) != RCL_RET_OK) { - throw std::runtime_error("Couldn't clear servicess from waitset"); + if (rcl_wait_set_clear_services(&wait_set_) != RCL_RET_OK) { + throw std::runtime_error("Couldn't clear servicess from wait set"); } - if (rcl_wait_set_clear_clients(&waitset_) != RCL_RET_OK) { - throw std::runtime_error("Couldn't clear clients from waitset"); + if (rcl_wait_set_clear_clients(&wait_set_) != RCL_RET_OK) { + throw std::runtime_error("Couldn't clear clients from wait set"); } - if (rcl_wait_set_clear_guard_conditions(&waitset_) != RCL_RET_OK) { - throw std::runtime_error("Couldn't clear guard conditions from waitset"); + if (rcl_wait_set_clear_guard_conditions(&wait_set_) != RCL_RET_OK) { + throw std::runtime_error("Couldn't clear guard conditions from wait set"); } - if (rcl_wait_set_clear_timers(&waitset_) != RCL_RET_OK) { - throw std::runtime_error("Couldn't clear timers from waitset"); + if (rcl_wait_set_clear_timers(&wait_set_) != RCL_RET_OK) { + throw std::runtime_error("Couldn't clear timers from wait set"); } } diff --git a/rclcpp/src/rclcpp/node_interfaces/node_services.cpp b/rclcpp/src/rclcpp/node_interfaces/node_services.cpp index 196404f..a2585e3 100644 --- a/rclcpp/src/rclcpp/node_interfaces/node_services.cpp +++ b/rclcpp/src/rclcpp/node_interfaces/node_services.cpp @@ -45,7 +45,8 @@ NodeServices::add_service( auto notify_guard_condition_lock = node_base_->acquire_notify_guard_condition_lock(); if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) { throw std::runtime_error( - std::string("Failed to notify waitset on service creation: ") + rmw_get_error_string() + std::string( + "Failed to notify wait set on service creation: ") + rmw_get_error_string() ); } } @@ -71,7 +72,7 @@ NodeServices::add_client( auto notify_guard_condition_lock = node_base_->acquire_notify_guard_condition_lock(); if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) { throw std::runtime_error( - std::string("Failed to notify waitset on client creation: ") + rmw_get_error_string() + std::string("Failed to notify wait set on client creation: ") + rmw_get_error_string() ); } } diff --git a/rclcpp/src/rclcpp/node_interfaces/node_timers.cpp b/rclcpp/src/rclcpp/node_interfaces/node_timers.cpp index b7176dc..6f781c0 100644 --- a/rclcpp/src/rclcpp/node_interfaces/node_timers.cpp +++ b/rclcpp/src/rclcpp/node_interfaces/node_timers.cpp @@ -42,6 +42,6 @@ NodeTimers::add_timer( if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) { throw std::runtime_error( std::string( - "Failed to notify waitset on timer creation: ") + rmw_get_error_string()); + "Failed to notify wait set on timer creation: ") + rmw_get_error_string()); } } diff --git a/rclcpp/src/rclcpp/node_interfaces/node_topics.cpp b/rclcpp/src/rclcpp/node_interfaces/node_topics.cpp index 857a71c..4e07d5e 100644 --- a/rclcpp/src/rclcpp/node_interfaces/node_topics.cpp +++ b/rclcpp/src/rclcpp/node_interfaces/node_topics.cpp @@ -74,7 +74,7 @@ NodeTopics::add_publisher( if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) { throw std::runtime_error( std::string( - "Failed to notify waitset on publisher creation: ") + rmw_get_error_string()); + "Failed to notify wait set on publisher creation: ") + rmw_get_error_string()); } } } @@ -124,7 +124,7 @@ NodeTopics::add_subscription( if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) { throw std::runtime_error( std::string( - "Failed to notify waitset on subscription creation: ") + rmw_get_error_string() + "Failed to notify wait set on subscription creation: ") + rmw_get_error_string() ); } } diff --git a/rclcpp/src/rclcpp/utilities.cpp b/rclcpp/src/rclcpp/utilities.cpp index 22132cf..8f07a96 100644 --- a/rclcpp/src/rclcpp/utilities.cpp +++ b/rclcpp/src/rclcpp/utilities.cpp @@ -218,10 +218,10 @@ rclcpp::utilities::on_shutdown(std::function callback) } rcl_guard_condition_t * -rclcpp::utilities::get_sigint_guard_condition(rcl_wait_set_t * waitset) +rclcpp::utilities::get_sigint_guard_condition(rcl_wait_set_t * wait_set) { std::lock_guard lock(g_sigint_guard_cond_handles_mutex); - auto kv = g_sigint_guard_cond_handles.find(waitset); + auto kv = g_sigint_guard_cond_handles.find(wait_set); if (kv != g_sigint_guard_cond_handles.end()) { return &kv->second; } else { @@ -234,16 +234,16 @@ rclcpp::utilities::get_sigint_guard_condition(rcl_wait_set_t * waitset) "Couldn't initialize guard condition: ") + rcl_get_error_string_safe()); // *INDENT-ON* } - g_sigint_guard_cond_handles[waitset] = handle; - return &g_sigint_guard_cond_handles[waitset]; + g_sigint_guard_cond_handles[wait_set] = handle; + return &g_sigint_guard_cond_handles[wait_set]; } } void -rclcpp::utilities::release_sigint_guard_condition(rcl_wait_set_t * waitset) +rclcpp::utilities::release_sigint_guard_condition(rcl_wait_set_t * wait_set) { std::lock_guard lock(g_sigint_guard_cond_handles_mutex); - auto kv = g_sigint_guard_cond_handles.find(waitset); + auto kv = g_sigint_guard_cond_handles.find(wait_set); if (kv != g_sigint_guard_cond_handles.end()) { if (rcl_guard_condition_fini(&kv->second) != RCL_RET_OK) { // *INDENT-OFF* (prevent uncrustify from making unnecessary indents here) @@ -256,7 +256,7 @@ rclcpp::utilities::release_sigint_guard_condition(rcl_wait_set_t * waitset) } else { // *INDENT-OFF* (prevent uncrustify from making unnecessary indents here) throw std::runtime_error(std::string( - "Tried to release sigint guard condition for nonexistent waitset")); + "Tried to release sigint guard condition for nonexistent wait set")); // *INDENT-ON* } }