TAO/examples/PluggableUDP/tests/SimplePerformance/client.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    client.cpp
   5  *
   6  *  This is the client for the UDP simple performance test.
   7  *
   8  *  @author Michael Kircher <Michael.Kircher@mchp.siemens.de>
   9  */
  10 //=============================================================================
  11
  12
  13 #include "ace/Get_Opt.h"
  14 #include "ace/Task.h"
  15 #include "ace/High_Res_Timer.h"
  16 #include "testC.h"
  17
  18 // The following include file forces DIOP to be linked into the
  19 // executable and initialized for static builds.
  20 #include "tao/Strategies/advanced_resource.h"
  21
  22 #if defined (ACE_VXWORKS) && !defined (__RTP__)
  23 # undef ACE_MAIN
  24 # define ACE_MAIN testClient
  25 #endif
  26
  27 const ACE_TCHAR *ior = ACE_TEXT ("file://test.ior");
  28
  29 int
  30 parse_args (int argc, ACE_TCHAR *argv[])
  31 {
  32   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:"));
  33   int c;
  34
  35   while ((c = get_opts ()) != -1)
  36     switch (c)
  37       {
  38       case 'k':
  39         ior = get_opts.opt_arg ();
  40         break;
  41
  42       case '?':
  43       default:
  44         ACE_ERROR_RETURN ((LM_ERROR,
  45                            "usage:  %s "
  46                            "-k <ior> "
  47                            "\n",
  48                            argv [0]),
  49                           -1);
  50       }
  51   // Indicates successful parsing of the command line
  52   return 0;
  53 }
  54
  55 ACE_UINT32 niter = 10;
  56 ACE_UINT32 SIZE_BLOCK= 256;
  57
  58 /**
  59  * @class Client
  60  *
  61  * @brief Run the client thread
  62  *
  63  * Use the ACE_Task_Base class to run the client threads.
  64  */
  65 class Client
  66 {
  67 public:
  68   /// ctor
  69   Client (Simple_Server_ptr server, ACE_UINT32 niterations);
  70
  71   virtual ~Client (void) {};
  72
  73   /// The thread entry point.
  74   virtual int svc (void);
  75
  76 private:
  77   /// The server.
  78   Simple_Server_var server_;
  79
  80   /// The number of iterations on each client thread.
  81   ACE_UINT32 niterations_;
  82 };
  83
  84
  85 //int testClient (char* orbName, char* ior)
  86 int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
  87 {
  88   try
  89     {
  90       CORBA::ORB_var orb =
  91           CORBA::ORB_init (argc,
  92                            argv,
  93                            "ORB_Test_Client");
  94
  95       if (parse_args (argc, argv) != 0)
  96         return 1;
  97
  98       CORBA::Object_var object =
  99         orb->string_to_object (ior);
 100
 101       Simple_Server_var server =
 102         Simple_Server::_narrow (object.in ());
 103
 104       if (CORBA::is_nil (server.in ()))
 105         {
 106           ACE_ERROR_RETURN ((LM_ERROR,
 107                              "Object reference <%s> is nil.\n",
 108                              ior),
 109                             1);
 110         }
 111
 112       CORBA::String_var string =
 113         orb->object_to_string (server.in ());
 114
 115       ACE_DEBUG ((LM_DEBUG,
 116                   "Client: orb->object_to_string: <%C>\n",
 117                   string.in ()));
 118
 119       Client client (server.in (), niter);
 120
 121       client.svc ();
 122
 123       //ACE_DEBUG ((LM_DEBUG, "threads finished\n"));
 124
 125       orb->destroy ();
 126     }
 127   catch (const CORBA::Exception& ex)
 128     {
 129       ex._tao_print_exception ("Caught exception:");
 130       return 1;
 131     }
 132
 133   return 0;
 134 }
 135
 136
 137 // ****************************************************************
 138
 139 Client::Client (Simple_Server_ptr server,
 140                 ACE_UINT32 niterations)
 141   :  server_ (Simple_Server::_duplicate (server)),
 142      niterations_ (niterations)
 143 {
 144 }
 145
 146
 147 int
 148 Client::svc (void)
 149 {
 150   try
 151     {
 152       Octet_Seq octetSeq(SIZE_BLOCK);
 153       Char_Seq charSeq(SIZE_BLOCK);
 154       ACE_High_Res_Timer timer;
 155       ACE_OS::printf("Start sending %d Msgs...\n",this->niterations_);
 156
 157       charSeq.length(SIZE_BLOCK);
 158       octetSeq.length(SIZE_BLOCK);
 159
 160       // This sets up the connector, so that we do not incur
 161       // the overhead on the first call in the loop.
 162       server_->sendCharSeq (charSeq);
 163
 164       timer.start ();
 165
 166       ACE_UINT32 client_count = 0;
 167       for (ACE_UINT32 i = 0; i < this->niterations_; ++i)
 168         {
 169           client_count++;
 170
 171           server_->sendCharSeq (charSeq);
 172
 173           //server_->sendOctetSeq (octetSeq);
 174
 175           //ACE_DEBUG ((LM_DEBUG, "."));
 176         }
 177       timer.stop ();
 178
 179       ACE_Time_Value measured;
 180       timer.elapsed_time (measured);
 181
 182       //ACE_DEBUG ((LM_DEBUG, "...finished\n"));
 183
 184       time_t dur = measured.sec () * 1000000 + measured.usec ();
 185       if (dur == 0 || this->niterations_ == 0)
 186         ACE_DEBUG ((LM_DEBUG, "Time not measurable, calculation skipped\n"));
 187       else
 188       {
 189         ACE_DEBUG ((LM_DEBUG,
 190                     "Time for %u Msgs: %u usec\n",
 191                     this->niterations_,
 192                     dur));
 193
 194         ACE_DEBUG ((LM_DEBUG, "Time for 1 Msg: %u usec, %u calls/sec\n",
 195                     dur / this->niterations_,
 196                     1000000 / (dur / this->niterations_)));
 197       }
 198
 199       for (int c = 0; c < 10; ++c)
 200         server_->shutdown ();
 201
 202     }
 203   catch (const CORBA::Exception& ex)
 204     {
 205       ex._tao_print_exception ("MT_Client: exception raised");
 206     }
 207   return 0;
 208 }