Logo Search packages:      
Sourcecode: zeroc-icee version File versions  Download package

Client.cpp

// **********************************************************************
//
// Copyright (c) 2003-2006 ZeroC, Inc. All rights reserved.
//
// This copy of Ice-E is licensed to you under the terms described in the
// ICEE_LICENSE file included in this distribution.
//
// **********************************************************************

#include <IceE/IceE.h>
#include <Throughput.h>

using namespace std;
using namespace Demo;

void
menu()
{
    printf("usage:\n");
    printf("\n");
    printf("toggle type of data to send:\n");
    printf("1: sequence of bytes (default)\n");
    printf("2: sequence of strings (\"hello\")\n");
    printf("3: sequence of structs with a string (\"hello\") and a double\n");
    printf("4: sequence of structs with two ints and a double\n");
    printf("\n");
    printf("select test to run:\n");
    printf("t: Send sequence as twoway\n");
    printf("o: Send sequence as oneway\n");
    printf("r: Receive sequence\n");
    printf("e: Echo (send and receive) sequence\n");
    printf("\n");
    printf("other commands:\n");
    printf("s: shutdown server\n");
    printf("x: exit\n");
    printf("?: help\n");
}

int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
{
    //
    // Check if we need to run with small sequences
    //
    int reduce = 1;
    int i;
    for(i = 0; i < argc; ++i)
    {
        if(strcmp(argv[i], "--small") == 0)
        {
            reduce = 100;
        }
    }

    Ice::PropertiesPtr properties = communicator->getProperties();
    const char* proxyProperty = "Throughput.Proxy";
    std::string proxy = properties->getProperty(proxyProperty);
    if(proxy.empty())
    {
      fprintf(stderr, "%s: property `%s' not set\n", argv[0], proxyProperty);
      return EXIT_FAILURE;
    }

    Ice::ObjectPrx base = communicator->stringToProxy(proxy);
    ThroughputPrx throughput = ThroughputPrx::checkedCast(base);
    if(!throughput)
    {
      fprintf(stderr, "%s: invalid proxy\n", argv[0]);
      return EXIT_FAILURE;
    }
    ThroughputPrx throughputOneway = ThroughputPrx::uncheckedCast(throughput->ice_oneway());

    ByteSeq byteSeq(ByteSeqSize / reduce, 0);
    pair<const Ice::Byte*, const Ice::Byte*> byteArr;
    byteArr.first = &byteSeq[0];
    byteArr.second = byteArr.first + byteSeq.size();

    StringSeq stringSeq(StringSeqSize / reduce, "hello");

    StringDoubleSeq structSeq(StringDoubleSeqSize / reduce);
    for(i = 0; i < StringDoubleSeqSize / reduce; ++i)
    {
        structSeq[i].s = "hello";
      structSeq[i].d = 3.14;
    }

    FixedSeq fixedSeq(FixedSeqSize / reduce);
    for(i = 0; i < FixedSeqSize / reduce; ++i)
    {
        fixedSeq[i].i = 0;
        fixedSeq[i].j = 0;
        fixedSeq[i].d = 0;
    }

    menu();

    throughput->ice_ping(); // Initial ping to setup the connection.

    //
    // By default use byte sequence.
    //
    char currentType = '1';
    int seqSize = ByteSeqSize / reduce;

    char c = EOF;
    do
    {
      try
      {
          printf("==> ");
          do
          {
              c = getchar();
          }
          while(c != EOF && c == '\n');

          IceUtil::Time tm = IceUtil::Time::now();
          const int repetitions = 1000;

          if(c == '1' || c == '2' || c == '3' || c == '4')
          {
            currentType = c;
              switch(c)
            {
                case '1':
                {
                    printf("using byte sequences\n");
                  seqSize = ByteSeqSize / reduce;
                  break;
                }

                case '2':
                {
                    printf("using string sequences\n");
                  seqSize = StringSeqSize / reduce;
                  break;
                }

                case '3':
                {
                    printf("using variable-length struct sequences\n");
                  seqSize = StringDoubleSeqSize / reduce;
                  break;
                }

                case '4':
                {
                    printf("using fixed-length struct sequences\n");
                  seqSize = FixedSeqSize / reduce;
                  break;
                }
            }
          }
          else if(c == 't' || c == 'o' || c == 'r' || c == 'e')
          {
            switch(c)
            {
                case 't':
                case 'o':
                {
                  printf("sending");
                  break;
                }

                case 'r':
                {
                  printf("receiving");
                  break;
                }

                case 'e':
                {
                  printf("sending and receiving");
                  break;
                }
            }

            printf(" %d", repetitions);
              switch(currentType)
            {
                case '1':
                {
                    printf(" byte");
                  break;
                }

                case '2':
                {
                    printf(" string");
                  break;
                }

                case '3':
                {
                    printf(" variable-length struct");
                  break;
                }

                case '4':
                {
                    printf(" fixed-length struct");
                  break;
                }
            }
            printf(" sequences of size %d", seqSize);


            if(c == 'o')
            {
                printf(" as oneway");
            }
            
            printf("...\n");
            
            for(int i = 0; i < repetitions; ++i)
            {
                switch(currentType)
                {
                    case '1':
                  {
                        switch(c)
                        {
                          case 't':
                          {
                              throughput->sendByteSeq(byteArr);
                              break;
                          }
                  
                          case 'o':
                          {
                              throughputOneway->sendByteSeq(byteArr);
                              break;
                          }
                  
                          case 'r':
                          {
                              throughput->recvByteSeq();
                              break;
                          }
                  
                          case 'e':
                          {
                              throughput->echoByteSeq(byteSeq);
                              break;
                          }
                      }
                      break;
                  }

                    case '2':
                  {
                        switch(c)
                        {
                          case 't':
                          {
                              throughput->sendStringSeq(stringSeq);
                              break;
                          }
                  
                          case 'o':
                          {
                              throughputOneway->sendStringSeq(stringSeq);
                              break;
                          }
                  
                          case 'r':
                          {
                              throughput->recvStringSeq();
                              break;
                          }
                  
                          case 'e':
                          {
                              throughput->echoStringSeq(stringSeq);
                              break;
                          }
                      }
                      break;
                  }

                    case '3':
                  {
                        switch(c)
                        {
                          case 't':
                          {
                              throughput->sendStructSeq(structSeq);
                              break;
                          }
                  
                          case 'o':
                          {
                              throughputOneway->sendStructSeq(structSeq);
                              break;
                          }
                  
                          case 'r':
                          {
                              throughput->recvStructSeq();
                              break;
                          }
                  
                          case 'e':
                          {
                              throughput->echoStructSeq(structSeq);
                              break;
                          }
                      }
                      break;
                  }

                    case '4':
                  {
                        switch(c)
                        {
                          case 't':
                          {
                              throughput->sendFixedSeq(fixedSeq);
                              break;
                          }
                  
                          case 'o':
                          {
                              throughputOneway->sendFixedSeq(fixedSeq);
                              break;
                          }
                  
                          case 'r':
                          {
                              throughput->recvFixedSeq();
                              break;
                          }
                  
                          case 'e':
                          {
                              throughput->echoFixedSeq(fixedSeq);
                              break;
                          }
                      }
                      break;
                  }
                }
            }

            tm = IceUtil::Time::now() - tm;
            printf("time for %d sequences: %fms\n", repetitions, tm.toMilliSecondsDouble());
            printf("time per sequence: %fms\n", tm.toMilliSecondsDouble() / repetitions);
            int wireSize = 0;
            switch(currentType)
            {
                case '1':
                {
                  wireSize = 1;
                  break;
                }
                case '2':
                {
                    wireSize = static_cast<int>(stringSeq[0].size());
                  break;
                }
                case '3':
                {
                  wireSize = static_cast<int>(structSeq[0].s.size());
                  wireSize += 8; // Size of double on the wire.
                  break;
                }
                case '4':
                {
                  wireSize = 16; // Size of two ints and a double on the wire.
                  break;
                }
            }
            double mbit = repetitions * seqSize * wireSize * 8.0 / tm.toMicroSeconds();
            if(c == 'e')
            {
                mbit *= 2;
            }
            printf("throughput: %.2fMbps\n", mbit);
          }
          else if(c == 's')
          {
            throughput->shutdown();
          }
          else if(c == 'x')
          {
            // Nothing to do
          }
          else if(c == '?')
          {
            menu();
          }
          else
          {
            printf("unknown command `%c'\n", c);
            menu();
          }
      }
      catch(const Ice::Exception& ex)
      {
          fprintf(stderr, "%s\n", ex.toString().c_str());
      }
    }
    while(c != EOF && c != 'x');

    return EXIT_SUCCESS;
}

int
main(int argc, char* argv[])
{
    int status;
    Ice::CommunicatorPtr communicator;

    try
    {
      Ice::PropertiesPtr properties = Ice::createProperties();
        properties->load("config");
      communicator = Ice::initializeWithProperties(argc, argv, properties);
      status = run(argc, argv, communicator);
    }
    catch(const Ice::Exception& ex)
    {
      fprintf(stderr, "%s\n", ex.toString().c_str());
      status = EXIT_FAILURE;
    }

    if(communicator)
    {
      try
      {
          communicator->destroy();
      }
      catch(const Ice::Exception& ex)
      {
          fprintf(stderr, "%s\n", ex.toString().c_str());
          status = EXIT_FAILURE;
      }
    }

    return status;
}

Generated by  Doxygen 1.6.0   Back to index