ACE/tests/Reactor_Notification_Queue_Test.cpp

   1 /**
   2  * @file Reactor_Notification_Queue_Test.cpp
   3  *
   4  * Verify that the notification queue can be used with large numbers
   5  * of events.
   6  *
   7  * Normally the ACE_Reactor uses a pipe to implement the notify()
   8  * methods.  ACE can be compiled with
   9  * ACE_HAS_REACTOR_NOTIFICATION_QUEUE, with this configuration flag
  10  * the Reactor uses a user-space queue to contain the notifications.
  11  * A single message is sent through the pipe to indicate "pipe not
  12  * empty."
  13  *
  14  * @author Carlos O'Ryan <coryan@atdesk.com>
  15  */
  16
  17 #include "test_config.h"
  18 #include "ace/Reactor.h"
  19 #include "ace/TP_Reactor.h"
  20 #include "ace/Select_Reactor.h"
  21 #include "ace/WFMO_Reactor.h"
  22
  23 class Event_Handler : public ACE_Event_Handler
  24 {
  25 public:
  26   Event_Handler(ACE_Reactor * reactor,
  27                 int max_notifications,
  28                 char const *test_name);
  29
  30   /// Run the test
  31   void run(void);
  32
  33   /// Receive the notifications.
  34   virtual int handle_exception(ACE_HANDLE);
  35
  36 private:
  37   /**
  38    * @brief Implement a single iteration.
  39    *
  40    * Each iteration of the test consists of sending multiple
  41    * notifications simultaneously.
  42    */
  43   void send_notifications (void);
  44
  45   /**
  46    * @brief Return true if the test is finished.
  47    */
  48   bool done (void) const;
  49
  50 private:
  51   /**
  52    * @brief The maximum number of notifications in any single
  53    * iteration.
  54    */
  55   int max_notifications_;
  56
  57   /**
  58    * @brief The name of the test
  59    */
  60   char const * test_name_;
  61   /**
  62    * @brief Number of notifications received
  63    */
  64   int notifications_sent_;
  65   /**
  66    * @brief Number of notifications sent
  67    */
  68   int notifications_recv_;
  69
  70   /**
  71    * @brief Number of notifications sent on each iteration
  72    */
  73   int notifications_curr_;
  74 };
  75
  76 int
  77 run_main (int, ACE_TCHAR *[])
  78 {
  79   ACE_START_TEST (ACE_TEXT ("Reactor_Notification_Queue_Test"));
  80
  81 #if !defined(ACE_HAS_REACTOR_NOTIFICATION_QUEUE)
  82   ACE_DEBUG ((LM_INFO,
  83               ACE_TEXT ("Notification queue disabled, ")
  84               ACE_TEXT ("small test version, ")
  85               ACE_TEXT ("which is of no practical use\n")));
  86
  87   int max_notifications = 16;
  88 #else
  89   int max_notifications = 1024 * 1024;
  90 #endif /* ACE_HAS_THREADS */
  91
  92   {
  93     ACE_Reactor select_reactor (
  94         new ACE_Select_Reactor,
  95         1);
  96
  97     Event_Handler handler(&select_reactor,
  98                           max_notifications,
  99                           "Select_Reactor");
 100
 101     handler.run ();
 102   }
 103
 104   {
 105     ACE_Reactor tp_reactor (new ACE_TP_Reactor,
 106                             1);
 107     Event_Handler handler(&tp_reactor,
 108                           max_notifications,
 109                           "TP_Reactor");
 110     handler.run();
 111   }
 112
 113 #if 0
 114   /// @@todo: Need to talk to Irfan to see how the WFMO handles this.
 115 #if defined (ACE_WIN32)
 116   {
 117     ACE_Reactor wfmo_reactor (new ACE_WFMO_Reactor,
 118                               1);
 119
 120     Event_Handler handler(&wfmo_reactor,
 121                           max_notifications,
 122                           "WFMO_Reactor");
 123     handler.run();
 124   }
 125 #endif /*ACE_WIN32*/
 126 #endif /*if 0 */
 127   ACE_END_TEST;
 128   return 0;
 129 }
 130
 131 Event_Handler::Event_Handler (
 132     ACE_Reactor * reactor,
 133     int max_notifications,
 134     char const * test_name)
 135   : ACE_Event_Handler(reactor)
 136   , max_notifications_(max_notifications)
 137   , test_name_(test_name)
 138   , notifications_sent_(0)
 139   , notifications_recv_(0)
 140   , notifications_curr_(1)
 141 {
 142 }
 143
 144 void
 145 Event_Handler::run (void)
 146 {
 147   send_notifications ();
 148
 149   // Run for 30 seconds or until the test is done.
 150   for(int i = 0; i != 30 && !done(); ++i)
 151   {
 152     ACE_Time_Value tv (1,0);
 153     reactor ()->run_reactor_event_loop(tv);
 154   }
 155
 156   if(!done())
 157   {
 158     ACE_ERROR ((LM_ERROR,
 159                ACE_TEXT ("Test %C failed due to timeout ")
 160                ACE_TEXT (" sent=%d,recv=%d\n"),
 161                test_name_,
 162                notifications_sent_,
 163                notifications_recv_));
 164   }
 165   else
 166   {
 167     ACE_DEBUG ((LM_INFO,
 168                 ACE_TEXT ("Test %C passed sent=%d, recv=%d\n"),
 169                 test_name_,
 170                 notifications_sent_,
 171                 notifications_recv_));
 172   }
 173 }
 174
 175 int
 176 Event_Handler::handle_exception (ACE_HANDLE)
 177 {
 178   ++notifications_recv_;
 179   if(notifications_recv_ == notifications_sent_)
 180   {
 181     if(notifications_curr_ >= max_notifications_)
 182     {
 183
 184       return 0;
 185     }
 186     send_notifications();
 187   }
 188   return 0;
 189 }
 190
 191 void
 192 Event_Handler::send_notifications (void)
 193 {
 194   for (int i = 0; i != notifications_curr_; ++i)
 195   {
 196     if(reactor()->notify (this) == -1)
 197     {
 198       ACE_ERROR((LM_ERROR,
 199                  ACE_TEXT ("Cannot send notifications in %C test (%d/%d)\n"),
 200                  test_name_, i, notifications_curr_));
 201       return;
 202     }
 203
 204     ++notifications_sent_;
 205   }
 206   //  ACE_ERROR((LM_ERROR,
 207   //                "Started iteration with %d notify() calls in test %C\n",
 208   //                notifications_curr_, test_name_));
 209   notifications_curr_ *= 2;
 210 }
 211
 212 bool
 213 Event_Handler::done (void) const
 214 {
 215   return (notifications_curr_ >= max_notifications_)
 216     && (notifications_sent_ == notifications_recv_);
 217 }