.

1 files changed, 125 insertions, 67 deletions

diff --git a/tests/Message_Queue_Test.cpp b/tests/Message_Queue_Test.cpp
index efc374cb109..0096f0ed01d 100644
--- a/tests/Message_Queue_Test.cpp
+++ b/tests/Message_Queue_Test.cpp
@@ -41,11 +41,11 @@ typedef ACE_Message_Queue<ACE_NULL_SYNCH> QUEUE;
 typedef ACE_Message_Queue_Iterator<ACE_NULL_SYNCH> ITERATOR;
 typedef ACE_Message_Queue_Reverse_Iterator<ACE_NULL_SYNCH> REVERSE_ITERATOR;
 
-const int MAX_MESSAGES = 10000;
-const int MAX_MESSAGE_SIZE = 32;
-const char test_message[] = "ACE_Message_Queue Test Message";
+static const int MAX_MESSAGES = 10000;
+static const int MAX_MESSAGE_SIZE = 32;
+static const char test_message[] = "ACE_Message_Queue Test Message";
 
-int messages = MAX_MESSAGES;
+static int messages = MAX_MESSAGES;
 
 // Dynamically allocate to avoid a static.
 static ACE_High_Res_Timer *timer = 0;
@@ -56,7 +56,8 @@ typedef ACE_Message_Queue<ACE_SYNCH> SYNCH_QUEUE;
 struct Queue_Wrapper
 {
   // = TITLE
-  //     Container for data passed to sender and receiver in performance test.
+  //     Container for data passed to sender and receiver in
+  //     performance test.
   //
   // = DESCRIPTION
   //     For use in multithreaded performance test.
@@ -67,77 +68,100 @@ struct Queue_Wrapper
   ACE_Message_Block **send_block_;
   // Pointer to messages blocks for sender to send to reciever.
 
-  Queue_Wrapper () : q_ (0), send_block_ (0) {}
+  Queue_Wrapper (void)
+    : q_ (0), send_block_ (0) 
+  {
+  }
   // Default constructor.
 };
 
 #endif /* ACE_HAS_THREADS */
 
 #if !defined (VXWORKS)
-static
-int
-iterator_test ()
+static int
+iterator_test (void)
 {
   const int ITERATIONS = 5;
   ASYS_TCHAR buffer[ITERATIONS][BUFSIZ];
+  // @@ David, can you please replace these magic #'s with constants
+  // or explain what 32 * 1024 means?
   QUEUE queue (32 * 1024);
   int i;
 
   for (i = 0; i < ITERATIONS; i++)
     {
-      ACE_OS::sprintf (buffer[i], ASYS_TEXT ("%d"), i+1);
+      ACE_OS::sprintf (buffer[i],
+                       ASYS_TEXT ("%d"),
+                       i + 1);
 
       ACE_Message_Block *entry;
-      ACE_NEW_RETURN (entry, ACE_Message_Block ((char *) buffer[i], sizeof buffer[i]), -1);
+      ACE_NEW_RETURN (entry,
+                      ACE_Message_Block ((char *) buffer[i],
+                                         sizeof buffer[i]),
+                      -1);
 
       if (queue.is_full ())
         ACE_ERROR_RETURN ((LM_ERROR,
                            ASYS_TEXT ("QUEUE:: the message queue is full on iteration %u!\n"),
-                           i+1),
+                           i + 1),
                           -1);
 
       if (queue.enqueue (entry) == -1)
-        ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("QUEUE::enqueue\n")), -1);
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           ASYS_TEXT ("QUEUE::enqueue\n")),
+                          -1);
     }
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\nForward Iterations\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("\nForward Iterations\n")));
   {
     ITERATOR iterator (queue);
 
     for (ACE_Message_Block *entry = 0;
          iterator.next (entry) != 0;
          iterator.advance ())
-      ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("%s\n"), entry->base ()));
+      ACE_DEBUG ((LM_DEBUG,
+                  ASYS_TEXT ("%s\n"),
+                  entry->base ()));
   }
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\nReverse Iterations\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("\nReverse Iterations\n")));
   {
     REVERSE_ITERATOR iterator (queue);
 
     for (ACE_Message_Block *entry = 0;
          iterator.next (entry) != 0;
          iterator.advance ())
-      ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("%s\n"), entry->base ()));
+      ACE_DEBUG ((LM_DEBUG,
+                  ASYS_TEXT ("%s\n"),
+                  entry->base ()));
   }
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\nForward Iterations\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("\nForward Iterations\n")));
   {
     QUEUE::ITERATOR iterator (queue);
 
     for (ACE_Message_Block *entry = 0;
          iterator.next (entry) != 0;
          iterator.advance ())
-      ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("%s\n"), entry->base ()));
+      ACE_DEBUG ((LM_DEBUG,
+                  ASYS_TEXT ("%s\n"),
+                  entry->base ()));
   }
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\nReverse Iterations\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("\nReverse Iterations\n")));
   {
     QUEUE::REVERSE_ITERATOR iterator (queue);
 
     for (ACE_Message_Block *entry = 0;
          iterator.next (entry) != 0;
          iterator.advance ())
-      ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("%s\n"), entry->base ()));
+      ACE_DEBUG ((LM_DEBUG,
+                  ASYS_TEXT ("%s\n"),
+                  entry->base ()));
   }
 
   return 0;
