path: root/perf/src/TAO/client.cpp

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

#include <tao/Messaging/Messaging.h>
#include <iostream>
#include <Roundtrip.h>
#include <Roundtrip_Handler.h>
#include <WorkerThread.h>

#include <IcePerf/Data.h>

using namespace std;

int do_shutdown = 1;

int
main(int argc, char *argv[])
{
    ACE_TRY_NEW_ENV
    {
	CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, "" ACE_ENV_ARG_PARAMETER);
	ACE_TRY_CHECK;
	
	CORBA::Object_var object = orb->resolve_initial_references("PolicyCurrent" ACE_ENV_ARG_PARAMETER);
	ACE_CHECK;

	CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow(object.in() ACE_ENV_ARG_PARAMETER);
	ACE_CHECK;

	CORBA::Any scope_as_any;
	scope_as_any <<= Messaging::SYNC_WITH_TRANSPORT;

	CORBA::PolicyList policies(1);
	policies.length(1);
	policies[0] = orb->create_policy(Messaging::SYNC_SCOPE_POLICY_TYPE, scope_as_any ACE_ENV_ARG_PARAMETER);
	ACE_CHECK;

	policy_current->set_policy_overrides(policies, CORBA::ADD_OVERRIDE ACE_ENV_ARG_PARAMETER);
	ACE_CHECK;

	policies[0]->destroy(ACE_ENV_SINGLE_ARG_PARAMETER);
	ACE_CHECK;

	CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
	ACE_TRY_CHECK;

	PortableServer::POA_var root_poa = PortableServer::POA::_narrow(poa_object.in() ACE_ENV_ARG_PARAMETER);
	ACE_TRY_CHECK;

	PortableServer::POAManager_var poa_manager = root_poa->the_POAManager(ACE_ENV_SINGLE_ARG_PARAMETER);
	ACE_TRY_CHECK;

	bool latency = false;
	bool oneway = false;
	bool twoway = false;
	bool ami = false;

	bool throughput = false;
	bool sendBytes = false;
	bool sendStrings = false;
	bool sendLongStrings = false;
	bool sendStructs = false;
	long byteSeqSize = 0;
	Ice::Int payloadSize = 0;
	int repetitions;

	int i;
	for(i = 0; i < argc; ++i)
	{
	    if(strcmp(argv[i], "latency") == 0)
	    {
		latency = true;
	    }
	    else if(strcmp(argv[i], "throughput") == 0)
	    {
		throughput = true;
	    }
	    else if(strcmp(argv[i], "oneway") == 0)
	    {
		oneway = true;
	    }
	    else if(strcmp(argv[i], "twoway") == 0)
	    {
		twoway = true;
	    }
	    else if(strcmp(argv[i], "ami") == 0)
	    {
		ami = true;
	    }
	    else if(strcmp(argv[i], "byte") == 0)
	    {
		sendBytes = true;
	    }
	    else if(strcmp(argv[i], "string") == 0)
	    {
		sendStrings = true;
	    }
	    else if(strcmp(argv[i], "longString") == 0)
	    {
		sendLongStrings = true;
	    }
	    else if(strcmp(argv[i], "struct") == 0)
	    {
		sendStructs = true;
	    }
	    else if(strncmp(argv[i], "--payload=", strlen("--payload=")) == 0)
	    {
		byteSeqSize = strtol(argv[i] + strlen("--payload="), 0, 10);
		if(errno == ERANGE)
		{
		    cerr << argv[0] << ": payload argument range error: " << argv[i] << endl;
		    return EXIT_FAILURE;
		}
	    }
	}

	//
	// Defaults to latency test if neither was selected.
	//
	if(!latency && !throughput)
	{
	    latency = true;
	}

	if(latency)
	{
	    if(!oneway && !twoway)
	    {
		twoway = true;
	    }
	}
	else if(throughput)
	{
	    if(!sendBytes && !sendStrings && !sendLongStrings && !sendStructs)
	    {
		sendBytes = true;
	    }
	}

	object = orb->string_to_object("file://test.ior" ACE_ENV_ARG_PARAMETER);
	ACE_TRY_CHECK;

	Test::Roundtrip_var roundtrip = Test::Roundtrip::_narrow(object.in() ACE_ENV_ARG_PARAMETER);
	ACE_TRY_CHECK;

	if(CORBA::is_nil(roundtrip.in()))
        {
	    ACE_ERROR_RETURN((LM_ERROR, "Nil Test::Roundtrip reference <%s>\n", "file://test.ior"), 1);
        }

	roundtrip->test_method(ACE_ENV_SINGLE_ARG_PARAMETER);
	ACE_TRY_CHECK;

	if(latency)
	{
	    Roundtrip_Handler *roundtrip_handler_impl;
	    ACE_NEW_RETURN(roundtrip_handler_impl, Roundtrip_Handler(), 1);
	    PortableServer::ServantBase_var owner_transfer(roundtrip_handler_impl);

	    Test::AMI_RoundtripHandler_var roundtrip_handler = 
		roundtrip_handler_impl->_this(ACE_ENV_SINGLE_ARG_PARAMETER);
	    ACE_TRY_CHECK;

	    poa_manager->activate(ACE_ENV_SINGLE_ARG_PARAMETER);
	    ACE_TRY_CHECK;

	    if(ami)
	    {
		WorkerThread *worker = new WorkerThread(orb.in());
		worker->activate(THR_NEW_LWP | THR_JOINABLE, 1, 1);
	    }

	    IceUtil::Time start = IceUtil::Time::now();

	    if(oneway)
	    {
		repetitions = 500000;
	    }
	    else
	    {
		repetitions = 100000;
	    }

	    Test::ByteSeq seq;
	    if(byteSeqSize > 0)
	    {
		seq.length(byteSeqSize);
		for(int i = 0; i < byteSeqSize; ++i)
		{
		    seq[i] = '0' + (char)(i % 10);
		}
		payloadSize = seq.length() * sizeof(seq[0]);
	    }

	    for(int i = 0; i != repetitions; ++i)
	    {
		if(oneway)
		{
		    if(byteSeqSize > 0)
		    {
			roundtrip->test_oneway_with_data(seq ACE_ENV_ARG_DECL_WITH_DEFAULTS);
			ACE_TRY_CHECK;
		    }
		    else
		    {
			roundtrip->test_oneway(ACE_ENV_SINGLE_ARG_PARAMETER);
			ACE_TRY_CHECK;
		    }
		}
		else if(ami)
		{
		    if(byteSeqSize > 0)
		    {
        
			roundtrip->sendc_sendByteSeq(roundtrip_handler.in(), seq ACE_ENV_ARG_DECL_WITH_DEFAULTS);
			ACE_TRY_CHECK;
			roundtrip_handler_impl->waitFinished();
		    }
		    else
		    {
			roundtrip->sendc_test_method(roundtrip_handler.in() ACE_ENV_SINGLE_ARG_PARAMETER);
			ACE_TRY_CHECK;
			roundtrip_handler_impl->waitFinished();
		    }
		}
		else if(byteSeqSize > 0)
		{
		    roundtrip->sendByteSeq(seq ACE_ENV_SINGLE_ARG_PARAMETER);
		    ACE_TRY_CHECK;
		}
		else
		{
		    roundtrip->test_method(ACE_ENV_SINGLE_ARG_PARAMETER);
		    ACE_TRY_CHECK;
		}
	    }

	    if(oneway)
	    {
		roundtrip->test_method(ACE_ENV_SINGLE_ARG_PARAMETER);
	    }

	    IcePerf::TestPrinter formatter;
	    formatter.fmt(cout, "TAO", "latency", IceUtil::Time::now() - start, repetitions, payloadSize, argc, argv);

	    roundtrip->shutdown(ACE_ENV_SINGLE_ARG_PARAMETER);
	    ACE_TRY_CHECK;

	    orb->destroy(ACE_ENV_SINGLE_ARG_PARAMETER);
	    ACE_TRY_CHECK;
	}
	else
	{
	    repetitions = 1000;
	    int i;
	    Test::ByteSeq seq;
	    seq.length(500000);

	    Test::StringSeq stringSeq;
	    stringSeq.length(50000);
	    for(i = 0; i < 50000; ++i)
	    {
		stringSeq[i] = CORBA::string_dup("hello");
	    }

	    Test::StringSeq longStringSeq;
	    longStringSeq.length(5000);
	    for(i = 0; i < 5000; ++i)
	    {
		longStringSeq[i] = CORBA::string_dup("As far as the laws of mathematics refer to reality, "
						     "they are not certain; and as far as they are certain, "
						     "they do not refer to reality.");
	    }
	
	    Test::StringDoubleSeq stringDoubleSeq;
	    stringDoubleSeq.length(50000);
	    for(i = 0; i < 50000; ++i)
	    {
		stringDoubleSeq[i].str = CORBA::string_dup("hello");
		stringDoubleSeq[i].d = 3.14;
	    }

	    IceUtil::Time start = IceUtil::Time::now();

	    if(sendBytes)
	    {
		payloadSize = seq.length() * sizeof(seq[0]);
	    }
	    else if(sendStrings)
	    {
		payloadSize = stringSeq.length() * strlen(stringSeq[0]) * sizeof(stringSeq[0][0]);
	    }
	    else if(sendLongStrings)
	    {
		payloadSize = longStringSeq.length() * strlen(longStringSeq[0]) * sizeof(longStringSeq[0][0]);
	    }
	    else if(sendStructs)
	    {
		payloadSize = stringDoubleSeq.length() * (strlen(stringDoubleSeq[0].str) * sizeof(stringDoubleSeq[0].str[0]) + 
							  sizeof(stringDoubleSeq[0].d));
	    }
	    else
	    {
		assert(false);
	    }
	    
	    for(i = 0; i < repetitions; ++i)
	    {
		if(sendBytes)
		{
		    roundtrip->sendByteSeq(seq);
		}
		else if(sendStrings)
		{
		    roundtrip->sendStringSeq(stringSeq);
		}
		else if(sendLongStrings)
		{
		    roundtrip->sendStringSeq(longStringSeq);
		}
		else if(sendStructs)
		{
		    roundtrip->sendStringDoubleSeq(stringDoubleSeq);
		}
	    }

	    IcePerf::TestPrinter formatter;
	    formatter.fmt(cout, "TAO", "throughput", IceUtil::Time::now() - start, repetitions, payloadSize, argc, argv);

	    roundtrip->shutdown(ACE_ENV_SINGLE_ARG_PARAMETER);
	    ACE_TRY_CHECK;

	    orb->destroy(ACE_ENV_SINGLE_ARG_PARAMETER);
	    ACE_TRY_CHECK;
	}			
    }
    ACE_CATCHANY
    {
	ACE_PRINT_EXCEPTION(ACE_ANY_EXCEPTION, "Exception caught:");
	return 1;
    }
    ACE_ENDTRY;

    return 0;
}