void
Test_i::test_method (CORBA::Short priority)
{
// Use RTCurrent to find out the CORBA priority of the current
// thread.
CORBA::Object_var obj =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (obj.in ());
if (CORBA::is_nil (obj.in ()))
throw CORBA::INTERNAL ();
CORBA::Short servant_thread_priority =
current->the_priority ();
// Print out the info.
if (servant_thread_priority != priority)
ACE_DEBUG ((LM_DEBUG,
"ERROR: servant thread priority is not equal "
"to method argument.\n"));
ACE_DEBUG ((LM_DEBUG,
"Client priority: %d "
"Servant thread priority: %d\n",
priority, servant_thread_priority));
}
RTCORBA_Setup::RTCORBA_Setup (CORBA::ORB_ptr orb,
const RT_Class &rtclass,
int nthreads)
: lanes_ (3)
{
this->priority_mapping_manager_ =
RIR_Narrow<RTCORBA::PriorityMappingManager>::resolve (orb,
"PriorityMappingManager");
this->priority_mapping_ =
this->priority_mapping_manager_->mapping ();
RTCORBA::Current_var current =
RIR_Narrow<RTCORBA::Current>::resolve (orb,
"RTCurrent");
RTCORBA::Priority corba_prc_priority;
this->priority_mapping_->to_CORBA (rtclass.priority_process (),
corba_prc_priority);
current->the_priority (corba_prc_priority);
this->lanes_.length (3);
this->setup_lane (rtclass.priority_high (),
this->lanes_[0]);
this->setup_lane (rtclass.priority_process (),
this->lanes_[1]);
this->setup_lane (rtclass.priority_low (),
this->lanes_[2]);
this->lanes_[2].static_threads = nthreads;
this->process_priority_ = this->lanes_[1].lane_priority;
}
void
TAO_RT_Notify_Service::init_i (CORBA::ORB_ptr orb)
{
//Init the base class.
TAO_CosNotify_Service::init_i (orb);
TAO_Notify_RT_Properties* properties = TAO_Notify_RT_PROPERTIES::instance();
// Resolve RTORB
CORBA::Object_var object =
orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb =
RTCORBA::RTORB::_narrow (object.in ());
// Resolve RTCurrent
object =
orb->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
/// Set the properties
properties->rt_orb (rt_orb.in ());
properties->current (current.in ());
}
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
{
// Priority Mapping Manager.
CORBA::Object_var object =
this->orb_->resolve_initial_references ("PriorityMappingManager");
RTCORBA::PriorityMappingManager_var mapping_manager =
RTCORBA::PriorityMappingManager::_narrow (object.in ());
if (check_for_nil (mapping_manager.in (), "Mapping Manager") == -1)
return -1;
RTCORBA::PriorityMapping *pm =
mapping_manager->mapping ();
// RTCurrent.
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
if (check_for_nil (current.in (), "RTCurrent") == -1)
return -1;
// Obtain Test object reference.
object =
this->orb_->string_to_object (ior);
Test_var server = Test::_narrow (object.in ());
if (check_for_nil (server.in (), "Test object") == -1)
return -1;
// Check that test object is configured with CLIENT_PROPAGATED
// PriorityModelPolicy.
CORBA::Policy_var policy =
server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE);
RTCORBA::PriorityModelPolicy_var priority_policy =
RTCORBA::PriorityModelPolicy::_narrow (policy.in ());
if (check_for_nil (priority_policy.in (), "PriorityModelPolicy") == -1)
return -1;
RTCORBA::PriorityModel priority_model =
priority_policy->priority_model ();
if (priority_model != RTCORBA::CLIENT_PROPAGATED)
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR: priority_model != "
"RTCORBA::CLIENT_PROPAGATED!\n"),
-1);
// Spawn two worker threads.
ACE_Barrier thread_barrier (2);
int flags =
THR_NEW_LWP |
THR_JOINABLE |
this->orb_->orb_core ()->orb_params ()->thread_creation_flags ();
// Worker 1.
Worker_Thread worker1 (this->orb_.in (),
server.in (),
protocol1,
&thread_barrier);
CORBA::Short native_priority1 = 0;
if (pm->to_native (priority1, native_priority1) == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot convert corba priority %d to native priority\n",
priority1),
-1);
if (worker1.activate (flags,
1, 0,
native_priority1) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate first client worker threads\n"),
-1);
// Worker 2.
Worker_Thread worker2 (this->orb_.in (),
server.in (),
protocol2,
&thread_barrier);
CORBA::Short native_priority2 = 0;
if (pm->to_native (priority2, native_priority2) == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot convert corba priority %d to native priority\n",
priority2),
-1);
if (worker2.activate (flags,
1, 0,
native_priority2) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate second client worker threads\n"),
-1);
// Wait for worker threads to finish.
ACE_Thread_Manager::instance ()->wait ();
// Testing over. Shut down the server.
ACE_DEBUG ((LM_DEBUG, "Client threads finished\n"));
current->the_priority (priority1);
server->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"Unexpected exception in MT_Client_Protocol_Priority test client:");
return -1;
}
return 0;
}
int
Task::svc (void)
{
Synchronizers synchronizers;
gsf = ACE_High_Res_Timer::global_scale_factor ();
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 ());
object =
this->orb_->resolve_initial_references ("PriorityMappingManager");
RTCORBA::PriorityMappingManager_var mapping_manager =
RTCORBA::PriorityMappingManager::_narrow (object.in ());
RTCORBA::PriorityMapping &priority_mapping =
*mapping_manager->mapping ();
ULong_Array rates;
int result =
get_values ("client",
rates_file,
"rates",
rates,
1);
if (result != 0)
return result;
ULong_Array invocation_priorities;
result =
get_values ("client",
invocation_priorities_file,
"invocation priorities",
invocation_priorities,
1);
if (result != 0)
return result;
if (invocation_priorities.size () != 0 &&
invocation_priorities.size () != rates.size ())
ACE_ERROR_RETURN ((LM_ERROR,
"Number of invocation priorities (%d) != Number of rates (%d)\n",
invocation_priorities.size (),
rates.size ()),
-1);
synchronizers.number_of_workers_ =
rates.size () + continuous_workers;
CORBA::ULong max_rate = 0;
result =
max_throughput (test.in (),
current.in (),
priority_mapping,
max_rate);
if (result != 0)
return result;
CORBA::Short priority_range =
RTCORBA::maxPriority - RTCORBA::minPriority;
ACE_Thread_Manager paced_workers_manager;
CORBA::ULong i = 0;
Paced_Worker **paced_workers =
new Paced_Worker *[rates.size ()];
for (i = 0;
i < rates.size ();
++i)
{
CORBA::Short priority = 0;
if (invocation_priorities.size () == 0)
priority =
CORBA::Short ((priority_range /
double (rates.size ())) *
(i + 1));
else
priority =
invocation_priorities[i];
paced_workers[i] =
new Paced_Worker (paced_workers_manager,
test.in (),
rates[i],
time_for_test * rates[i],
priority,
current.in (),
priority_mapping,
synchronizers);
}
ACE_Thread_Manager continuous_workers_manager;
Continuous_Worker continuous_worker (continuous_workers_manager,
test.in (),
max_rate * time_for_test,
current.in (),
priority_mapping,
synchronizers);
long flags =
THR_NEW_LWP |
THR_JOINABLE |
this->orb_->orb_core ()->orb_params ()->thread_creation_flags ();
CORBA::Short CORBA_priority =
continuous_worker_priority;
CORBA::Short native_priority;
CORBA::Boolean convert_result =
priority_mapping.to_native (CORBA_priority,
native_priority);
if (!convert_result)
ACE_ERROR_RETURN ((LM_ERROR,
"Error in converting CORBA priority %d to native priority\n",
CORBA_priority),
-1);
int force_active = 0;
if (priority_setting == AT_THREAD_CREATION)
{
result =
continuous_worker.activate (flags,
continuous_workers,
force_active,
native_priority);
if (result != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Continuous_Worker::activate failed\n"),
result);
}
else
{
result =
continuous_worker.activate (flags,
continuous_workers);
if (result != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Continuous_Worker::activate failed\n"),
result);
}
flags =
THR_NEW_LWP |
THR_JOINABLE |
this->orb_->orb_core ()->orb_params ()->thread_creation_flags ();
for (i = 0;
i < rates.size ();
++i)
{
if (priority_setting == AT_THREAD_CREATION)
{
if (set_priority)
{
CORBA_priority =
paced_workers[i]->priority_;
convert_result =
priority_mapping.to_native (CORBA_priority,
native_priority);
if (!convert_result)
ACE_ERROR_RETURN ((LM_ERROR,
"Error in converting CORBA priority %d to native priority\n",
CORBA_priority),
-1);
}
result =
paced_workers[i]->activate (flags,
1,
force_active,
native_priority);
if (result != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Paced_Worker::activate failed\n"),
result);
}
else
{
result =
paced_workers[i]->activate (flags);
if (result != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Paced_Worker::activate failed\n"),
result);
}
}
if (rates.size () != 0)
{
paced_workers_manager.wait ();
}
continuous_workers_manager.wait ();
continuous_worker.print_collective_stats ();
for (i = 0;
i < rates.size ();
++i)
{
delete paced_workers[i];
}
delete[] paced_workers;
if (shutdown_server)
{
test->shutdown ();
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
int
Task::svc (void)
{
int result = 0;
try
{
CORBA::Object_var object =
this->orb_->string_to_object (ior);
Test_var server =
Test::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR: Object reference <%s> is nil\n",
ior),
-1);
}
// Check that the object is configured with CLIENT_PROPAGATED
// PriorityModelPolicy.
CORBA::Policy_var policy =
server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE);
RTCORBA::PriorityModelPolicy_var priority_policy =
RTCORBA::PriorityModelPolicy::_narrow (policy.in ());
if (CORBA::is_nil (priority_policy.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR: Priority Model Policy not exposed!\n"),
-1);
RTCORBA::PriorityModel priority_model =
priority_policy->priority_model ();
if (priority_model != RTCORBA::CLIENT_PROPAGATED)
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR: priority_model != "
"RTCORBA::CLIENT_PROPAGATED!\n"),
-1);
// Make several invocations, changing the priority of this thread
// for each.
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
object = this->orb_->resolve_initial_references ("PriorityMappingManager");
RTCORBA::PriorityMappingManager_var mapping_manager =
RTCORBA::PriorityMappingManager::_narrow (object.in ());
RTCORBA::PriorityMapping *pm =
mapping_manager->mapping ();
int sched_policy =
this->orb_->orb_core ()->orb_params ()->ace_sched_policy ();
int max_priority =
ACE_Sched_Params::priority_max (sched_policy);
int min_priority =
ACE_Sched_Params::priority_min (sched_policy);
CORBA::Short native_priority =
(max_priority - min_priority) / 2;
CORBA::Short desired_priority = 0;
for (int i = 0; i < 3; ++i)
{
if (pm->to_CORBA (native_priority, desired_priority) == 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Cannot convert native priority %d to corba priority\n",
native_priority));
result = -1;
break;
}
current->the_priority (desired_priority);
CORBA::Short priority =
current->the_priority ();
if (desired_priority != priority)
{
ACE_ERROR ((LM_ERROR,
"ERROR: No exception setting the priority but mismatch between requested and returned value from Current. "
"Set to %d but Current::the_priority returns %d\n", desired_priority, priority));
result = -1;
}
server->test_method (priority);
native_priority++;
}
// Shut down Server ORB.
server->shutdown ();
}
catch (const CORBA::DATA_CONVERSION& ex)
{
ex._tao_print_exception (
"Most likely, this is due to the in-ability "
"to set the thread priority.");
return -1;
}
catch (const CORBA::Exception & ae)
{
ae._tao_print_exception (
"Caught exception:");
return -1;
}
return result;
}
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;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow(naming_obj.in());
CosNaming::Name name;
name.length (1);
name[0].id = CORBA::string_dup("MyEventChannel");
CORBA::Object_var ecObj = naming_context->resolve(name);
CosNotifyChannelAdmin::EventChannel_var ec =
CosNotifyChannelAdmin::EventChannel::_narrow(ecObj.in());
CosNotifyChannelAdmin::AdminID adminid;
CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
CosNotifyChannelAdmin::AND_OP;
CosNotifyChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->new_for_consumers(ifgop,
adminid);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in());
CORBA::Object_var rtorb_obj = orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (rtorb_obj.in ());
// Create an RT POA with a lane at the given priority.
CORBA::Policy_var priority_model_policy =
rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
DEFAULT_PRIORITY);
RTCORBA::ThreadpoolLanes lanes (2);
lanes.length (2);
lanes[0].lane_priority = LOW_PRIORITY;
lanes[0].static_threads = 2;
lanes[0].dynamic_threads = 0;
lanes[1].lane_priority = HIGH_PRIORITY;
lanes[1].static_threads = 2;
lanes[1].dynamic_threads = 0;
// Create a thread-pool.
CORBA::ULong stacksize = 0;
CORBA::Boolean allow_request_buffering = 0;
CORBA::ULong max_buffered_requests = 0;
CORBA::ULong max_request_buffer_size = 0;
CORBA::Boolean allow_borrowing = 0;
// Create the thread-pool.
RTCORBA::ThreadpoolId threadpool_id =
rt_orb->create_threadpool_with_lanes (stacksize,
lanes,
allow_borrowing,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size);
// Create a thread-pool policy.
CORBA::Policy_var lanes_policy =
rt_orb->create_threadpool_policy (threadpool_id);
CORBA::PolicyList poa_policy_list(2);
poa_policy_list.length (2);
poa_policy_list[0] = priority_model_policy;
poa_policy_list[1] = lanes_policy;
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
PortableServer::POA_var rt_poa = poa->create_POA ("RT POA",
poa_manager.in (),
poa_policy_list);
PortableServer::Servant_var<StructuredEventConsumer_i> servant =
new StructuredEventConsumer_i(orb.in());
PortableServer::ObjectId_var objectId =
rt_poa->activate_object (servant.in());
CORBA::Object_var consumer_obj =
rt_poa->id_to_reference (objectId.in ());
CosNotifyComm::StructuredPushConsumer_var consumer =
CosNotifyComm::StructuredPushConsumer::_narrow (consumer_obj.in ());
NotifyExt::ThreadPoolLanesParams tpl_params;
tpl_params.priority_model = NotifyExt::CLIENT_PROPAGATED;
tpl_params.server_priority = DEFAULT_PRIORITY;
tpl_params.stacksize = 0;
tpl_params.allow_borrowing = 0;
tpl_params.allow_request_buffering = 0;
tpl_params.max_buffered_requests = 0;
tpl_params.max_request_buffer_size = 0;
tpl_params.lanes.length (2);
tpl_params.lanes[0].lane_priority = LOW_PRIORITY;
tpl_params.lanes[0].static_threads = 2;
tpl_params.lanes[0].dynamic_threads = 0;
tpl_params.lanes[1].lane_priority = HIGH_PRIORITY;
tpl_params.lanes[1].static_threads = 2;
tpl_params.lanes[1].dynamic_threads = 0;
CosNotification::QoSProperties qos;
qos.length(1);
qos[0].name = CORBA::string_dup (NotifyExt::ThreadPoolLanes);
qos[0].value <<= tpl_params;
consumer_admin->set_qos(qos);
CORBA::Object_var current_obj =
orb->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (current_obj.in ());
current->the_priority(HIGH_PRIORITY);
CosNotifyChannelAdmin::ProxyID consumeradmin_proxy_id;
CosNotifyChannelAdmin::ProxySupplier_var proxy_supplier =
consumer_admin->obtain_notification_push_supplier(
CosNotifyChannelAdmin::STRUCTURED_EVENT,
consumeradmin_proxy_id);
CosNotifyChannelAdmin::StructuredProxyPushSupplier_var supplier_proxy;
supplier_proxy = CosNotifyChannelAdmin::StructuredProxyPushSupplier::
_narrow(proxy_supplier.in());
supplier_proxy->connect_structured_push_consumer(consumer.in());
CosNotification::EventTypeSeq added (1);
CosNotification::EventTypeSeq removed (1);
added.length (1);
removed.length (1);
added[0].domain_name = CORBA::string_dup ("OCI_TAO");
added[0].type_name = CORBA::string_dup ("examples");
removed[0].domain_name = CORBA::string_dup ("*");
removed[0].type_name = CORBA::string_dup ("*");
supplier_proxy->subscription_change(added, removed);
poa_manager->activate();
// Write a file to let the run_test.pl script know we are ready.
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(output_file) );
iorFile << "Ready" << std::endl;
iorFile.close();
orb->run();
}
catch(const CORBA::Exception& ex)
{
std::cerr << "Caught exception: " << ex << std::endl;
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 ());
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 ());
default_thread_priority =
current->the_priority ();
int result = 0;
CORBA::ULong stacksize = 0;
CORBA::Boolean allow_request_buffering = 0;
CORBA::ULong max_buffered_requests = 0;
CORBA::ULong max_request_buffer_size = 0;
CORBA::PolicyList policies;
CORBA::Boolean allow_borrowing = 0;
if (number_of_lanes != 0)
{
get_auto_priority_lanes_and_bands (number_of_lanes,
rt_orb.in (),
stacksize,
static_threads,
dynamic_threads,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size,
allow_borrowing,
policies,
1);
}
else if (ACE_OS::strcmp (lanes_file, ACE_TEXT("empty-file")) != 0)
{
result =
get_priority_lanes ("server",
lanes_file,
rt_orb.in (),
stacksize,
static_threads,
dynamic_threads,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size,
allow_borrowing,
policies,
1);
if (result != 0)
return result;
result =
get_priority_bands ("server",
bands_file,
rt_orb.in (),
policies,
1);
if (result != 0)
return result;
}
else
{
if (pool_priority == ACE_INT16_MIN)
pool_priority =
default_thread_priority;
RTCORBA::ThreadpoolId threadpool_id =
rt_orb->create_threadpool (stacksize,
static_threads,
dynamic_threads,
pool_priority,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size);
policies.length (policies.length () + 1);
policies[policies.length () - 1] =
rt_orb->create_threadpool_policy (threadpool_id);
if (ACE_OS::strcmp (bands_file, ACE_TEXT("empty-file")) != 0)
{
result =
get_priority_bands ("server",
bands_file,
rt_orb.in (),
policies,
1);
if (result != 0)
return result;
}
}
policies.length (policies.length () + 1);
policies[policies.length () - 1] =
root_poa->create_implicit_activation_policy
(PortableServer::IMPLICIT_ACTIVATION);
policies.length (policies.length () + 1);
policies[policies.length () - 1] =
rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
default_thread_priority);
PortableServer::POA_var poa =
root_poa->create_POA ("RT POA",
poa_manager.in (),
policies);
test_i *servant =
new test_i (this->orb_.in (),
poa.in ());
PortableServer::ServantBase_var safe_servant (servant);
ACE_UNUSED_ARG (safe_servant);
test_var test =
servant->_this ();
result =
write_ior_to_file (ior_output_file,
this->orb_.in (),
test.in ());
if (result != 0)
return result;
poa_manager->activate ();
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_->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb =
RTCORBA::RTORB::_narrow (object.in ());
object =
this->orb_->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (object.in ());
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
current->the_priority (0);
object =
this->orb_->string_to_object (ior);
test_var test =
test::_narrow (object.in ());
Client client (test.in (),
this->orb_.in (),
current.in (),
rt_orb.in (),
policy_manager.in ());
client.vanilla_invocations ();
client.set_private_connection_policies ();
client.vanilla_invocations ();
client.reset_policies ();
client.set_client_protocols_policies (debug);
client.vanilla_invocations ();
client.set_private_connection_policies ();
client.vanilla_invocations ();
client.reset_policies ();
client.set_priority_bands (debug);
client.priority_invocations (debug);
client.set_private_connection_policies ();
client.priority_invocations (debug);
client.reset_policies ();
client.set_priority_bands (debug);
client.set_client_protocols_policies (0);
client.priority_invocations (0);
client.set_private_connection_policies ();
client.priority_invocations (debug);
client.reset_policies ();
if (shutdown_server)
{
test->shutdown ();
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Error!");
return -1;
}
return 0;
}