@@ -146,24 +170,28 @@ iterator_test ()
 
 #if defined (ACE_HAS_THREADS)
 
-static
-int
+static int
 single_thread_performance_test (int queue_type = 0)
 {
-  const char test_message[] = "ACE_Message_Queue Test Message";
-  const ASYS_TCHAR *message = ASYS_TEXT ("ACE_Message_Queue<ACE_NULL_SYNCH>, single thread");
+  const char test_message[] =
+    "ACE_Message_Queue Test Message";
+  const ASYS_TCHAR *message =
+    ASYS_TEXT ("ACE_Message_Queue<ACE_NULL_SYNCH>, single thread");
   int i;
 
   // Create a message queue.
   ACE_Message_Queue_Base *msgq = 0;
 
   if (queue_type == 0)
-    ACE_NEW_RETURN (msgq, QUEUE, -1);
+    ACE_NEW_RETURN (msgq,
+                    QUEUE,
+                    -1);
 #if defined (VXWORKS)
   else
     {
       ACE_NEW_RETURN (msgq,
-                      ACE_Message_Queue_Vx (messages, MAX_MESSAGE_SIZE),
+                      ACE_Message_Queue_Vx (messages,
+                                            MAX_MESSAGE_SIZE),
                       -1);
       message = "ACE_Message_Queue_Vx, single thread test";
     }
@@ -180,15 +208,20 @@ single_thread_performance_test (int queue_type = 0)
   // Create the messages.  Allocate off the heap in case messages
   // is large relative to the amount of stack space available.
   ACE_Message_Block **send_block;
-  ACE_NEW_RETURN (send_block, ACE_Message_Block *[messages], -1);
+  ACE_NEW_RETURN (send_block,
+                  ACE_Message_Block *[messages],
+                  -1);
 
   for (i = 0; i < messages; ++i)
     ACE_NEW_RETURN (send_block[i],
-                    ACE_Message_Block (test_message, MAX_MESSAGE_SIZE),
+                    ACE_Message_Block (test_message,
+                                       MAX_MESSAGE_SIZE),
                     -1);
 
   ACE_Message_Block **receive_block_p;
-  ACE_NEW_RETURN (receive_block_p, ACE_Message_Block *[messages], -1);
+  ACE_NEW_RETURN (receive_block_p,
+                  ACE_Message_Block *[messages],
+                  -1);
 
 #if defined (VXWORKS)
   // Set up blocks to receive the messages.  Allocate these off the
@@ -216,19 +249,24 @@ single_thread_performance_test (int queue_type = 0)
   for (i = 0; i < messages; ++i)
     {
       if (msgq->enqueue_tail (send_block[i]) == -1)
-        ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("%p\n"),
-                           ASYS_TEXT ("enqueue")), -1);
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           ASYS_TEXT ("%p\n"),
+                           ASYS_TEXT ("enqueue")),
+                          -1);
 
       if (msgq->dequeue_head (receive_block_p[i]) == -1)
