diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-27 18:24:20 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-27 18:24:20 +0000 |
commit | 483eb2f56657e8e7f419ab1a4fab8dce9ade8609 (patch) | |
tree | e5d88d25d870d5dedacb6bbdbe2a966086a0a5cf /src/test/TestTimers.cc | |
parent | Initial commit. (diff) | |
download | ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.tar.xz ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.zip |
Adding upstream version 14.2.21.upstream/14.2.21upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/test/TestTimers.cc')
-rw-r--r-- | src/test/TestTimers.cc | 285 |
1 files changed, 285 insertions, 0 deletions
diff --git a/src/test/TestTimers.cc b/src/test/TestTimers.cc new file mode 100644 index 00000000..cf6ef4b5 --- /dev/null +++ b/src/test/TestTimers.cc @@ -0,0 +1,285 @@ +#include "common/ceph_argparse.h" +#include "common/Mutex.h" +#include "common/Timer.h" +#include "global/global_init.h" + +#include <iostream> + +/* + * TestTimers + * + * Tests the timer classes + */ +#define MAX_TEST_CONTEXTS 5 + +class TestContext; + +namespace +{ + int test_array[MAX_TEST_CONTEXTS]; + int array_idx; + TestContext* test_contexts[MAX_TEST_CONTEXTS]; + + Mutex array_lock("test_timers_mutex"); +} + +class TestContext : public Context +{ +public: + explicit TestContext(int num_) + : num(num_) + { + } + + void finish(int r) override + { + array_lock.Lock(); + cout << "TestContext " << num << std::endl; + test_array[array_idx++] = num; + array_lock.Unlock(); + } + + ~TestContext() override + { + } + +protected: + int num; +}; + +class StrictOrderTestContext : public TestContext +{ +public: + explicit StrictOrderTestContext (int num_) + : TestContext(num_) + { + } + + void finish(int r) override + { + array_lock.Lock(); + cout << "StrictOrderTestContext " << num << std::endl; + test_array[num] = num; + array_lock.Unlock(); + } + + ~StrictOrderTestContext() override + { + } +}; + +static void print_status(const char *str, int ret) +{ + cout << str << ": "; + cout << ((ret == 0) ? "SUCCESS" : "FAILURE"); + cout << std::endl; +} + +template <typename T> +static int basic_timer_test(T &timer, Mutex *lock) +{ + int ret = 0; + memset(&test_array, 0, sizeof(test_array)); + array_idx = 0; + memset(&test_contexts, 0, sizeof(test_contexts)); + + cout << __PRETTY_FUNCTION__ << std::endl; + + for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) { + test_contexts[i] = new TestContext(i); + } + + + for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) { + if (lock) + lock->Lock(); + utime_t inc(2 * i, 0); + utime_t t = ceph_clock_now() + inc; + timer.add_event_at(t, test_contexts[i]); + if (lock) + lock->Unlock(); + } + + bool done = false; + do { + sleep(1); + array_lock.Lock(); + done = (array_idx == MAX_TEST_CONTEXTS); + array_lock.Unlock(); + } while (!done); + + for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) { + if (test_array[i] != i) { + ret = 1; + cout << "error: expected test_array[" << i << "] = " << i + << "; got " << test_array[i] << " instead." << std::endl; + } + } + + return ret; +} + +static int test_out_of_order_insertion(SafeTimer &timer, Mutex *lock) +{ + int ret = 0; + memset(&test_array, 0, sizeof(test_array)); + array_idx = 0; + memset(&test_contexts, 0, sizeof(test_contexts)); + + cout << __PRETTY_FUNCTION__ << std::endl; + + test_contexts[0] = new StrictOrderTestContext(0); + test_contexts[1] = new StrictOrderTestContext(1); + + { + utime_t inc(100, 0); + utime_t t = ceph_clock_now() + inc; + lock->Lock(); + timer.add_event_at(t, test_contexts[0]); + lock->Unlock(); + } + + { + utime_t inc(2, 0); + utime_t t = ceph_clock_now() + inc; + lock->Lock(); + timer.add_event_at(t, test_contexts[1]); + lock->Unlock(); + } + + int secs = 0; + for (; secs < 100 ; ++secs) { + sleep(1); + array_lock.Lock(); + int a = test_array[1]; + array_lock.Unlock(); + if (a == 1) + break; + } + + if (secs == 100) { + ret = 1; + cout << "error: expected test_array[" << 1 << "] = " << 1 + << "; got " << test_array[1] << " instead." << std::endl; + } + + return ret; +} + +static int safe_timer_cancel_all_test(SafeTimer &safe_timer, Mutex& safe_timer_lock) +{ + cout << __PRETTY_FUNCTION__ << std::endl; + + int ret = 0; + memset(&test_array, 0, sizeof(test_array)); + array_idx = 0; + memset(&test_contexts, 0, sizeof(test_contexts)); + + for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) { + test_contexts[i] = new TestContext(i); + } + + safe_timer_lock.Lock(); + for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) { + utime_t inc(4 * i, 0); + utime_t t = ceph_clock_now() + inc; + safe_timer.add_event_at(t, test_contexts[i]); + } + safe_timer_lock.Unlock(); + + sleep(10); + + safe_timer_lock.Lock(); + safe_timer.cancel_all_events(); + safe_timer_lock.Unlock(); + + for (int i = 0; i < array_idx; ++i) { + if (test_array[i] != i) { + ret = 1; + cout << "error: expected test_array[" << i << "] = " << i + << "; got " << test_array[i] << " instead." << std::endl; + } + } + + return ret; +} + +static int safe_timer_cancellation_test(SafeTimer &safe_timer, Mutex& safe_timer_lock) +{ + cout << __PRETTY_FUNCTION__ << std::endl; + + int ret = 0; + memset(&test_array, 0, sizeof(test_array)); + array_idx = 0; + memset(&test_contexts, 0, sizeof(test_contexts)); + + for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) { + test_contexts[i] = new StrictOrderTestContext(i); + } + + safe_timer_lock.Lock(); + for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) { + utime_t inc(4 * i, 0); + utime_t t = ceph_clock_now() + inc; + safe_timer.add_event_at(t, test_contexts[i]); + } + safe_timer_lock.Unlock(); + + // cancel the even-numbered events + for (int i = 0; i < MAX_TEST_CONTEXTS; i += 2) { + safe_timer_lock.Lock(); + safe_timer.cancel_event(test_contexts[i]); + safe_timer_lock.Unlock(); + } + + sleep(20); + + safe_timer_lock.Lock(); + safe_timer.cancel_all_events(); + safe_timer_lock.Unlock(); + + for (int i = 1; i < array_idx; i += 2) { + if (test_array[i] != i) { + ret = 1; + cout << "error: expected test_array[" << i << "] = " << i + << "; got " << test_array[i] << " instead." << std::endl; + } + } + + return ret; +} + +int main(int argc, const char **argv) +{ + vector<const char*> args; + argv_to_vec(argc, argv, args); + + auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, + CODE_ENVIRONMENT_UTILITY, + CINIT_FLAG_NO_DEFAULT_CONFIG_FILE); + common_init_finish(g_ceph_context); + + int ret; + Mutex safe_timer_lock("safe_timer_lock"); + SafeTimer safe_timer(g_ceph_context, safe_timer_lock); + + ret = basic_timer_test <SafeTimer>(safe_timer, &safe_timer_lock); + if (ret) + goto done; + + ret = safe_timer_cancel_all_test(safe_timer, safe_timer_lock); + if (ret) + goto done; + + ret = safe_timer_cancellation_test(safe_timer, safe_timer_lock); + if (ret) + goto done; + + ret = test_out_of_order_insertion(safe_timer, &safe_timer_lock); + if (ret) + goto done; + +done: + print_status(argv[0], ret); + return ret; +} |