int
Task::svc (void)
{
try
{
CORBA::Object_var object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
default_thread_priority =
get_implicit_thread_CORBA_priority (this->orb_.in ());
object =
this->orb_->string_to_object (ior);
test_var test =
test::_narrow (object.in ());
for (int i = 0; i < iterations; i++)
{
current->the_priority (default_thread_priority);
CORBA::Short priority =
test->method ();
if (priority != TAO_INVALID_PRIORITY)
{
current->the_priority (priority);
test->prioritized_method ();
}
}
if (shutdown_server)
{
test->shutdown ();
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Unexpected exception!");
return -1;
}
return 0;
}
int
Task::svc (void)
{
try
{
CORBA::Object_var object =
this->orb_->string_to_object (ior);
test_var test =
test::_narrow (object.in ());
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
// We need to set the client thread CORBA priority
current->the_priority (get_implicit_thread_CORBA_priority (this->orb_.in ()));
pid_t pid =
ACE_OS::getpid ();
for (int i = 0; i != iterations; ++i)
{
CORBA::Long r =
test->method (pid,
i);
ACE_ASSERT (r == i);
// Assert disappears on with optimizations on.
ACE_UNUSED_ARG (r);
}
if (shutdown_server)
{
test->shutdown ();
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
int
Task::svc (void)
{
try
{
CORBA::Object_var object =
this->orb_->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR: Panic <RootPOA> is nil\n"),
-1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
object = this->orb_->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in ());
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
// Create POA with CLIENT_PROPAGATED PriorityModelPolicy,
// and register Test object with it.
CORBA::PolicyList poa_policy_list;
poa_policy_list.length (1);
poa_policy_list[0] =
rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
0);
PortableServer::POA_var child_poa =
root_poa->create_POA ("Child_POA",
poa_manager.in (),
poa_policy_list);
Test_i server_impl (this->orb_.in ());
PortableServer::ObjectId_var id =
child_poa->activate_object (&server_impl);
CORBA::Object_var server =
child_poa->id_to_reference (id.in ());
// Print Object IOR.
CORBA::String_var ior =
this->orb_->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n\n", ior.in ()));
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
-1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
// Get the initial priority of the current thread.
CORBA::Short initial_thread_priority =
get_implicit_thread_CORBA_priority (this->orb_.in ());
current->the_priority (initial_thread_priority);
// Run ORB Event loop.
poa_manager->activate ();
this->orb_->run ();
ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n"));
// Get the final priority of the current thread.
CORBA::Short final_thread_priority =
current->the_priority ();
if (final_thread_priority != initial_thread_priority)
ACE_DEBUG ((LM_DEBUG,
"ERROR: Priority of the servant thread "
"has been permanently changed!\n"
"Initial priority: %d Final priority: %d\n",
initial_thread_priority, final_thread_priority));
else
ACE_DEBUG ((LM_DEBUG,
"Final priority of the servant thread"
" == its initial priority\n"));
}
catch (const ::CORBA::Exception & ex)
{
ex._tao_print_exception(
"Exception caught:");
return -1;
}
return 0;
}
int
Worker_Thread::svc (void)
{
try
{
// RTORB.
CORBA::Object_var object =
this->orb_->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in ());
if (check_for_nil (rt_orb.in (), "RTORB") == -1)
return 0;
// PolicyCurrent.
object =
this->orb_->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
if (check_for_nil (policy_current.in (), "PolicyCurrent")
== -1)
return 0;
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
// We need to set the client thread CORBA priority
current->the_priority (get_implicit_thread_CORBA_priority (this->orb_));
// Set ClientProtocolPolicy override on the Current.
RTCORBA::ProtocolList protocols;
protocols.length (1);
protocols[0].protocol_type = this->protocol_type_;
protocols[0].transport_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
CORBA::PolicyList policy_list;
policy_list.length (1);
policy_list[0] =
rt_orb->create_client_protocol_policy (protocols);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
// Wait for other threads.
this->synchronizer_->wait ();
for (int i = 0; i < iterations; ++i)
{
// Invoke method.
this->server_->test_method ();
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Worker Thread exception:");
}
return 0;
}
int
Task::svc (void)
{
try
{
CORBA::Object_var object =
this->orb_->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
object =
this->orb_->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb =
RTCORBA::RTORB::_narrow (object.in ());
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
RTCORBA::Priority default_thread_priority =
get_implicit_thread_CORBA_priority (this->orb_.in ());
test_i servant (this->orb_.in (),
root_poa.in (),
nap_time);
PortableServer::ObjectId_var id =
root_poa->activate_object (&servant);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
test_var test =
test::_narrow (object_act.in ());
int result =
write_ior_to_file (this->orb_.in (),
test.in ());
if (result != 0)
return result;
poa_manager->activate ();
CORBA::ULong stacksize = 0;
CORBA::Boolean allow_request_buffering = false;
CORBA::ULong max_buffered_requests = 0;
CORBA::ULong max_request_buffer_size = 0;
RTCORBA::ThreadpoolId threadpool_id_1 =
rt_orb->create_threadpool (stacksize,
static_threads,
dynamic_threads,
default_thread_priority,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size);
CORBA::Policy_var threadpool_policy_1 =
rt_orb->create_threadpool_policy (threadpool_id_1);
CORBA::Boolean allow_borrowing = false;
RTCORBA::ThreadpoolLanes lanes (1);
lanes.length (1);
lanes[0].lane_priority = default_thread_priority;
lanes[0].static_threads = static_threads;
lanes[0].dynamic_threads = dynamic_threads;
RTCORBA::ThreadpoolId threadpool_id_2 =
rt_orb->create_threadpool_with_lanes (stacksize,
lanes,
allow_borrowing,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size);
CORBA::Policy_var threadpool_policy_2 =
rt_orb->create_threadpool_policy (threadpool_id_2);
result =
create_POA_and_register_servant (threadpool_policy_1.in (),
"first_poa",
poa_manager.in (),
root_poa.in (),
this->orb_.in (),
rt_orb.in ());
if (result != 0)
return result;
result =
create_POA_and_register_servant (threadpool_policy_2.in (),
"second_poa",
poa_manager.in (),
root_poa.in (),
this->orb_.in (),
rt_orb.in ());
if (result != 0)
return result;
this->orb_->run ();
this->orb_->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
int
Task::svc (void)
{
try
{
CORBA::Object_var object =
this->orb_->string_to_object (ior);
test_var test =
test::_narrow (object.in ());
pid_t pid =
ACE_OS::getpid ();
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
// We need to set the client thread CORBA priority
current->the_priority (get_implicit_thread_CORBA_priority (this->orb_.in ()));
CORBA::Long tc = 0;
for (int i = 0; i != iterations; ++i)
{
CORBA::Long mtc = 0;
CORBA::Long r =
test->method (pid,
i,
mtc);
// Each 2 iterations sleep 5 seconds
if (i % 2 == 0)
ACE_OS::sleep (5);
ACE_ASSERT (r == i);
// Assert disappears on with optimizations on.
ACE_UNUSED_ARG (r);
if (mtc > tc)
{
// Number of threads increased, so store this.
ACE_DEBUG ((LM_DEBUG, "Thread count increased to %d\n", mtc));
tc = mtc;
}
else if (mtc < tc)
{
// Number of threads decreased!
ACE_DEBUG ((LM_DEBUG, "Thread count decreased to %d\n", mtc));
decreased = true;
tc = mtc;
}
}
ACE_OS::sleep (20);
CORBA::Long end = 0;
CORBA::Long re =
test->method (pid,
0,
end);
ACE_ASSERT (re == 0);
// Assert disappears on with optimizations on.
ACE_UNUSED_ARG (re);
if (end != 0)
{
ACE_ERROR ((LM_ERROR, "Dynamic thread count should be 0, not %d\n", end));
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