-        ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("%p\n"),
-                           ASYS_TEXT ("dequeue_head")), -1);
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           ASYS_TEXT ("%p\n"),
+                           ASYS_TEXT ("dequeue_head")),
+                          -1);
     }
 
   timer->stop ();
 
   ACE_Time_Value tv;
   timer->elapsed_time (tv);
-  ACE_DEBUG ((LM_INFO, ASYS_TEXT ("%s: %u messages took %u msec (%f msec/message)\n"),
+  ACE_DEBUG ((LM_INFO,
+              ASYS_TEXT ("%s: %u messages took %u msec (%f msec/message)\n"),
               message,
               messages,
               tv.msec (),
@@ -248,41 +286,47 @@ single_thread_performance_test (int queue_type = 0)
   return 0;
 }
 
-static
-void *
+static void *
 receiver (void *arg)
 {
-  Queue_Wrapper *queue_wrapper = ACE_reinterpret_cast (Queue_Wrapper *, arg);
+  Queue_Wrapper *queue_wrapper =
+    ACE_reinterpret_cast (Queue_Wrapper *,
+                          arg);
   int i;
 
   ACE_Message_Block **receive_block_p;
-  ACE_NEW_RETURN (receive_block_p, ACE_Message_Block *[messages], (void *) -1);
+  ACE_NEW_RETURN (receive_block_p,
+                  ACE_Message_Block *[messages],
+                  (void *) -1);
 
 #if defined (VXWORKS)
   // Set up blocks to receive the messages.  Allocate these off the
-  // heap in case messages is large relative to the amount of
-  // stack space available.
+  // heap in case messages is large relative to the amount of stack
+  // space available.
   ACE_Message_Block *receive_block;
-  ACE_NEW_RETURN (receive_block, ACE_Message_Block[messages], (void *) -1);
+  ACE_NEW_RETURN (receive_block,
+                  ACE_Message_Block[messages],
+                  (void *) -1);
 
   for (i = 0; i < messages; ++i)
     {
-      // There's got to be a better way to do this.  init () doesn't
+      // There's got to be a better way to do this.  <init> doesn't
       // delete any existing data block, so we do it explicitly.
       delete receive_block[i].data_block ();
       receive_block[i].init (MAX_MESSAGE_SIZE);
 
       // For VxWorks Message Queues, the receive block pointer must be
-      // assigned.  It will be used by dequeue_head ().
+      // assigned.  It will be used by <dequeue_head>.
       receive_block_p[i] = &receive_block[i];
     }
 #endif /* VXWORKS */
 
   for (i = 0; i < messages; ++i)
     if (queue_wrapper->q_->dequeue_head (receive_block_p[i]) == -1)
-      ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("%p\n"),
-                         ASYS_TEXT ("dequeue_head")), 0);
-
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         ASYS_TEXT ("%p\n"),
+                         ASYS_TEXT ("dequeue_head")),
+                        0);
   timer->stop ();
 
   delete [] receive_block_p;
@@ -293,11 +337,11 @@ receiver (void *arg)
   return 0;
 }
 
-static
-void *
+static void *
 sender (void *arg)
 {
-  Queue_Wrapper *queue_wrapper = ACE_reinterpret_cast (Queue_Wrapper *, arg);
+  Queue_Wrapper *queue_wrapper =
+    ACE_reinterpret_cast (Queue_Wrapper *, arg);
   int i;
 
   timer->start ();
@@ -306,9 +350,10 @@ sender (void *arg)
   for (i = 0; i < messages; ++i)
     if (queue_wrapper->q_->
         enqueue_tail (queue_wrapper->send_block_[i]) == -1)
-      ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("%p\n"),
-                         ASYS_TEXT ("enqueue")), 0);
-
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         ASYS_TEXT ("%p\n"),
+                         ASYS_TEXT ("enqueue")),
+                        0);
   return 0;
 }
 
