TAO/tests/OctetSeq/OctetSeq.cpp

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    OctetSeq.cpp
   6  *
   7  * TAO optimizes octet sequences, this test verifies that the
   8  * optimizations do not break any code and that they effectively
   9  * improve performance.
  10  *
  11  *  @author Carlos O'Ryan
  12  */
  13 //=============================================================================
  14
  15 #include "ace/Get_Opt.h"
  16 #include "ace/High_Res_Timer.h"
  17
  18 #include "tao/ORB.h"
  19 #include "tao/CDR.h"
  20 #include "testC.h"
  21 #include "ace/OS_NS_string.h"
  22
  23 static int
  24 test_write_octet (TAO_OutputCDR &cdr,
  25                   char* /* buf */,
  26                   size_t bufsize)
  27 {
  28 #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
  29   ACE_Message_Block mb (/* buf, */ bufsize);
  30   mb.wr_ptr (bufsize);
  31   Test::OctetSeq os (bufsize, &mb);
  32 #else
  33   Test::OctetSeq os (bufsize);
  34   os.length (bufsize);
  35 #endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */
  36
  37
  38   if ((cdr << os) == 0)
  39     return -1;
  40   return 0;
  41 }
  42
  43 static int
  44 test_read_octet (TAO_InputCDR &cdr,
  45                  char* /* buf */,
  46                  size_t /* bufsize */)
  47 {
  48   Test::OctetSeq os;
  49
  50   if ((cdr >> os) == 0)
  51     return -1;
  52   return 0;
  53 }
  54
  55 static int
  56 test_write_char (TAO_OutputCDR &cdr,
  57                  char* buf,
  58                  size_t bufsize)
  59 {
  60   Test::CharSeq cs (bufsize, bufsize, buf);
  61
  62   if ((cdr << cs) == 0)
  63     return -1;
  64   return 0;
  65 }
  66
  67 static int
  68 test_read_char (TAO_InputCDR &cdr,
  69                 char* /* buf */,
  70                 size_t /* bufsize */)
  71 {
  72   Test::CharSeq cs;
  73
  74   if ((cdr >> cs) == 0)
  75     return -1;
  76   return 0;
  77 }
  78
  79 typedef
  80 int (*Writer)(TAO_OutputCDR& cdr,
  81               char* buf, size_t bufsize);
  82 typedef
  83 int (*Reader)(TAO_InputCDR& cdr,
  84               char* buf, size_t bufsize);
  85
  86 int
  87 run (char* buf, size_t bufsize,
  88      size_t n, size_t lo, size_t s,
  89      int quiet,
  90      const ACE_TCHAR* name,
  91      Writer writer, Reader reader)
  92 {
  93   size_t count = 0;
  94   double sum_read = 0;
  95   double sum_write = 0;
  96
  97   for (size_t x = lo; x <= bufsize; x += s)
  98     {
  99       ACE_High_Res_Timer writing;
 100       ACE_High_Res_Timer reading;
 101
 102       for (size_t i = 0; i < n; ++i)
 103         {
 104           writing.start_incr ();
 105           TAO_OutputCDR output;
 106
 107           if (writer (output, buf, x) != 0)
 108             return -1;
 109           writing.stop_incr ();
 110
 111           TAO_InputCDR input (output);
 112           reading.start_incr ();
 113           if (reader (input, buf, x) != 0)
 114             return -1;
 115           reading.stop_incr ();
 116         }
 117
 118       double m = n;
 119
 120       ACE_Time_Value wtv;
 121       writing.elapsed_time_incr (wtv);
 122       ACE_hrtime_t wusecs = wtv.sec ();
 123       wusecs *= static_cast<ACE_UINT32> (ACE_ONE_SECOND_IN_USECS);
 124       wusecs += wtv.usec ();
 125
 126       ACE_Time_Value rtv;
 127       reading.elapsed_time_incr (rtv);
 128       ACE_hrtime_t rusecs = rtv.sec ();
 129       rusecs *= static_cast<ACE_UINT32> (ACE_ONE_SECOND_IN_USECS);
 130       rusecs += rtv.usec ();
 131
 132       double write_average = ACE_HRTIME_CONVERSION(wusecs) / m;
 133       double read_average = ACE_HRTIME_CONVERSION(rusecs) / m;
 134
 135       count++;
 136       sum_read += read_average;
 137       sum_write += write_average;
 138       if (quiet == 0)
 139         {
 140           ACE_DEBUG ((LM_DEBUG,
 141                       "%s: %d %.3f %.3f\n",
 142                       name, x, write_average, read_average));
 143         }
 144     }
 145
 146   if (count != 0)
 147     {
 148       ACE_DEBUG ((LM_DEBUG,
 149                   "%s total: %.3f %.3f\n",
 150                   name, sum_write / count, sum_read / count));
 151     }
 152   return 0;
 153 }
 154
 155 int
 156 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 157 {
 158   try
 159     {
 160       CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
 161
 162       int n = 64;
 163       int lo = 128;
 164       int hi = 65536;
 165       int s = 32;
 166
 167       int quiet = 0;
 168
 169       ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("qn:l:h:s:"));
 170       int opt;
 171
 172       while ((opt = get_opt ()) != EOF)
 173         {
 174           switch (opt)
 175             {
 176             case 'n':
 177               n = ACE_OS::atoi (get_opt.opt_arg ());
 178               break;
 179             case 'l':
 180               lo = ACE_OS::atoi (get_opt.opt_arg ());
 181               break;
 182             case 'h':
 183               hi = ACE_OS::atoi (get_opt.opt_arg ());
 184               break;
 185             case 's':
 186               s = ACE_OS::atoi (get_opt.opt_arg ());
 187               break;
 188             case 'q':
 189               quiet = 1;
 190               break;
 191
 192             case '?':
 193             default:
 194               ACE_DEBUG ((LM_DEBUG,
 195                           "Usage: %s "
 196                           "-l low "
 197                           "-h high "
 198                           "-s step "
 199                           "-n n "
 200                           "\n"
 201                           "Writes and then reads octet sequences to a CDR stream "
 202                           "starting from <low> up to <high> incrementing "
 203                           "by <step>, at each step run <n> iterations to "
 204                           "average."
 205                           "\n",
 206                           argv[0]));
 207               return -1;
 208             }
 209         }
 210
 211       ACE_DEBUG ((LM_DEBUG, "Running:\n"
 212                   "  low: %d\n"
 213                   "  hi : %d\n"
 214                   "  s  : %d\n"
 215                   "  n  : %d\n",
 216                   lo, hi, s, n));
 217
 218       // Create a "big" buffer and fill it up.
 219       char* buf = new char[hi];
 220       CORBA::Long l = 0xdeadbeef;
 221       for (int i = 0; i < hi / (int) sizeof (l); ++i)
 222         {
 223           ACE_OS::memcpy (buf + sizeof (l) * i, &l, sizeof (l));
 224         }
 225
 226       if (run (buf, hi,
 227                n, lo, s, quiet,
 228                ACE_TEXT ("OCTET"), test_write_octet, test_read_octet) != 0)
 229         return 1;
 230
 231       if (run (buf, hi,
 232                n, lo, s, quiet,
 233                ACE_TEXT ("CHAR"), test_write_char, test_read_char) != 0)
 234         return 1;
 235       delete[] buf;
 236     }
 237   catch (const CORBA::Exception& ex)
 238     {
 239       ex._tao_print_exception ("OctetSeq");
 240     }
 241
 242   return 0;
 243 }