Paced_Worker::Paced_Worker (ACE_Thread_Manager &thread_manager,
test_ptr test,
CORBA::Short rate,
CORBA::ULong iterations,
CORBA::Short priority,
RTCORBA::Current_ptr current,
RTCORBA::PriorityMapping &priority_mapping,
Synchronizers &synchronizers)
: ACE_Task_Base (&thread_manager),
test_ (test::_duplicate (test)),
rate_ (rate),
history_ (iterations),
priority_ (priority),
current_ (RTCORBA::Current::_duplicate (current)),
priority_mapping_ (priority_mapping),
synchronizers_ (synchronizers),
CORBA_priority_ (0),
native_priority_ (0),
interval_between_calls_ (),
missed_start_deadlines_ (0),
missed_end_deadlines_ (0),
missed_start_invocations_ (iterations),
missed_end_invocations_ (iterations)
{
this->interval_between_calls_ =
to_hrtime (1 / double (this->rate_), gsf);
}
int
max_throughput (test_ptr test,
RTCORBA::Current_ptr current,
RTCORBA::PriorityMapping &priority_mapping,
CORBA::ULong &max_rate)
{
CORBA::ULong calls_made = 0;
CORBA::Short CORBA_priority = 0;
CORBA::Short native_priority = 0;
try
{
CORBA_priority =
current->the_priority ();
CORBA::Boolean result =
priority_mapping.to_native (CORBA_priority,
native_priority);
if (!result)
ACE_ERROR_RETURN ((LM_ERROR,
"Error in converting CORBA priority %d to native priority\n",
CORBA_priority),
-1);
ACE_hrtime_t start =
ACE_OS::gethrtime ();
ACE_hrtime_t end =
start +
to_hrtime (max_throughput_timeout, gsf);
for (;;)
{
ACE_hrtime_t now =
ACE_OS::gethrtime ();
if (now > end)
break;
test->method (work,
prime_number);
++calls_made;
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
max_rate =
calls_made / max_throughput_timeout;
ACE_DEBUG ((LM_DEBUG,
"\nPriority = %d/%d; Max rate calculations => %d calls in %d seconds; Max rate = %.2f\n",
CORBA_priority,
native_priority,
calls_made,
max_throughput_timeout,
calls_made / (double) max_throughput_timeout));
return 0;
}
Worker::Worker (CORBA::ORB_ptr orb,
RTCORBA::RTORB_ptr rtorb,
CORBA::PolicyManager_ptr policy_manager,
Protocols::test_ptr test,
::CORBA::ULong iterations,
::CORBA::ULong invocation_rate,
::CORBA::Boolean count_missed_end_deadlines,
::CORBA::Boolean do_dump_history,
::CORBA::Boolean print_missed_invocations,
::CORBA::ULong message_size,
::CORBA::ULong test_protocol_tag,
::CORBA::ULong number_of_connection_attempts,
::CORBA::Boolean enable_diffserv_code_points,
::Protocols::Sender_Controller::Test_Type test_type)
: rtorb_ (RTCORBA::RTORB::_duplicate (rtorb)),
policy_manager_ (CORBA::PolicyManager::_duplicate (policy_manager)),
test_ (Protocols::test::_duplicate (test)),
history_ (iterations),
interval_between_calls_ (),
missed_start_deadlines_ (0),
missed_end_deadlines_ (0),
missed_start_invocations_ (iterations),
missed_end_invocations_ (iterations),
iterations_ (iterations),
invocation_rate_ (invocation_rate),
count_missed_end_deadlines_ (count_missed_end_deadlines),
do_dump_history_ (do_dump_history),
print_missed_invocations_ (print_missed_invocations),
message_size_ (message_size),
test_protocol_tag_ (test_protocol_tag),
number_of_connection_attempts_ (number_of_connection_attempts),
enable_diffserv_code_points_ (enable_diffserv_code_points),
test_type_ (test_type)
{
// Each sender will have a random session id. This helps in
// identifying late packets arriving at the server.
ACE_OS::srand ((unsigned) ACE_OS::time (0));
this->session_id_ = ACE_OS::rand ();
// Interval is inverse of rate.
this->interval_between_calls_ =
to_hrtime (1 / double (this->invocation_rate_), gsf);
// Base protocol is used for setting up and tearing down the test.
this->base_protocol_policy_.length (1);
// Test protocol is the one being tested.
this->test_protocol_policy_.length (1);
RTCORBA::ProtocolProperties_var base_transport_protocol_properties =
TAO_Protocol_Properties_Factory::create_transport_protocol_property (IOP::TAG_INTERNET_IOP,
orb->orb_core ());
RTCORBA::TCPProtocolProperties_var tcp_base_transport_protocol_properties =
RTCORBA::TCPProtocolProperties::_narrow (base_transport_protocol_properties.in ());
tcp_base_transport_protocol_properties->enable_network_priority (this->enable_diffserv_code_points_);
RTCORBA::ProtocolList protocols;
protocols.length (1);
protocols[0].transport_protocol_properties =
base_transport_protocol_properties;
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
// IIOP is always used for the base protocol.
protocols[0].protocol_type = IOP::TAG_INTERNET_IOP;
this->base_protocol_policy_[0] =
this->rtorb_->create_client_protocol_policy (protocols);
// User decides the test protocol.
protocols[0].protocol_type = test_protocol_tag;
RTCORBA::ProtocolProperties_var test_transport_protocol_properties =
TAO_Protocol_Properties_Factory::create_transport_protocol_property (protocols[0].protocol_type,
orb->orb_core ());
if (protocols[0].protocol_type == TAO_TAG_DIOP_PROFILE)
{
RTCORBA::UserDatagramProtocolProperties_var udp_test_transport_protocol_properties =
RTCORBA::UserDatagramProtocolProperties::_narrow (test_transport_protocol_properties.in ());
udp_test_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points);
}
else if (protocols[0].protocol_type == TAO_TAG_SCIOP_PROFILE)
{
RTCORBA::StreamControlProtocolProperties_var sctp_test_transport_protocol_properties =
RTCORBA::StreamControlProtocolProperties::_narrow (test_transport_protocol_properties.in ());
sctp_test_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points);
}
else if (protocols[0].protocol_type == IOP::TAG_INTERNET_IOP)
{
RTCORBA::TCPProtocolProperties_var tcp_test_transport_protocol_properties =
RTCORBA::TCPProtocolProperties::_narrow (test_transport_protocol_properties.in ());
tcp_test_transport_protocol_properties->enable_network_priority (enable_diffserv_code_points);
}
protocols[0].transport_protocol_properties =
test_transport_protocol_properties;
this->test_protocol_policy_[0] =
this->rtorb_->create_client_protocol_policy (protocols);
}