@@ -317,30 +362,37 @@ int
 performance_test (int queue_type = 0)
 {
   Queue_Wrapper queue_wrapper;
-  const ASYS_TCHAR *message = ASYS_TEXT ("ACE_Message_Queue<ACE_SYNCH>");
+  const ASYS_TCHAR *message =
+    ASYS_TEXT ("ACE_Message_Queue<ACE_SYNCH>");
   int i;
 
-  // Create the messages.  Allocate off the heap in case messages
-  // is large relative to the amount of stack space available.
-  // Allocate it here instead of in the sender, so that we can
-  // delete it after the _receiver_ is done.
+  // Create the messages.  Allocate off the heap in case messages is
+  // large relative to the amount of stack space available.  Allocate
+  // it here instead of in the sender, so that we can delete it after
+  // the _receiver_ is done.
   ACE_Message_Block **send_block;
-  ACE_NEW_RETURN (send_block, ACE_Message_Block *[messages], -1);
+  ACE_NEW_RETURN (send_block,
+                  ACE_Message_Block *[messages],
+                  -1);
 
   for (i = 0; i < messages; ++i)
     ACE_NEW_RETURN (send_block[i],
-                    ACE_Message_Block (test_message, MAX_MESSAGE_SIZE),
+                    ACE_Message_Block (test_message,
+                                       MAX_MESSAGE_SIZE),
                     -1);
 
   queue_wrapper.send_block_ = send_block;
 
   if (queue_type == 0)
-    ACE_NEW_RETURN (queue_wrapper.q_, SYNCH_QUEUE, -1);
+    ACE_NEW_RETURN (queue_wrapper.q_,
+                    SYNCH_QUEUE,
+                    -1);
 #if defined (VXWORKS)
   else
     {
       ACE_NEW_RETURN (queue_wrapper.q_,
-                      ACE_Message_Queue_Vx (messages, MAX_MESSAGE_SIZE),
+                      ACE_Message_Queue_Vx (messages,
+                                            MAX_MESSAGE_SIZE),
                       -1);
       message = "ACE_Message_Queue_Vx";
     }
@@ -400,17 +452,22 @@ main (int argc, ASYS_TCHAR *argv[])
 
   if (argc == 2)
     if (! ACE_OS::strcmp (argv[1], ASYS_TEXT ("-?")))
-      ACE_ERROR ((LM_ERROR, ASYS_TEXT ("%s/n"), usage));
+      ACE_ERROR ((LM_ERROR,
+                  ASYS_TEXT ("%s/n"),
+                  usage));
     else
       messages = ACE_OS::atoi (argv[1]);
 
 #if !defined (VXWORKS)
-  // The iterator test occasionally causes a page fault or a hang on VxWorks.
+  // The iterator test occasionally causes a page fault or a hang on
+  // VxWorks.
   if (status == 0)
     status = iterator_test ();
 #endif /* ! VXWORKS */
 
-  ACE_NEW_RETURN (timer, ACE_High_Res_Timer, -1);
+  ACE_NEW_RETURN (timer,
+                  ACE_High_Res_Timer,
+                  -1);
 
 #if defined (ACE_HAS_THREADS)
   if (status == 0)
@@ -433,8 +490,9 @@ main (int argc, ASYS_TCHAR *argv[])
 #endif /* ACE_HAS_THREADS */
 
   if (status != 0)
-    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("%p\n"), ASYS_TEXT ("test failed")));
-
+    ACE_ERROR ((LM_ERROR,
+                ASYS_TEXT ("%p\n"),
+                ASYS_TEXT ("test failed")));
   delete timer;
   timer = 0;