diff options
Diffstat (limited to 'tests/Timer_Queue_Test.cpp')
| -rw-r--r-- | tests/Timer_Queue_Test.cpp | 234 |
1 files changed, 106 insertions, 128 deletions
diff --git a/tests/Timer_Queue_Test.cpp b/tests/Timer_Queue_Test.cpp index aff963cec17..c985f5c762e 100644 --- a/tests/Timer_Queue_Test.cpp +++ b/tests/Timer_Queue_Test.cpp @@ -10,16 +10,13 @@ // // = DESCRIPTION // This is a simple test of <ACE_Timer_Queue> and four of its -// subclasses (<ACE_Timer_List>, <ACE_Timer_Heap>, -// <ACE_Timer_Wheel>, and <ACE_Timer_Hash>). The test sets up a -// bunch of timers and then adds them to a timer queue. The -// functionality of the timer queue is then tested. No command -// line arguments are needed to run the test. +// subclasses (<ACE_Timer_List>, <ACE_Timer_Heap>, <ACE_Timer_Wheel>, and +// <ACE_Timer_Hash>). The test sets up a bunch of timers and then adds +// them to a timer queue. The functionality of the timer queue is then +// tested. No command line arguments are needed to run the test. // // = AUTHORS -// Douglas C. Schmidt <schmidt@cs.wustl.edu>, -// Prashant Jain <pjain@cs.wustl.edu>, and -// Darrell Brunsch <brunsch@cs.wustl.edu> +// Douglas C. Schmidt, Prashant Jain, and Darrell Brunsch // // ============================================================================ @@ -55,9 +52,9 @@ randomize_array (T array[], size_t size) } } -// Number of iterations for the performance tests. Some platforms -// have a very high ACE_DEFAULT_TIMERS (HP-UX is 400), so limit this -// to a reasonable run time. +// Number of iterations for the performance tests. Some platforms have a very +// high ACE_DEFAULT_TIMERS (HP-UX is 400), so limit this to a reasonable run +// time. #if (ACE_DEFAULT_TIMERS > 20) static int max_iterations = 2000; #else @@ -83,8 +80,7 @@ public: const void *arg) { ACE_ASSERT (arg == (const void *) 42 || arg == (const void *)007); - - if (arg != (const void *) 42) + if (arg != (const void *)42) return -1; else return 0; @@ -103,17 +99,16 @@ test_functionality (ACE_Timer_Queue *tq) ACE_ASSERT (ACE_Time_Value::zero == ACE_Time_Value (0)); long timer_id, timer_id2; - // Do a test on earliest_time. + // Do a test on earliest_time + ACE_Time_Value earliest_time = tq->gettimeofday (); - timer_id = tq->schedule (&eh, - (const void *) 1, + timer_id = tq->schedule (&eh, (const void *) 1, earliest_time); ACE_OS::sleep (ACE_Time_Value (0, 10)); - timer_id2 = tq->schedule (&eh, - (const void *) 1, + timer_id2 = tq->schedule (&eh, (const void *) 1, tq->gettimeofday ()); ACE_ASSERT (tq->earliest_time () == earliest_time); @@ -121,51 +116,42 @@ test_functionality (ACE_Timer_Queue *tq) tq->cancel (timer_id); tq->cancel (timer_id2); - timer_id = tq->schedule (&eh, - (const void *) 1, + timer_id = tq->schedule (&eh, (const void *) 1, tq->gettimeofday ()); ACE_ASSERT (timer_id != -1); ACE_ASSERT (tq->is_empty () == 0); //== - ACE_ASSERT (tq->schedule (&eh, - (const void *) 42, - tq->gettimeofday ()) != -1); + ACE_ASSERT (tq->schedule (&eh, (const void *) 42, + tq->gettimeofday ()) != -1); ACE_ASSERT (tq->is_empty () == 0); //== - ACE_ASSERT (tq->schedule (&eh, - (const void *) 42, - tq->gettimeofday ()) != -1); + ACE_ASSERT (tq->schedule (&eh, (const void *) 42, + tq->gettimeofday ()) != -1); ACE_ASSERT (tq->is_empty () == 0); //== - // The following method will trigger a call to <handle_close>. ACE_ASSERT (tq->cancel (timer_id, 0, 0) == 1); ACE_ASSERT (tq->is_empty () == 0); ACE_ASSERT (tq->expire () == 2); - ACE_ASSERT (tq->schedule (&eh, - (const void *) 007, + ACE_ASSERT (tq->schedule (&eh, (const void *) 007, tq->gettimeofday ()) != -1); - ACE_ASSERT (tq->schedule (&eh, - (const void *) 42, + ACE_ASSERT (tq->schedule (&eh, (const void *) 42, tq->gettimeofday () + ACE_Time_Value (100)) != -1); - ACE_ASSERT (tq->schedule (&eh, - (const void *) 42, - tq->gettimeofday () + ACE_Time_Value (100)) != -1); - - // The following will trigger a call to <handle_close> when it - // cancels the second timer. This happens because the first timer - // has an <act> of 007, which causes eh.handle_timeout () to return - // -1. Since -1 is returned, all timers that use <eh> will be - // cancelled (and <handle_close> will only be called on the first - // timer that is cancelled). + ACE_ASSERT (tq->schedule (&eh, (const void *) 42, + tq->gettimeofday () + ACE_Time_Value (100)) != -1); + + // The following will trigger a call to <handle_close> when + // it cancels the second timer. This happens because the first + // timer has an <act> of 007, which causes eh.handle_timeout () to + // return -1. Since -1 is returned, all timers that use <eh> will + // be cancelled (and <handle_close> will only be called on the first + // timer that is cancelled). ACE_ASSERT (tq->expire () == 1); ACE_ASSERT (tq->is_empty () != 0); - ACE_ASSERT (tq->schedule (&eh, - (const void *) 4, + ACE_ASSERT (tq->schedule (&eh, (const void *) 4, tq->gettimeofday ()) != -1); - ACE_ASSERT (tq->schedule (&eh, - (const void *) 5, + ACE_ASSERT (tq->schedule (&eh, (const void *) 5, tq->gettimeofday ()) != -1); // The following method will trigger a call to <handle_close>. @@ -175,17 +161,14 @@ test_functionality (ACE_Timer_Queue *tq) // This tests to make sure that <handle_close> is called when there // is only one timer of the type in the queue - ACE_ASSERT (tq->schedule (&eh, - (const void *) 007, + ACE_ASSERT (tq->schedule (&eh, (const void *) 007, tq->gettimeofday ()) != -1); ACE_ASSERT (tq->expire () == 1); - timer_id = tq->schedule (&eh, - (const void *) 6, + timer_id = tq->schedule (&eh, (const void *) 6, tq->gettimeofday ()); ACE_ASSERT (timer_id != -1); - ACE_ASSERT (tq->schedule (&eh, - (const void *) 7, + ACE_ASSERT (tq->schedule (&eh, (const void *) 7, tq->gettimeofday ()) != -1); // The following method will *not* trigger a call to <handle_close>. @@ -237,7 +220,7 @@ test_performance (ACE_Timer_Queue *tq, max_iterations, test_name)); ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"), - et.real_time, et.user_time, et.system_time)); + et.real_time, et.user_time, et.system_time)); ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("time per call = %f usecs\n"), (et.user_time / ACE_timer_t (max_iterations)) * 1000000)); @@ -260,7 +243,7 @@ test_performance (ACE_Timer_Queue *tq, max_iterations, test_name)); ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"), - et.real_time, et.user_time, et.system_time)); + et.real_time, et.user_time, et.system_time)); ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("time per call = %f usecs\n"), (et.user_time / ACE_timer_t (max_iterations)) * 1000000)); @@ -283,10 +266,10 @@ test_performance (ACE_Timer_Queue *tq, timer.stop (); if (!tq->is_empty ()) - { - ACE_OS::sleep (ACE_Time_Value (1)); - tq->expire (); - } + { + ACE_OS::sleep (ACE_Time_Value (1)); + tq->expire (); + } ACE_ASSERT (tq->is_empty ()); @@ -321,10 +304,10 @@ test_performance (ACE_Timer_Queue *tq, tq->cancel (timer_ids[i]); if (!tq->is_empty ()) - { - ACE_OS::sleep (ACE_Time_Value (1)); - tq->expire (); - } + { + ACE_OS::sleep (ACE_Time_Value (1)); + tq->expire (); + } ACE_ASSERT (tq->is_empty ()); @@ -333,17 +316,14 @@ test_performance (ACE_Timer_Queue *tq, timer.elapsed_time (et); ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("time to randomly cancel %d timers for %s\n"), - max_iterations, - test_name)); + ASYS_TEXT ("time to randomly cancel %d timers for %s\n"), + max_iterations, test_name)); ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"), - et.real_time, - et.user_time, - et.system_time)); + ASYS_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"), + et.real_time, et.user_time, et.system_time)); ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("time per call = %f usecs\n"), - (et.user_time / ACE_timer_t (max_iterations)) * 1000000)); + ASYS_TEXT ("time per call = %f usecs\n"), + (et.user_time / ACE_timer_t (max_iterations)) * 1000000)); // Test the amount of time required to randomly schedule all the timers. @@ -373,9 +353,7 @@ test_performance (ACE_Timer_Queue *tq, max_iterations, test_name)); ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"), - et.real_time, - et.user_time, - et.system_time)); + et.real_time, et.user_time, et.system_time)); ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("time per call = %f usecs\n"), (et.user_time / ACE_timer_t (max_iterations)) * 1000000)); @@ -387,10 +365,10 @@ test_performance (ACE_Timer_Queue *tq, tq->expire (); if (!tq->is_empty ()) - { - ACE_OS::sleep (ACE_Time_Value (1)); - tq->expire (); - } + { + ACE_OS::sleep (ACE_Time_Value (1)); + tq->expire (); + } ACE_ASSERT (tq->is_empty ()); @@ -403,7 +381,7 @@ test_performance (ACE_Timer_Queue *tq, max_iterations, test_name)); ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"), - et.real_time, et.user_time, et.system_time)); + et.real_time, et.user_time, et.system_time)); ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("time per call = %f usecs\n"), (et.user_time / ACE_timer_t (max_iterations)) * 1000000)); @@ -411,23 +389,13 @@ test_performance (ACE_Timer_Queue *tq, delete [] times; } -class Timer_Queue_Stack +struct Timer_Queue_List { - // = TITLE - // Keeps track of the <Timer_Queue>s that we're going to test. - // - // = DESCRIPTION - // This data structure is organized as a stack to make it easy to implement. -public: - // = Initialization method - Timer_Queue_Stack (ACE_Timer_Queue *queue, - const ASYS_TCHAR *name, - Timer_Queue_Stack *next = NULL) + Timer_Queue_List (ACE_Timer_Queue *queue, const ASYS_TCHAR *name, Timer_Queue_List *next = NULL) : queue_ (queue), name_ (name), next_ (next) {} - // "Push" a new <queue> on the stack of <queue>s. ACE_Timer_Queue *queue_; // Pointer to the subclass of <ACE_Timer_Queue> that we're testing. @@ -435,8 +403,8 @@ public: const ASYS_TCHAR *name_; // Name of the Queue that we're testing. - Timer_Queue_Stack *next_; - // Pointer to the next <Timer_Queue>. + Timer_Queue_List *next_; + // Pointer to the next <Timer_Queues> structure }; int @@ -451,78 +419,88 @@ main (int argc, ASYS_TCHAR *argv[]) // = Perform initializations. - Timer_Queue_Stack *tq_stack = NULL; + Timer_Queue_List *tq_list = NULL; - // Add new Timer_Queue implementations here. Note that these will - // be executed in "reverse order" since we treat + // Add new Timer_Queue implementations here. + // Timer_Hash (Heap) - ACE_NEW_RETURN (tq_stack, - Timer_Queue_Stack (new ACE_Timer_Hash_Heap, - ASYS_TEXT ("ACE_Timer_Hash (Heap)"), - tq_stack), + + ACE_NEW_RETURN (tq_list, + Timer_Queue_List (new ACE_Timer_Hash_Heap, + ASYS_TEXT ("ACE_Timer_Hash (Heap)"), + tq_list), -1); // Timer_Hash - ACE_NEW_RETURN (tq_stack, - Timer_Queue_Stack (new ACE_Timer_Hash, - ASYS_TEXT ("ACE_Timer_Hash"), - tq_stack), + + ACE_NEW_RETURN (tq_list, + Timer_Queue_List (new ACE_Timer_Hash, + ASYS_TEXT ("ACE_Timer_Hash"), + tq_list), -1); - // Timer_stack - ACE_NEW_RETURN (tq_stack, - Timer_Queue_Stack (new ACE_Timer_List, - ASYS_TEXT ("ACE_Timer_List"), - tq_stack), + // Timer_List + + ACE_NEW_RETURN (tq_list, + Timer_Queue_List (new ACE_Timer_List, + ASYS_TEXT ("ACE_Timer_List"), + tq_list), -1); // Timer_Wheel without preallocated memory - ACE_NEW_RETURN (tq_stack, - Timer_Queue_Stack (new ACE_Timer_Wheel, - ASYS_TEXT ("ACE_Timer_Wheel (non-preallocated)"), - tq_stack), + + ACE_NEW_RETURN (tq_list, + Timer_Queue_List (new ACE_Timer_Wheel, + ASYS_TEXT ("ACE_Timer_Wheel (non-preallocated)"), + tq_list), -1); // Timer_Wheel with preallocated memory. - ACE_NEW_RETURN (tq_stack, - Timer_Queue_Stack (new ACE_Timer_Wheel (ACE_DEFAULT_TIMER_WHEEL_SIZE, + + ACE_NEW_RETURN (tq_list, + Timer_Queue_List (new ACE_Timer_Wheel (ACE_DEFAULT_TIMER_WHEEL_SIZE, ACE_DEFAULT_TIMER_WHEEL_RESOLUTION, max_iterations), - ASYS_TEXT ("ACE_Timer_Wheel (preallocated)"), - tq_stack), + ASYS_TEXT ("ACE_Timer_Wheel (preallocated)"), + tq_list), -1); + + + // Timer_Heap without preallocated memory. - ACE_NEW_RETURN (tq_stack, - Timer_Queue_Stack (new ACE_Timer_Heap, - ASYS_TEXT ("ACE_Timer_Heap (non-preallocated)"), - tq_stack), + + ACE_NEW_RETURN (tq_list, + Timer_Queue_List (new ACE_Timer_Heap, + ASYS_TEXT ("ACE_Timer_Heap (non-preallocated)"), + tq_list), -1); // Timer_Heap with preallocate memory. - ACE_NEW_RETURN (tq_stack, - Timer_Queue_Stack (new ACE_Timer_Heap (max_iterations, 1), - ASYS_TEXT ("ACE_Timer_Heap (preallocated)"), - tq_stack), + + ACE_NEW_RETURN (tq_list, + Timer_Queue_List (new ACE_Timer_Heap (max_iterations, 1), + ASYS_TEXT ("ACE_Timer_Heap (preallocated)"), + tq_list), -1); // Create the Timer ID array + ACE_NEW_RETURN (timer_ids, long[max_iterations], -1); - Timer_Queue_Stack *tq_ptr = tq_stack; + Timer_Queue_List *tq_ptr = tq_list; while (tq_ptr != NULL) { - ACE_DEBUG ((LM_DEBUG, - ASYS_TEXT ("**** starting test of %s\n"), + ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("**** starting test of %s\n"), tq_ptr->name_)); test_functionality (tq_ptr->queue_); test_performance (tq_ptr->queue_, tq_ptr->name_); delete tq_ptr->queue_; - Timer_Queue_Stack *temp = tq_ptr; + Timer_Queue_List *temp = tq_ptr; tq_ptr = tq_ptr->next_; delete temp; } |