ACE/tests/Timer_Queue_Test.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Timer_Queue_Test.cpp
   5  *
   6  *    This is a simple test of <ACE_Timer_Queue> and four of its
   7  *    subclasses (<ACE_Timer_List>, <ACE_Timer_Heap>,
   8  *    <ACE_Timer_Wheel>, and <ACE_Timer_Hash>).  The test sets up a
   9  *    bunch of timers and then adds them to a timer queue. The
  10  *    functionality of the timer queue is then tested. No command
  11  *    line arguments are needed to run the test.
  12  *
  13  *  @author Douglas C. Schmidt <d.schmidt@vanderbilt.edu>
  14  *  @author Prashant Jain <pjain@cs.wustl.edu>
  15  *  @author and Darrell Brunsch <brunsch@cs.wustl.edu>
  16  */
  17 //=============================================================================
  18
  19 #include "test_config.h"
  20 #include "randomize.h"
  21 #include "ace/Profile_Timer.h"
  22 #include "ace/Timer_Queue.h"
  23 #include "ace/Timer_List.h"
  24 #include "ace/Timer_Heap.h"
  25 #include "ace/Timer_Wheel.h"
  26 #include "ace/Timer_Hash.h"
  27 #include "ace/Timer_Queue.h"
  28 #include "ace/Time_Policy.h"
  29 #include "ace/Recursive_Thread_Mutex.h"
  30 #include "ace/Null_Mutex.h"
  31 #include "ace/OS_NS_unistd.h"
  32 #include "ace/Containers_T.h"
  33 #include "ace/Event_Handler.h"
  34
  35 // Number of iterations for the performance tests.  Some platforms
  36 // have a very high ACE_DEFAULT_TIMERS (HP-UX is 400), so limit this
  37 // to a reasonable run time.
  38 #if (ACE_DEFAULT_TIMERS > 20)
  39 static int max_iterations = 2000;
  40 #else
  41 static int max_iterations = ACE_DEFAULT_TIMERS * 100;
  42 #endif
  43
  44 // Amount of time between each timer.
  45 // (0 schedules all the timers to expire at exactly the same time.)
  46 // in milliseconds
  47 static int TIMER_DISTANCE = 50;
  48
  49 // Array of timer ids assigned to us that we need to keep track of.
  50 static long *timer_ids = 0;
  51
  52 class Example_Handler : public ACE_Event_Handler
  53 {
  54 public:
  55   Example_Handler (): close_count_ (0) {}
  56
  57   int handle_close (ACE_HANDLE, ACE_Reactor_Mask mask) override
  58   {
  59     ACE_TEST_ASSERT (mask == ACE_Event_Handler::TIMER_MASK);
  60     this->close_count_++;
  61     return 0;
  62   }
  63
  64   int handle_timeout (const ACE_Time_Value &,
  65                               const void *arg) override
  66   {
  67     int *act = (int *) arg;
  68     ACE_TEST_ASSERT (*act == 42 || *act == 007);
  69     int result = 0;
  70
  71     if (*act == 007)
  72       result = -1; // This is the special value to trigger a handle_close
  73
  74     delete act;
  75     return result;
  76   }
  77
  78   /// Keeps track of the number of times that <handle_close> is called.
  79   int close_count_;
  80 };
  81
  82
  83 struct Interval_Handler : public ACE_Event_Handler
  84 {
  85   Interval_Handler () : trip_count_ (0) { }
  86
  87   int handle_timeout (const ACE_Time_Value & , const void *) override
  88   {
  89     ++trip_count_;
  90     return 0;
  91   }
  92
  93   unsigned trip_count_; // number of times handle_timeout has been tripped.
  94 };
  95
  96 static void
  97 test_interval_timer (ACE_Timer_Queue *tq)
  98 {
  99   /*
 100     The strategy:
 101
 102     Set up a timer to fire on a 50ms interval.
 103   */
 104   Interval_Handler ih;
 105   ACE_Time_Value interval (0, 50 * 1000 /* number of usec in millisecond */);
 106   const unsigned NUM_INTERVAL_FIRINGS = 50;
 107   ACE_Time_Value loop_stop_time =
 108     tq->gettimeofday () + (NUM_INTERVAL_FIRINGS * interval);
 109   const unsigned EXPECTED_TRIP_COUNT =
 110     NUM_INTERVAL_FIRINGS + 1 /* for the first immediate firing */;
 111
 112   long id = tq->schedule (&ih, 0 /* no act */, ACE_Time_Value::zero, interval);
 113   ACE_TEST_ASSERT (id != -1);
 114
 115   do
 116     {
 117       tq->expire ();
 118     }
 119   while (tq->gettimeofday () < loop_stop_time);
 120
 121   ACE_DEBUG((LM_DEBUG,
 122              ACE_TEXT("after interval loop, timer fired %d ")
 123              ACE_TEXT("times out of %d expected: %s\n"),
 124              ih.trip_count_, EXPECTED_TRIP_COUNT,
 125              ih.trip_count_ == EXPECTED_TRIP_COUNT
 126              ? ACE_TEXT ("success") : ACE_TEXT ("FAIL")
 127              ));
 128
 129   tq->cancel (id);
 130 }
 131
 132 static void
 133 test_functionality (ACE_Timer_Queue *tq)
 134 {
 135   Example_Handler eh;
 136
 137   ACE_TEST_ASSERT (tq->is_empty () != 0);
 138   ACE_TEST_ASSERT (ACE_Time_Value::zero == ACE_Time_Value (0));
 139   long timer_id;
 140   long timer_id2;
 141
 142   // Do a test on earliest_time.
 143   ACE_Time_Value earliest_time = tq->gettimeofday ();
 144
 145   const void *timer_act = 0;
 146   ACE_NEW (timer_act, int (1));
 147   timer_id = tq->schedule (&eh, timer_act, earliest_time);
 148
 149   ACE_OS::sleep (ACE_Time_Value (0, 10));
 150
 151   ACE_NEW (timer_act, int (1));
 152   timer_id2 = tq->schedule (&eh, timer_act, tq->gettimeofday ());
 153
 154   long result = tq->earliest_time () == earliest_time;
 155   ACE_TEST_ASSERT (result != 0);
 156
 157   tq->cancel (timer_id, &timer_act);
 158   delete (int *) timer_act;
 159   tq->cancel (timer_id2, &timer_act);
 160   delete (int *) timer_act;
 161
 162   ACE_TEST_ASSERT (tq->is_empty () == 1);
 163   ACE_TEST_ASSERT (eh.close_count_ == 0);
 164
 165   ACE_NEW (timer_act, int (1));
 166   timer_id = tq->schedule (&eh,
 167                            timer_act,
 168                            tq->gettimeofday ());
 169   ACE_TEST_ASSERT (timer_id != -1);
 170   ACE_TEST_ASSERT (tq->is_empty () == 0); //==
 171
 172   ACE_NEW (timer_act, int (42));
 173   result = tq->schedule (&eh,
 174                          timer_act,
 175                          tq->gettimeofday ());
 176   ACE_TEST_ASSERT (result != -1);
 177   ACE_TEST_ASSERT (tq->is_empty () == 0); //==
 178
 179   ACE_NEW (timer_act, int (42));
 180   result = tq->schedule (&eh,
 181                          timer_act,
 182                          tq->gettimeofday ());
 183   ACE_TEST_ASSERT (result != -1);
 184   ACE_TEST_ASSERT (tq->is_empty () == 0); //==
 185
 186   // The following method will trigger a call to <handle_close>.
 187   ACE_TEST_ASSERT (eh.close_count_ == 0);
 188   result = tq->cancel (timer_id, &timer_act, 0);
 189   ACE_TEST_ASSERT (result == 1);
 190   delete (int *) timer_act;
 191
 192   ACE_TEST_ASSERT (tq->is_empty () == 0);
 193   ACE_TEST_ASSERT (eh.close_count_ == 1);
 194
 195   result = tq->expire ();
 196   ACE_TEST_ASSERT (result == 2);
 197
 198   ACE_NEW (timer_act, int (007));
 199   result = tq->schedule (&eh,
 200                          timer_act,
 201                          tq->gettimeofday ());
 202   ACE_TEST_ASSERT (result != -1);
 203
 204   const void *timer_act1 = 0;
 205   ACE_NEW (timer_act1, int (42));
 206   result = tq->schedule (&eh,
 207                          timer_act1,
 208                          tq->gettimeofday () + ACE_Time_Value (100));
 209   ACE_TEST_ASSERT (result != -1);
 210
 211   const void *timer_act2 = 0;
 212   ACE_NEW (timer_act2, int (42));
 213   result = tq->schedule (&eh,
 214                          timer_act2,
 215                          tq->gettimeofday () + ACE_Time_Value (100));
 216   ACE_TEST_ASSERT (result != -1);
 217
 218   // The following will trigger a call to <handle_close> when it
 219   // cancels the second timer.  This happens because the first timer
 220   // has an <act> of 007, which causes eh.handle_timeout () to return
 221   // -1.  Since -1 is returned, all timers that use <eh> will be
 222   // cancelled (and <handle_close> will only be called on the first
 223   // timer that is cancelled).
 224   ACE_TEST_ASSERT (eh.close_count_ == 1);
 225
 226   result = tq->expire ();
 227   ACE_TEST_ASSERT (result == 1);
 228   ACE_TEST_ASSERT (eh.close_count_ == 2);
 229
 230   ACE_TEST_ASSERT (tq->is_empty () != 0);
 231   delete (int *) timer_act2;
 232   delete (int *) timer_act1;
 233
 234   ACE_NEW (timer_act, int (4));
 235   timer_id = tq->schedule (&eh,
 236                            timer_act,
 237                            tq->gettimeofday ());
 238   ACE_TEST_ASSERT (timer_id != -1);
 239
 240   ACE_NEW (timer_act, int (4));
 241   timer_id2 = tq->schedule (&eh,
 242                             timer_act,
 243                             tq->gettimeofday ());
 244   ACE_TEST_ASSERT (timer_id2 != -1);
 245
 246   // The following method will trigger a call to <handle_close>.
 247   ACE_TEST_ASSERT (eh.close_count_ == 2);
 248   result = tq->cancel (timer_id, &timer_act);
 249   ACE_TEST_ASSERT (result != -1);
 250   delete (int *) timer_act;
 251
 252   result = tq->cancel (timer_id2, &timer_act);
 253   ACE_TEST_ASSERT (result != -1);
 254   delete (int *) timer_act;
 255
 256   ACE_TEST_ASSERT (eh.close_count_ == 2); // Only one call to handle_close() even though two timers
 257   ACE_TEST_ASSERT (tq->is_empty () != 0);
 258
 259   result = tq->expire ();
 260   ACE_TEST_ASSERT (result == 0);
 261
 262   // This tests to make sure that <handle_close> is called when there
 263   // is only one timer of the type in the queue
 264   ACE_TEST_ASSERT (eh.close_count_ == 2);
 265
 266   ACE_NEW (timer_act, int (007));
 267   result = tq->schedule (&eh,
 268                          timer_act,
 269                          tq->gettimeofday ());
 270   ACE_TEST_ASSERT (result != -1);
 271
 272   result = tq->expire ();
 273   ACE_TEST_ASSERT (result == 1);
 274   ACE_TEST_ASSERT (eh.close_count_ == 3);
 275
 276   ACE_NEW (timer_act, int (6));
 277   timer_id = tq->schedule (&eh,
 278                            timer_act,
 279                            tq->gettimeofday ());
 280   ACE_TEST_ASSERT (timer_id != -1);
 281
 282   ACE_NEW (timer_act, int (7));
 283   timer_id2 = tq->schedule (&eh,
 284                             timer_act,
 285                             tq->gettimeofday ());
 286   ACE_TEST_ASSERT (timer_id2 != -1);
 287
 288   ACE_TEST_ASSERT (eh.close_count_ == 3);
 289
 290   result = tq->cancel (timer_id, &timer_act);
 291   ACE_TEST_ASSERT (result == 1);
 292   ACE_TEST_ASSERT (eh.close_count_ == 3);
 293   delete (int *) timer_act;
 294
 295   result = tq->cancel (timer_id2, &timer_act);
 296   ACE_TEST_ASSERT (result == 1);
 297   ACE_TEST_ASSERT (eh.close_count_ == 3);
 298   delete (int *) timer_act;
 299
 300   result = tq->expire ();
 301   ACE_TEST_ASSERT (result == 0);
 302   ACE_TEST_ASSERT (eh.close_count_ == 3);
 303 }
 304
 305 static void
 306 test_performance (ACE_Timer_Queue *tq,
 307                   const ACE_TCHAR *test_name)
 308 {
 309   Example_Handler eh;
 310   ACE_Profile_Timer timer;
 311   int i;
 312   const void *timer_act = 0;
 313
 314   ACE_TEST_ASSERT (tq->is_empty () != 0);
 315   ACE_TEST_ASSERT (ACE_Time_Value::zero == ACE_Time_Value (0));
 316
 317   // Test the amount of time required to schedule all the timers.
 318
 319   ACE_Time_Value *times = 0;
 320   ACE_NEW (times, ACE_Time_Value[max_iterations]);
 321
 322   // Set up a bunch of times TIMER_DISTANCE ms apart.
 323   for (i = 0; i < max_iterations; ++i)
 324     {
 325       times[i] = (tq->gettimeofday()
 326         + ACE_Time_Value(0, i * TIMER_DISTANCE * 1000));
 327     }
 328
 329   ACE_Time_Value last_time = times[max_iterations-1];
 330
 331   timer.start ();
 332
 333   for (i = 0; i < max_iterations; ++i)
 334     {
 335       ACE_NEW (timer_act, int (42));
 336       timer_ids[i] = tq->schedule (&eh,
 337                                    timer_act,
 338                                    times[i]);
 339       ACE_TEST_ASSERT (timer_ids[i] != -1);
 340     }
 341
 342   ACE_TEST_ASSERT (tq->is_empty () == 0);
 343
 344   timer.stop ();
 345
 346   ACE_Profile_Timer::ACE_Elapsed_Time et;
 347
 348   timer.elapsed_time (et);
 349
 350   ACE_DEBUG ((LM_DEBUG,
 351               ACE_TEXT ("time to schedule %d timers for %s\n"),
 352               max_iterations, test_name));
 353   ACE_DEBUG ((LM_DEBUG,
 354               ACE_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"),
 355               et.real_time, et.user_time, et.system_time));
 356   ACE_DEBUG ((LM_DEBUG,
 357               ACE_TEXT ("time per call = %f usecs\n"),
 358               (et.user_time / ACE_timer_t (max_iterations)) * 1000000));
 359
 360   // Test the amount of time required to cancel all the timers.
 361
 362   timer.start ();
 363
 364   for (i = max_iterations; i-- != 0; )
 365     {
 366       tq->cancel (timer_ids[i], &timer_act);
 367       delete (int *) timer_act;
 368     }
 369
 370   timer.stop ();
 371
 372   ACE_TEST_ASSERT (tq->is_empty () != 0);
 373
 374   timer.elapsed_time (et);
 375
 376   ACE_DEBUG ((LM_DEBUG,
 377               ACE_TEXT ("time to cancel %d timers for %s\n"),
 378               max_iterations, test_name));
 379   ACE_DEBUG ((LM_DEBUG,
 380               ACE_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"),
 381               et.real_time, et.user_time, et.system_time));
 382   ACE_DEBUG ((LM_DEBUG,
 383               ACE_TEXT ("time per call = %f usecs\n"),
 384               (et.user_time / ACE_timer_t (max_iterations)) * 1000000));
 385
 386   // Test the amount of time required to schedule and expire all the
 387   // timers.
 388
 389   timer.start ();
 390
 391   for (i = 0; i < max_iterations; ++i)
 392     {
 393       ACE_NEW (timer_act, int (42));
 394       long result = tq->schedule (&eh, timer_act, times[i]);
 395       ACE_TEST_ASSERT (result != -1);
 396     }
 397
 398   ACE_TEST_ASSERT (tq->is_empty () == 0);
 399
 400   // Expire all the timers.
 401   tq->expire (last_time + ACE_Time_Value(1));
 402
 403   timer.stop ();
 404
 405   ACE_TEST_ASSERT (tq->is_empty () != 0);
 406
 407   timer.elapsed_time (et);
 408
 409   ACE_DEBUG ((LM_DEBUG,
 410               ACE_TEXT ("time to schedule and expire %d timers for %s\n"),
 411               max_iterations, test_name));
 412   ACE_DEBUG ((LM_DEBUG,
 413               ACE_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"),
 414               et.real_time, et.user_time, et.system_time));
 415   ACE_DEBUG ((LM_DEBUG,
 416               ACE_TEXT ("time per call = %f usecs\n"),
 417               (et.user_time / ACE_timer_t (max_iterations)) * 1000000));
 418
 419   randomize (times,
 420              max_iterations,
 421              static_cast<unsigned int> (ACE_OS::time (0L)));
 422
 423   // Test the amount of time required to randomly cancel all the
 424   // timers.
 425
 426   for (i = 0; i < max_iterations; ++i)
 427     {
 428       ACE_NEW (timer_act, int (42));
 429       timer_ids[i] = tq->schedule (&eh,
 430                                    timer_act,
 431                                    times[i]);
 432       ACE_TEST_ASSERT (timer_ids[i] != -1);
 433     }
 434
 435   ACE_TEST_ASSERT (tq->is_empty () == 0);
 436
 437   timer.start ();
 438
 439   for (i = max_iterations - 1; i >= 0; i--)
 440     {
 441       tq->cancel (timer_ids[i], &timer_act);
 442       delete (int *) timer_act;
 443     }
 444
 445   ACE_TEST_ASSERT (tq->is_empty () != 0);
 446
 447   timer.stop ();
 448
 449   timer.elapsed_time (et);
 450
 451   ACE_DEBUG ((LM_DEBUG,
 452               ACE_TEXT ("time to randomly cancel %d timers for %s\n"),
 453               max_iterations,
 454               test_name));
 455   ACE_DEBUG ((LM_DEBUG,
 456               ACE_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"),
 457               et.real_time,
 458               et.user_time,
 459               et.system_time));
 460   ACE_DEBUG ((LM_DEBUG,
 461               ACE_TEXT ("time per call = %f usecs\n"),
 462               (et.user_time / ACE_timer_t (max_iterations)) * 1000000));
 463
 464   // Test the amount of time required to randomly schedule all the timers.
 465
 466   timer.start ();
 467
 468   for (i = 0; i < max_iterations; ++i)
 469     {
 470       ACE_NEW (timer_act, int (42));
 471       timer_ids[i] = tq->schedule (&eh,
 472                                    timer_act,
 473                                    times[i]);
 474       ACE_TEST_ASSERT (timer_ids[i] != -1);
 475     }
 476
 477   timer.stop ();
 478
 479   ACE_TEST_ASSERT (tq->is_empty () == 0);
 480
 481   timer.elapsed_time (et);
 482
 483   ACE_DEBUG ((LM_DEBUG,
 484               ACE_TEXT ("time to randomly schedule %d timers for %s\n"),
 485               max_iterations, test_name));
 486   ACE_DEBUG ((LM_DEBUG,
 487               ACE_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"),
 488               et.real_time,
 489               et.user_time,
 490               et.system_time));
 491   ACE_DEBUG ((LM_DEBUG,
 492               ACE_TEXT ("time per call = %f usecs\n"),
 493               (et.user_time / ACE_timer_t (max_iterations)) * 1000000));
 494
 495   // Test the amount of time required to expire all the timers.
 496
 497   timer.start ();
 498
 499   tq->expire (last_time + ACE_Time_Value(1));
 500
 501   ACE_TEST_ASSERT (tq->is_empty ());
 502
 503   timer.stop ();
 504
 505   timer.elapsed_time (et);
 506
 507   ACE_DEBUG ((LM_DEBUG,
 508               ACE_TEXT ("time to expire %d randomly scheduled timers for %s\n"),
 509               max_iterations, test_name));
 510   ACE_DEBUG ((LM_DEBUG,
 511               ACE_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"),
 512               et.real_time, et.user_time, et.system_time));
 513   ACE_DEBUG ((LM_DEBUG,
 514               ACE_TEXT ("time per call = %f usecs\n"),
 515               (et.user_time / ACE_timer_t (max_iterations)) * 1000000));
 516
 517   delete [] times;
 518 }
 519
 520 // This test function was contributed with Bugzilla #2447 to test validity
 521 // of ACE_Timer_Heap timer IDs around the boundary of having to enlarge
 522 // the heap.
 523 static void
 524 test_unique_timer_heap_ids ()
 525 {
 526   Example_Handler eh;
 527   ACE_Timer_Heap timer_heap (44);
 528   ACE_Time_Value anytime(1);
 529   ACE_Bounded_Set<long> timer_ids (max_iterations);
 530   long timer_id = -1;
 531   bool all_unique = true;
 532
 533   for (int i = 0; i < 100; ++i)
 534     {
 535       timer_id = timer_heap.schedule (&eh, 0, anytime);
 536       if (timer_id == -1)
 537         {
 538           ACE_ERROR ((LM_ERROR,
 539                       ACE_TEXT ("Schedule timer %d %p\n"),
 540                       i,
 541                       ACE_TEXT ("test_unique_timer_heap_ids")));
 542           continue;
 543         }
 544       ACE_DEBUG ((LM_DEBUG,
 545                   ACE_TEXT ("Schedule timer %d. Timer id = %d\n"),
 546                   i,
 547                   timer_id));
 548       if (1 == timer_ids.insert (timer_id))
 549         {
 550           ACE_ERROR ((LM_ERROR,
 551                       ACE_TEXT ("Pass %d, id %d is not unique\n"),
 552                       i,
 553                       timer_id));
 554           all_unique = false;
 555         }
 556
 557       if (i == 0 || i == 1 || i == 47 || i == 48)
 558         {
 559           ACE_DEBUG ((LM_DEBUG,
 560                       ACE_TEXT ("Free Timer %d. Timer Id = %d\n"),
 561                       i,
 562                       timer_id));
 563           timer_heap.cancel (timer_id);
 564           if (timer_id == -1)
 565             ACE_ERROR ((LM_ERROR,
 566                         ACE_TEXT ("%p\n"),
 567                         ACE_TEXT ("Failed to cancel timer")));
 568
 569           timer_ids.remove (timer_id);
 570         }
 571     }
 572
 573   if (all_unique)
 574     ACE_DEBUG ((LM_INFO, ACE_TEXT ("All timer ids were unique.\n")));
 575
 576   return;
 577 }
 578
 579 /**
 580  * @class Timer_Queue_Stack
 581  *
 582  * @brief Keeps track of the <Timer_Queue>s that we're going to test.
 583  *
 584  * This data structure is organized as a stack to make it easy to implement.
 585  */
 586 class Timer_Queue_Stack
 587 {
 588 public:
 589   Timer_Queue_Stack (ACE_Timer_Queue *queue,
 590     const ACE_TCHAR *name,
 591     Timer_Queue_Stack *next = 0)
 592     : queue_ (queue),
 593     name_ (name),
 594     next_ (next)
 595   {}
 596   // "Push" a new <queue> on the stack of <queue>s.
 597
 598   /// Pointer to the subclass of <ACE_Timer_Queue> that we're testing.
 599   ACE_Timer_Queue *queue_;
 600
 601   /// Name of the Queue that we're testing.
 602   const ACE_TCHAR *name_;
 603
 604   /// Pointer to the next <Timer_Queue>.
 605   Timer_Queue_Stack *next_;
 606 };
 607
 608 int
 609 run_main (int argc, ACE_TCHAR *argv[])
 610 {
 611   ACE_START_TEST (ACE_TEXT ("Timer_Queue_Test"));
 612
 613   if (argc > 1)
 614     max_iterations = ACE_OS::atoi (argv[1]);
 615
 616   // = Perform initializations.
 617
 618   Timer_Queue_Stack *tq_stack = 0;
 619
 620   // Add new Timer_Queue implementations here.  Note that these will
 621   // be executed in "reverse order".
 622
 623   // Timer_Hash (Heap)
 624   ACE_NEW_RETURN (tq_stack,
 625                   Timer_Queue_Stack (new ACE_Timer_Hash_Heap,
 626                                      ACE_TEXT ("ACE_Timer_Hash (Heap)"),
 627                                      tq_stack),
 628                   -1);
 629
 630   // Timer_Hash
 631   ACE_NEW_RETURN (tq_stack,
 632                   Timer_Queue_Stack (new ACE_Timer_Hash,
 633                                      ACE_TEXT ("ACE_Timer_Hash"),
 634                                      tq_stack),
 635                   -1);
 636
 637   // Timer_stack
 638   ACE_NEW_RETURN (tq_stack,
 639                   Timer_Queue_Stack (new ACE_Timer_List,
 640                                      ACE_TEXT ("ACE_Timer_List"),
 641                                      tq_stack),
 642                   -1);
 643
 644   // Timer_Wheel without preallocated memory
 645   ACE_NEW_RETURN (tq_stack,
 646                   Timer_Queue_Stack (new ACE_Timer_Wheel,
 647                                      ACE_TEXT ("ACE_Timer_Wheel (non-preallocated)"),
 648                                      tq_stack),
 649                   -1);
 650
 651   // Timer_Wheel with preallocated memory.
 652   ACE_NEW_RETURN (tq_stack,
 653                   Timer_Queue_Stack (new ACE_Timer_Wheel (ACE_DEFAULT_TIMER_WHEEL_SIZE,
 654                                                           ACE_DEFAULT_TIMER_WHEEL_RESOLUTION,
 655                                                           max_iterations),
 656                                      ACE_TEXT ("ACE_Timer_Wheel (preallocated)"),
 657                                      tq_stack),
 658                   -1);
 659   // Timer_Heap without preallocated memory.
 660   ACE_NEW_RETURN (tq_stack,
 661                   Timer_Queue_Stack (new ACE_Timer_Heap,
 662                                      ACE_TEXT ("ACE_Timer_Heap (non-preallocated)"),
 663                                      tq_stack),
 664                   -1);
 665
 666   // Timer_Heap with preallocate memory.
 667   ACE_NEW_RETURN (tq_stack,
 668                   Timer_Queue_Stack (new ACE_Timer_Heap (max_iterations, 1),
 669                                      ACE_TEXT ("ACE_Timer_Heap (preallocated)"),
 670                                      tq_stack),
 671                   -1);
 672
 673   // Timer_Heap without preallocated memory, using high-res time.
 674   // @deprecated
 675   (void) ACE_High_Res_Timer::global_scale_factor ();
 676
 677   ACE_Timer_Heap *tq_heap =
 678     new ACE_Timer_Heap;
 679   tq_heap->gettimeofday(&ACE_High_Res_Timer::gettimeofday_hr);
 680   ACE_NEW_RETURN (tq_stack,
 681                   Timer_Queue_Stack (tq_heap,
 682                                      ACE_TEXT ("ACE_Timer_Heap (high-res timer; deprecated version)"),
 683                                      tq_stack),
 684                   -1);
 685
 686   // new (optimized) version
 687   using timer_heap_hr_type = ACE_Timer_Heap_T<ACE_Event_Handler *, ACE_Event_Handler_Handle_Timeout_Upcall, ACE_MT_SYNCH::RECURSIVE_MUTEX, ACE_HR_Time_Policy>;
 688   ACE_NEW_RETURN (tq_stack,
 689                   Timer_Queue_Stack (new timer_heap_hr_type,
 690                                      ACE_TEXT ("ACE_Timer_Heap (high-res timer)"),
 691                                      tq_stack),
 692                   -1);
 693
 694
 695   // Create the Timer ID array
 696   ACE_NEW_RETURN (timer_ids,
 697                   long[max_iterations],
 698                   -1);
 699
 700   Timer_Queue_Stack *tq_ptr = tq_stack;
 701
 702   while (tq_ptr != 0)
 703     {
 704       ACE_DEBUG ((LM_DEBUG,
 705                   ACE_TEXT ("**** starting test of %s\n"),
 706                   tq_ptr->name_));
 707       test_interval_timer (tq_ptr->queue_);
 708       test_functionality (tq_ptr->queue_);
 709       test_performance (tq_ptr->queue_,
 710                         tq_ptr->name_);
 711       delete tq_ptr->queue_;
 712       Timer_Queue_Stack *temp = tq_ptr;
 713       tq_ptr = tq_ptr->next_;
 714       delete temp;
 715     }
 716   delete [] timer_ids;
 717
 718   ACE_DEBUG
 719     ((LM_DEBUG,
 720       ACE_TEXT ("**** starting unique IDs test for ACE_Timer_Heap\n")));
 721   test_unique_timer_heap_ids ();
 722
 723   ACE_END_TEST;
 724   return 0;
 725 }