#ifndef INCLUDE_TEST_PERFORMANCE_HPP
#define INCLUDE_TEST_PERFORMANCE_HPP
#include <string>
#include <boost/lexical_cast.hpp>
#include <RCF/ClientTransport.hpp>
#include <RCF/FilterService.hpp>
#include <RCF/Idl.hpp>
#include <RCF/RcfServer.hpp>
#include <RCF/ServerTransport.hpp>
#include <RCF/util/Profile.hpp>
class X
{
public:
void f0() {}
int f1(int) { return 0; }
std::string f2(const std::string &) { return ""; }
std::string echo(const std::string &s) { return s; }
};
RCF_BEGIN( I_X, "I_X" )
RCF_METHOD_V0(void, f0)
RCF_METHOD_R1(int, f1, int)
RCF_METHOD_R1(std::string, f2, const std::string &)
RCF_METHOD_R1(std::string, echo, const std::string &)
RCF_END( I_X )
void runClientTests(const RCF::I_Endpoint &clientEndpoint, int calls, const std::string &title)
{
RcfClient<I_X> client(clientEndpoint);
client.f0();
client.f1(1);
client.f2("");
for (int protocol=1; protocol<=10; protocol++)
{
if (RCF::isSerializationProtocolSupported(protocol))
{
client.getClientStub().setSerializationProtocol(protocol);
std::string protocolName = RCF::getSerializationProtocolName(protocol);
std::string titleHeader =
"Protocol: " + protocolName +
", Calls: " + boost::lexical_cast<std::string>(calls);
{
std::string desc = title + titleHeader + ", void f()";
util::Profile profile(desc);
for (int i=0; i<calls; i++)
{
client.f0();
}
}
{
std::string desc = title + titleHeader + ", int f(int)";
util::Profile profile(desc);
for (int i=0; i<calls; i++)
{
client.f1(0);
}
}
{
std::string desc = title + titleHeader + ", std::string f(std::string)";
util::Profile profile(desc);
for (int i=0; i<calls; i++)
{
client.f2("");
}
}
}
}
}
void runPerformanceTest(
const std::string &title,
RCF::ClientTransportAutoPtr clientTransportAutoPtr,
RCF::ServerTransportPtr serverTransportPtr,
RCF::RemoteCallSemantics rcs,
const std::string &s0,
int serializationProtocol,
const std::vector<RCF::FilterFactoryPtr> &filterFactories,
const std::vector<RCF::FilterPtr> &payloadFilters,
const std::vector<RCF::FilterPtr> &transportFilters,
int calls)
{
std::string serverTransportDesc = typeid(*serverTransportPtr).name();
std::string clientTransportDesc = typeid(*clientTransportAutoPtr).name();
std::string transportDesc = "(" + serverTransportDesc + ", " + clientTransportDesc + ")";
RCF::FilterServicePtr filterServicePtr( new RCF::FilterService() );
for (unsigned int i=0; i<filterFactories.size(); ++i)
{
filterServicePtr->addFilterFactory( filterFactories[i] );
}
std::string payloadFiltersDesc = "<empty>";
if (!payloadFilters.empty())
{
payloadFiltersDesc.clear();
for (unsigned int i=0; i<payloadFilters.size(); ++i)
{
payloadFiltersDesc += "<" + payloadFilters[i]->getFilterDescription().getName() + ">";
}
}
std::string transportFiltersDesc = "<empty>";
if (!transportFilters.empty())
{
transportFiltersDesc.clear();
for (unsigned int i=0; i<transportFilters.size(); ++i)
{
transportFiltersDesc += "<" + transportFilters[i]->getFilterDescription().getName() + ">";
}
}
std::string serializationProtocolDesc =
boost::lexical_cast<std::string>(serializationProtocol)
+ " (" + RCF::getSerializationProtocolName(serializationProtocol) + ")";
RCF_ASSERT(rcs == RCF::Oneway || rcs == RCF::Twoway);
std::string directionDesc = (rcs == RCF::Oneway) ? "one-way" : "two-way";
std::string profileDesc = title
+ " Transport: " + transportDesc
+ ", Semantics: " + "std::string echo(const std::string &)"
+ ", Direction: " + directionDesc
+ ", String length: " + boost::lexical_cast<std::string>(s0.length())
+ ", Ser. protocol: " + serializationProtocolDesc
+ ", Payload filters: " + payloadFiltersDesc
+ ", Transport filters: " + transportFiltersDesc
+ ", Calls: " + boost::lexical_cast<std::string>(calls);
RCF::RcfServer server(serverTransportPtr);
server.bind<I_X>( boost::shared_ptr<X>(new X) );
server.addService(filterServicePtr);
server.start();
// TODO: wait a little bit here?
// all calls on the same connection
RcfClient<I_X> client(clientTransportAutoPtr);
client.getClientStub().setSerializationProtocol(serializationProtocol);
client.getClientStub().setPayloadFilters(payloadFilters);
client.getClientStub().setTransportFilters(transportFilters);
std::string s = client.echo(s0);
util::Profile profile(profileDesc);
for (int i=0; i<calls; ++i)
{
std::string s = client.echo(rcs, s0);
}
}
#endif // ! INCLUDE_TEST_PERFORMANCE_HPP