From 9f3bdbf99e79c48481e7cf074a175f280282e189 Mon Sep 17 00:00:00 2001 From: Tully Foote Date: Thu, 2 Nov 2017 14:38:26 -0700 Subject: [PATCH] Implement custom allocators for clock. Store the allocator for the rcl_clock inside the datastructure to not require passing it into the fini. --- rcl/include/rcl/time.h | 36 ++++++++---- rcl/src/rcl/time.c | 52 +++++++++++------ rcl/test/rcl/test_time.cpp | 111 +++++++++++++++++-------------------- 3 files changed, 110 insertions(+), 89 deletions(-) diff --git a/rcl/include/rcl/time.h b/rcl/include/rcl/time.h index 7b46398..6c45485 100644 --- a/rcl/include/rcl/time.h +++ b/rcl/include/rcl/time.h @@ -20,6 +20,7 @@ extern "C" { #endif +#include "rcl/allocator.h" #include "rcl/macros.h" #include "rcl/types.h" #include "rcl/visibility_control.h" @@ -62,10 +63,9 @@ typedef struct rcl_clock_t rcl_ret_t (* get_now)(void * data, rcl_time_point_value_t * now); // void (*set_now) (rcl_time_point_value_t); void * data; + rcl_allocator_t * allocator; } rcl_clock_t; -struct rcl_ros_clock_storage_t; - /// A single point in time, measured in nanoseconds, the reference point is based on the source. typedef struct rcl_time_point_t { @@ -109,6 +109,7 @@ rcl_clock_valid(rcl_clock_t * clock); * * \param[in] clock_type the type identifying the time source to provide * \param[in] clock the handle to the clock which is being initialized + * \param[in] allocator The allocator to use for allocations * \return `RCL_RET_OK` if the time source was successfully initialized, or * \return `RCL_RET_INVALID_ARGUMENT` if any arguments are invalid, or * \return `RCL_RET_ERROR` an unspecified error occur. @@ -117,8 +118,8 @@ RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t rcl_clock_init( - enum rcl_clock_type_t clock_type, rcl_clock_t * clock -); + enum rcl_clock_type_t clock_type, rcl_clock_t * clock, + const rcl_allocator_t * allocator); /// Finalize a clock. /** @@ -136,7 +137,8 @@ rcl_clock_init( RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t -rcl_clock_fini(rcl_clock_t * clock); +rcl_clock_fini( + rcl_clock_t * clock); /// Initialize a clock as a RCL_ROS_TIME time source. /** @@ -144,6 +146,7 @@ rcl_clock_fini(rcl_clock_t * clock); * It is specifically setting up a RCL_ROS_TIME time source. * * \param[in] clock the handle to the clock which is being initialized + * \param[in] allocator The allocator to use for allocations * \return `RCL_RET_OK` if the time source was successfully initialized, or * \return `RCL_RET_INVALID_ARGUMENT` if any arguments are invalid, or * \return `RCL_RET_ERROR` an unspecified error occur. @@ -151,7 +154,9 @@ rcl_clock_fini(rcl_clock_t * clock); RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t -rcl_ros_clock_init(rcl_clock_t * clock); +rcl_ros_clock_init( + rcl_clock_t * clock, + const rcl_allocator_t * allocator); /// Finalize a clock as a `RCL_ROS_TIME` time source. /** @@ -167,7 +172,8 @@ rcl_ros_clock_init(rcl_clock_t * clock); RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t -rcl_ros_clock_fini(rcl_clock_t * clock); +rcl_ros_clock_fini( + rcl_clock_t * clock); /// Initialize a clock as a `RCL_STEADY_TIME` time source. /** @@ -175,6 +181,7 @@ rcl_ros_clock_fini(rcl_clock_t * clock); * It is specifically setting up a `RCL_STEADY_TIME` time source. * * \param[in] clock the handle to the clock which is being initialized + * \param[in] allocator The allocator to use for allocations * \return `RCL_RET_OK` if the time source was successfully initialized, or * \return `RCL_RET_INVALID_ARGUMENT` if any arguments are invalid, or * \return `RCL_RET_ERROR` an unspecified error occur. @@ -182,7 +189,9 @@ rcl_ros_clock_fini(rcl_clock_t * clock); RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t -rcl_steady_clock_init(rcl_clock_t * clock); +rcl_steady_clock_init( + rcl_clock_t * clock, + const rcl_allocator_t * allocator); /// Finalize a clock as a `RCL_STEADY_TIME` time source. /** @@ -200,7 +209,8 @@ rcl_steady_clock_init(rcl_clock_t * clock); RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t -rcl_steady_clock_fini(rcl_clock_t * clock); +rcl_steady_clock_fini( + rcl_clock_t * clock); /// Initialize a clock as a `RCL_SYSTEM_TIME` time source. /** @@ -210,6 +220,7 @@ rcl_steady_clock_fini(rcl_clock_t * clock); * It is specifically setting up a system time source. * * \param[in] clock the handle to the clock which is being initialized + * \param[in] allocator The allocator to use for allocations * \return `RCL_RET_OK` if the time source was successfully initialized, or * \return `RCL_RET_INVALID_ARGUMENT` if any arguments are invalid, or * \return `RCL_RET_ERROR` an unspecified error occur. @@ -217,7 +228,9 @@ rcl_steady_clock_fini(rcl_clock_t * clock); RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t -rcl_system_clock_init(rcl_clock_t * clock); +rcl_system_clock_init( + rcl_clock_t * clock, + const rcl_allocator_t * allocator); /// Finalize a clock as a `RCL_SYSTEM_TIME` time source. /** @@ -235,7 +248,8 @@ rcl_system_clock_init(rcl_clock_t * clock); RCL_PUBLIC RCL_WARN_UNUSED rcl_ret_t -rcl_system_clock_fini(rcl_clock_t * clock); +rcl_system_clock_fini( + rcl_clock_t * clock); /// Initialize a duration using the clock. /** diff --git a/rcl/src/rcl/time.c b/rcl/src/rcl/time.c index 6b02e9d..81f6417 100644 --- a/rcl/src/rcl/time.c +++ b/rcl/src/rcl/time.c @@ -29,7 +29,6 @@ typedef struct rcl_ros_clock_storage_t { atomic_uint_least64_t current_time; bool active; - // TODO(tfoote): store subscription here } rcl_ros_clock_storage_t; // Implementation only @@ -86,9 +85,10 @@ rcl_clock_valid(rcl_clock_t * clock) rcl_ret_t rcl_clock_init( - enum rcl_clock_type_t clock_type, rcl_clock_t * clock -) + enum rcl_clock_type_t clock_type, rcl_clock_t * clock, + const rcl_allocator_t * allocator) { + RCL_CHECK_ARGUMENT_FOR_NULL(allocator, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); switch (clock_type) { case RCL_CLOCK_UNINITIALIZED: RCL_CHECK_ARGUMENT_FOR_NULL( @@ -96,18 +96,19 @@ rcl_clock_init( rcl_init_generic_clock(clock); return RCL_RET_OK; case RCL_ROS_TIME: - return rcl_ros_clock_init(clock); + return rcl_ros_clock_init(clock, allocator); case RCL_SYSTEM_TIME: - return rcl_system_clock_init(clock); + return rcl_system_clock_init(clock, allocator); case RCL_STEADY_TIME: - return rcl_steady_clock_init(clock); + return rcl_steady_clock_init(clock, allocator); default: return RCL_RET_INVALID_ARGUMENT; } } rcl_ret_t -rcl_clock_fini(rcl_clock_t * clock) +rcl_clock_fini( + rcl_clock_t * clock) { switch (clock->type) { case RCL_ROS_TIME: @@ -124,40 +125,52 @@ rcl_clock_fini(rcl_clock_t * clock) } rcl_ret_t -rcl_ros_clock_init(rcl_clock_t * clock) +rcl_ros_clock_init( + rcl_clock_t * clock, + const rcl_allocator_t * allocator) { RCL_CHECK_ARGUMENT_FOR_NULL(clock, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); + RCL_CHECK_ARGUMENT_FOR_NULL(allocator, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); rcl_init_generic_clock(clock); - clock->data = calloc(1, sizeof(rcl_ros_clock_storage_t)); + clock->data = allocator->allocate(sizeof(rcl_ros_clock_storage_t), allocator->state); + rcl_ros_clock_storage_t * storage = (rcl_ros_clock_storage_t *)clock->data; + storage->active = false; clock->get_now = rcl_get_ros_time; clock->type = RCL_ROS_TIME; + clock->allocator = allocator; return RCL_RET_OK; } rcl_ret_t -rcl_ros_clock_fini(rcl_clock_t * clock) +rcl_ros_clock_fini( + rcl_clock_t * clock) { RCL_CHECK_ARGUMENT_FOR_NULL(clock, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); if (clock->type != RCL_ROS_TIME) { RCL_SET_ERROR_MSG("clock not of type RCL_ROS_TIME", rcl_get_default_allocator()); return RCL_RET_ERROR; } - free((rcl_ros_clock_storage_t *)clock->data); + clock->allocator->deallocate((rcl_ros_clock_storage_t *)clock->data, clock->allocator->state); return RCL_RET_OK; } rcl_ret_t -rcl_steady_clock_init(rcl_clock_t * clock) +rcl_steady_clock_init( + rcl_clock_t * clock, + const rcl_allocator_t * allocator) { RCL_CHECK_ARGUMENT_FOR_NULL(clock, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); + RCL_CHECK_ARGUMENT_FOR_NULL(allocator, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); rcl_init_generic_clock(clock); clock->get_now = rcl_get_steady_time; clock->type = RCL_STEADY_TIME; + clock->allocator = allocator; return RCL_RET_OK; } rcl_ret_t -rcl_steady_clock_fini(rcl_clock_t * clock) +rcl_steady_clock_fini( + rcl_clock_t * clock) { RCL_CHECK_ARGUMENT_FOR_NULL(clock, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); if (clock->type != RCL_STEADY_TIME) { @@ -168,17 +181,22 @@ rcl_steady_clock_fini(rcl_clock_t * clock) } rcl_ret_t -rcl_system_clock_init(rcl_clock_t * clock) +rcl_system_clock_init( + rcl_clock_t * clock, + const rcl_allocator_t * allocator) { RCL_CHECK_ARGUMENT_FOR_NULL(clock, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); + RCL_CHECK_ARGUMENT_FOR_NULL(allocator, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); rcl_init_generic_clock(clock); clock->get_now = rcl_get_system_time; clock->type = RCL_SYSTEM_TIME; + clock->allocator = allocator; return RCL_RET_OK; } rcl_ret_t -rcl_system_clock_fini(rcl_clock_t * clock) +rcl_system_clock_fini( + rcl_clock_t * clock) { RCL_CHECK_ARGUMENT_FOR_NULL(clock, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); if (clock->type != RCL_SYSTEM_TIME) { @@ -229,7 +247,6 @@ rcl_difference_times( rcl_ret_t rcl_clock_get_now(rcl_clock_t * clock, rcl_time_point_t * time_point) { - // TODO(tfoote) switch to use external time source RCL_CHECK_ARGUMENT_FOR_NULL(time_point, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()); if (clock->type && clock->get_now) { return clock->get_now(clock->data, @@ -250,8 +267,7 @@ rcl_enable_ros_time_override(rcl_clock_t * clock) "Time source is not RCL_ROS_TIME cannot enable override.", rcl_get_default_allocator()) return RCL_RET_ERROR; } - rcl_ros_clock_storage_t * storage = \ - (rcl_ros_clock_storage_t *)clock->data; + rcl_ros_clock_storage_t * storage = (rcl_ros_clock_storage_t *)clock->data; if (!storage) { RCL_SET_ERROR_MSG("Storage not initialized, cannot enable.", rcl_get_default_allocator()) return RCL_RET_ERROR; diff --git a/rcl/test/rcl/test_time.cpp b/rcl/test/rcl/test_time.cpp index fe89f43..d3faad2 100644 --- a/rcl/test/rcl/test_time.cpp +++ b/rcl/test/rcl/test_time.cpp @@ -56,9 +56,9 @@ public: // Tests the rcl_set_ros_time_override() function. TEST_F(CLASSNAME(TestTimeFixture, RMW_IMPLEMENTATION), test_rcl_ros_time_set_override) { - rcl_clock_t * ros_clock = - reinterpret_cast(calloc(1, sizeof(rcl_clock_t))); - rcl_ret_t retval = rcl_ros_clock_init(ros_clock); + rcl_clock_t ros_clock; + rcl_allocator_t allocator = rcl_get_default_allocator(); + rcl_ret_t retval = rcl_ros_clock_init(&ros_clock, &allocator); EXPECT_EQ(retval, RCL_RET_OK) << rcl_get_error_string_safe(); assert_no_realloc_begin(); @@ -71,7 +71,7 @@ TEST_F(CLASSNAME(TestTimeFixture, RMW_IMPLEMENTATION), test_rcl_ros_time_set_ove ret = rcl_is_enabled_ros_time_override(nullptr, &result); EXPECT_EQ(ret, RCL_RET_INVALID_ARGUMENT) << rcl_get_error_string_safe(); rcl_reset_error(); - ret = rcl_is_enabled_ros_time_override(ros_clock, nullptr); + ret = rcl_is_enabled_ros_time_override(&ros_clock, nullptr); EXPECT_EQ(ret, RCL_RET_INVALID_ARGUMENT) << rcl_get_error_string_safe(); rcl_reset_error(); ret = rcl_is_enabled_ros_time_override(nullptr, nullptr); @@ -79,13 +79,13 @@ TEST_F(CLASSNAME(TestTimeFixture, RMW_IMPLEMENTATION), test_rcl_ros_time_set_ove rcl_reset_error(); rcl_time_point_t query_now; bool is_enabled; - ret = rcl_is_enabled_ros_time_override(ros_clock, &is_enabled); + ret = rcl_is_enabled_ros_time_override(&ros_clock, &is_enabled); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(is_enabled, false); assert_no_malloc_begin(); assert_no_free_begin(); // Check for normal operation (not allowed to alloc). - ret = rcl_clock_get_now(ros_clock, &query_now); + ret = rcl_clock_get_now(&ros_clock, &query_now); assert_no_malloc_end(); assert_no_realloc_end(); assert_no_free_end(); @@ -93,7 +93,7 @@ TEST_F(CLASSNAME(TestTimeFixture, RMW_IMPLEMENTATION), test_rcl_ros_time_set_ove EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_NE(query_now.nanoseconds, 0u); // Compare to std::chrono::system_clock time (within a second). - ret = rcl_clock_get_now(ros_clock, &query_now); + ret = rcl_clock_get_now(&ros_clock, &query_now); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); { std::chrono::system_clock::time_point now_sc = std::chrono::system_clock::now(); @@ -106,18 +106,18 @@ TEST_F(CLASSNAME(TestTimeFixture, RMW_IMPLEMENTATION), test_rcl_ros_time_set_ove // Test ros time specific APIs rcl_time_point_value_t set_point = 1000000000ull; // Check initialized state - ret = rcl_is_enabled_ros_time_override(ros_clock, &is_enabled); + ret = rcl_is_enabled_ros_time_override(&ros_clock, &is_enabled); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(is_enabled, false); // set the time point - ret = rcl_set_ros_time_override(ros_clock, set_point); + ret = rcl_set_ros_time_override(&ros_clock, set_point); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); // check still disabled - ret = rcl_is_enabled_ros_time_override(ros_clock, &is_enabled); + ret = rcl_is_enabled_ros_time_override(&ros_clock, &is_enabled); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(is_enabled, false); // get real - ret = rcl_clock_get_now(ros_clock, &query_now); + ret = rcl_clock_get_now(&ros_clock, &query_now); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); { std::chrono::system_clock::time_point now_sc = std::chrono::system_clock::now(); @@ -128,25 +128,25 @@ TEST_F(CLASSNAME(TestTimeFixture, RMW_IMPLEMENTATION), test_rcl_ros_time_set_ove EXPECT_LE(llabs(now_diff), RCL_MS_TO_NS(k_tolerance_ms)) << "ros_clock differs"; } // enable - ret = rcl_enable_ros_time_override(ros_clock); + ret = rcl_enable_ros_time_override(&ros_clock); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); // check enabled - ret = rcl_is_enabled_ros_time_override(ros_clock, &is_enabled); + ret = rcl_is_enabled_ros_time_override(&ros_clock, &is_enabled); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(is_enabled, true); // get sim - ret = rcl_clock_get_now(ros_clock, &query_now); + ret = rcl_clock_get_now(&ros_clock, &query_now); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(query_now.nanoseconds, set_point); // disable - ret = rcl_disable_ros_time_override(ros_clock); + ret = rcl_disable_ros_time_override(&ros_clock); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); // check disabled - ret = rcl_is_enabled_ros_time_override(ros_clock, &is_enabled); + ret = rcl_is_enabled_ros_time_override(&ros_clock, &is_enabled); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(is_enabled, false); // get real - ret = rcl_clock_get_now(ros_clock, &query_now); + ret = rcl_clock_get_now(&ros_clock, &query_now); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); { std::chrono::system_clock::time_point now_sc = std::chrono::system_clock::now(); @@ -159,42 +159,25 @@ TEST_F(CLASSNAME(TestTimeFixture, RMW_IMPLEMENTATION), test_rcl_ros_time_set_ove } TEST_F(CLASSNAME(TestTimeFixture, RMW_IMPLEMENTATION), test_rcl_init_for_clock_and_point) { - assert_no_realloc_begin(); rcl_ret_t ret; + rcl_allocator_t allocator = rcl_get_default_allocator(); // Check for invalid argument error condition (allowed to alloc). - ret = rcl_ros_clock_init(nullptr); + ret = rcl_ros_clock_init(nullptr, &allocator); + EXPECT_EQ(ret, RCL_RET_INVALID_ARGUMENT) << rcl_get_error_string_safe(); + rcl_reset_error(); + // Check for invalid argument error condition (allowed to alloc). + rcl_clock_t uninitialized_clock; + ret = rcl_ros_clock_init(&uninitialized_clock, nullptr); EXPECT_EQ(ret, RCL_RET_INVALID_ARGUMENT) << rcl_get_error_string_safe(); rcl_reset_error(); // Check for normal operation (not allowed to alloc). rcl_clock_t source; - ret = rcl_ros_clock_init(&source); + ret = rcl_ros_clock_init(&source, &allocator); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); - rcl_clock_t * ros_clock = - reinterpret_cast(calloc(1, sizeof(rcl_clock_t))); - rcl_ret_t retval = rcl_ros_clock_init(ros_clock); + rcl_clock_t ros_clock; + rcl_ret_t retval = rcl_ros_clock_init(&ros_clock, &allocator); EXPECT_EQ(retval, RCL_RET_OK) << rcl_get_error_string_safe(); - - // assert_no_malloc_begin(); - // assert_no_free_begin(); - // // Do stuff in here - // assert_no_malloc_end(); - // assert_no_realloc_end(); - // assert_no_free_end(); - // stop_memory_checking(); - // EXPECT_NE(now.nanoseconds, 0u); - // // Compare to std::chrono::system_clock time (within a second). - // now = {0}; - // ret = rcutils_system_time_now(&now); - // { - // std::chrono::system_clock::time_point now_sc = std::chrono::system_clock::now(); - // auto now_ns = std::chrono::duration_cast( - // now_sc.time_since_epoch()); - // int64_t now_ns_int = now_ns.count(); - // int64_t now_diff = now.nanoseconds - now_ns_int; - // const int k_tolerance_ms = 1000; - // EXPECT_LE(llabs(now_diff), RCL_MS_TO_NS(k_tolerance_ms)) << "system_clock differs"; - // } } TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), clock_validation) { @@ -202,43 +185,45 @@ TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), clock_validation) { rcl_clock_t uninitialized; // Not reliably detectable due to random values. // ASSERT_FALSE(rcl_clock_valid(&uninitialized)); + rcl_allocator_t allocator = rcl_get_default_allocator(); rcl_ret_t ret; - ret = rcl_ros_clock_init(&uninitialized); + ret = rcl_ros_clock_init(&uninitialized, &allocator); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); } TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), default_clock_instanciation) { - rcl_clock_t * ros_clock = - reinterpret_cast(calloc(1, sizeof(rcl_clock_t))); - rcl_ret_t retval = rcl_ros_clock_init(ros_clock); + rcl_clock_t ros_clock; + rcl_allocator_t allocator = rcl_get_default_allocator(); + rcl_ret_t retval = rcl_ros_clock_init(&ros_clock, &allocator); EXPECT_EQ(retval, RCL_RET_OK) << rcl_get_error_string_safe(); - ASSERT_TRUE(rcl_clock_valid(ros_clock)); + ASSERT_TRUE(rcl_clock_valid(&ros_clock)); rcl_clock_t * steady_clock = reinterpret_cast(calloc(1, sizeof(rcl_clock_t))); - retval = rcl_steady_clock_init(steady_clock); + retval = rcl_steady_clock_init(steady_clock, &allocator); EXPECT_EQ(retval, RCL_RET_OK) << rcl_get_error_string_safe(); ASSERT_TRUE(rcl_clock_valid(steady_clock)); rcl_clock_t * system_clock = reinterpret_cast(calloc(1, sizeof(rcl_clock_t))); - retval = rcl_system_clock_init(system_clock); + retval = rcl_system_clock_init(system_clock, &allocator); EXPECT_EQ(retval, RCL_RET_OK) << rcl_get_error_string_safe(); ASSERT_TRUE(rcl_clock_valid(system_clock)); } TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), specific_clock_instantiation) { + rcl_allocator_t allocator = rcl_get_default_allocator(); { rcl_clock_t uninitialized_clock; rcl_ret_t ret = rcl_clock_init( - RCL_CLOCK_UNINITIALIZED, &uninitialized_clock); + RCL_CLOCK_UNINITIALIZED, &uninitialized_clock, &allocator); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(uninitialized_clock.type, RCL_CLOCK_UNINITIALIZED) << "Expected time source of type RCL_CLOCK_UNINITIALIZED"; } { rcl_clock_t ros_clock; - rcl_ret_t ret = rcl_clock_init(RCL_ROS_TIME, &ros_clock); + rcl_ret_t ret = rcl_clock_init(RCL_ROS_TIME, &ros_clock, &allocator); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(ros_clock.type, RCL_ROS_TIME) << "Expected time source of type RCL_ROS_TIME"; @@ -247,7 +232,7 @@ TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), specific_clock_instantiation) { } { rcl_clock_t system_clock; - rcl_ret_t ret = rcl_clock_init(RCL_SYSTEM_TIME, &system_clock); + rcl_ret_t ret = rcl_clock_init(RCL_SYSTEM_TIME, &system_clock, &allocator); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(system_clock.type, RCL_SYSTEM_TIME) << "Expected time source of type RCL_SYSTEM_TIME"; @@ -256,7 +241,7 @@ TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), specific_clock_instantiation) { } { rcl_clock_t steady_clock; - rcl_ret_t ret = rcl_clock_init(RCL_STEADY_TIME, &steady_clock); + rcl_ret_t ret = rcl_clock_init(RCL_STEADY_TIME, &steady_clock, &allocator); EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_EQ(steady_clock.type, RCL_STEADY_TIME) << "Expected time source of type RCL_STEADY_TIME"; @@ -266,9 +251,10 @@ TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), specific_clock_instantiation) { } TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), rcl_time_difference) { + rcl_allocator_t allocator = rcl_get_default_allocator(); rcl_clock_t * ros_clock = - reinterpret_cast(calloc(1, sizeof(rcl_clock_t))); - rcl_ret_t retval = rcl_ros_clock_init(ros_clock); + reinterpret_cast(allocator.allocate(sizeof(rcl_clock_t), allocator.state)); + rcl_ret_t retval = rcl_ros_clock_init(ros_clock, &allocator); EXPECT_EQ(retval, RCL_RET_OK) << rcl_get_error_string_safe(); EXPECT_TRUE(ros_clock != nullptr); EXPECT_TRUE(ros_clock->data != nullptr); @@ -312,11 +298,17 @@ void post_callback(void) post_callback_called = true; } +void reset_callback_triggers(void) +{ + pre_callback_called = false; + post_callback_called = false; +} TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), rcl_time_update_callbacks) { + rcl_allocator_t allocator = rcl_get_default_allocator(); rcl_clock_t * ros_clock = - reinterpret_cast(calloc(1, sizeof(rcl_clock_t))); - rcl_ret_t retval = rcl_ros_clock_init(ros_clock); + reinterpret_cast(allocator.allocate(sizeof(rcl_clock_t), allocator.state)); + rcl_ret_t retval = rcl_ros_clock_init(ros_clock, &allocator); EXPECT_EQ(retval, RCL_RET_OK) << rcl_get_error_string_safe(); rcl_time_point_t query_now; rcl_ret_t ret; @@ -326,7 +318,6 @@ TEST(CLASSNAME(rcl_time, RMW_IMPLEMENTATION), rcl_time_update_callbacks) { ros_clock->pre_update = pre_callback; ros_clock->post_update = post_callback; - EXPECT_FALSE(pre_callback_called); EXPECT_FALSE(post_callback_called);