int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc,
argv);
CORBA::Object_var manager_obj = orb->resolve_initial_references ("RTSchedulerManager");
TAO_RTScheduler_Manager_var manager = TAO_RTScheduler_Manager::_narrow (manager_obj.in ());
TAO_Scheduler scheduler (orb.in ());
manager->rtscheduler (&scheduler);
Thread_Task task (orb.in ());
task.activate_task (4);
orb->run ();
// Wait until all threads are ready.
ACE_Thread_Manager::instance ()->wait ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
Fixed_Priority_Scheduler* scheduler=0;
RTScheduling::Current_var current;
int prio;
int max_prio;
ACE_Sched_Params::Policy sched_policy = ACE_SCHED_RR;
int sched_scope = ACE_SCOPE_THREAD;
long flags;
if (sched_policy == ACE_SCHED_RR)
flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_RR;
else
flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_FIFO;
ACE_hthread_t main_thr_handle;
ACE_Thread::self (main_thr_handle);
max_prio = ACE_Sched_Params::priority_max (sched_policy,
sched_scope);
//FUZZ: disable check_for_lack_ACE_OS
ACE_Sched_Params sched_params (sched_policy, max_prio);
//FUZZ: enable check_for_lack_ACE_OS
ACE_OS::sched_params (sched_params);
if (ACE_Thread::getprio (main_thr_handle, prio) == -1)
{
if (errno == ENOTSUP)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT ("getprio not supported\n")
));
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n")
ACE_TEXT ("thr_getprio failed")));
}
}
ACE_DEBUG ((LM_DEBUG, "(%t): main thread prio is %d\n", prio));
try
{
RTScheduling::Scheduler_var sched_owner;
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
if (enable_dynamic_scheduling)
{
ACE_DEBUG ((LM_DEBUG, "Dyn Sched enabled\n"));
CORBA::Object_var manager_obj =
orb->resolve_initial_references ("RTSchedulerManager");
TAO_RTScheduler_Manager_var manager =
TAO_RTScheduler_Manager::_narrow (manager_obj.in ());
Kokyu::DSRT_Dispatcher_Impl_t disp_impl_type;
if (enable_yield)
{
disp_impl_type = Kokyu::DSRT_CV_BASED;
}
else
{
disp_impl_type = Kokyu::DSRT_OS_BASED;
}
ACE_NEW_RETURN (scheduler,
Fixed_Priority_Scheduler (orb.in (),
disp_impl_type,
sched_policy,
sched_scope), -1);
sched_owner = scheduler;
manager->rtscheduler (scheduler);
CORBA::Object_var object =
orb->resolve_initial_references ("RTScheduler_Current");
current =
RTScheduling::Current::_narrow (object.in ());
}
Worker worker1 (orb.in (),
server.in (),
current.in (),
scheduler, 10, 15);
if (worker1.activate (flags, 1, 0, max_prio) != 0)
{
ACE_ERROR ((LM_ERROR,
"(%t|%T) cannot activate worker thread.\n"));
}
ACE_OS::sleep(2);
Worker worker2 (orb.in (),
server.in (),
current.in (),
scheduler, 12, 5);
if (worker2.activate (flags, 1, 0, max_prio) != 0)
{
ACE_ERROR ((LM_ERROR,
"(%t|%T) cannot activate scheduler thread in RT mode.\n"));
}
worker1.wait ();
worker2.wait ();
ACE_DEBUG ((LM_DEBUG,
"(%t): wait for worker threads done in main thread\n"));
if (do_shutdown)
{
if (enable_dynamic_scheduling)
{
FP_Scheduling::SegmentSchedulingParameter sched_param;
sched_param.base_priority = 0;
CORBA::Policy_var sched_param_policy
= scheduler->create_segment_scheduling_parameter (sched_param);
CORBA::Policy_ptr implicit_sched_param = 0;
current->begin_scheduling_segment (0,
sched_param_policy.in (),
implicit_sched_param);
}
ACE_DEBUG ((LM_DEBUG, "(%t): about to call server shutdown\n"));
server->shutdown ();
ACE_DEBUG ((LM_DEBUG, "after shutdown call in main thread\n"));
if (enable_dynamic_scheduling)
{
current->end_scheduling_segment (0);
}
}
scheduler->shutdown ();
ACE_DEBUG ((LM_DEBUG, "scheduler shutdown done\n"));
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
Fixed_Priority_Scheduler* scheduler=0;
RTScheduling::Current_var current;
long flags;
int sched_policy = ACE_SCHED_RR;
int sched_scope = ACE_SCOPE_THREAD;
if (sched_policy == ACE_SCHED_RR)
flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_RR;
else
flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_FIFO;
task_stats.init (100000);
try
{
RTScheduling::Scheduler_var sched_owner;
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
if (enable_dynamic_scheduling)
{
CORBA::Object_var manager_obj =
orb->resolve_initial_references ("RTSchedulerManager");
TAO_RTScheduler_Manager_var manager =
TAO_RTScheduler_Manager::_narrow (manager_obj.in ());
Kokyu::DSRT_Dispatcher_Impl_t disp_impl_type;
if (enable_yield)
{
disp_impl_type = Kokyu::DSRT_CV_BASED;
}
else
{
disp_impl_type = Kokyu::DSRT_OS_BASED;
}
ACE_NEW_RETURN (scheduler,
Fixed_Priority_Scheduler (orb.in (),
disp_impl_type,
sched_policy,
sched_scope), -1);
sched_owner = scheduler;
manager->rtscheduler (scheduler);
CORBA::Object_var object =
orb->resolve_initial_references ("RTScheduler_Current");
current =
RTScheduling::Current::_narrow (object.in ());
}
Simple_Server_i server_impl (orb.in (),
current.in (),
task_stats,
enable_yield);
Simple_Server_var server =
server_impl._this ();
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
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);
}
poa_manager->activate ();
Worker worker (orb.in ());
if (worker.activate (flags,
nthreads,
0,
ACE_Sched_Params::priority_max(sched_policy,
sched_scope)) != 0)
{
ACE_ERROR ((LM_ERROR,
"Cannot activate threads in RT class.",
"Trying to activate in non-RT class\n"));
flags = THR_NEW_LWP | THR_JOINABLE | THR_BOUND;
if (worker.activate (flags, nthreads) != 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate server threads\n"),
1);
}
}
worker.wait ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
ACE_DEBUG ((LM_DEBUG, "shutting down scheduler\n"));
scheduler->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
ACE_DEBUG ((LM_DEBUG, "Exiting main...\n"));
task_stats.dump_samples (ACE_TEXT("timeline.txt"),
ACE_TEXT("Time\t\tGUID"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
CORBA::ORB_var orb;
test_var server;
RTScheduling::Scheduler_var safe_scheduler;
try
{
try
{
orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) == -1)
return (-1);
CORBA::Object_var manager_obj = orb->resolve_initial_references ("RTSchedulerManager");
TAO_RTScheduler_Manager_var manager = TAO_RTScheduler_Manager::_narrow (manager_obj.in ());
TAO_Scheduler* scheduler = 0;
ACE_NEW_RETURN (scheduler,
TAO_Scheduler (orb.in ()),
-1);
safe_scheduler = scheduler;
manager->rtscheduler (scheduler);
CORBA::Object_var object =
orb->string_to_object (ior.c_str ());
server = test::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR: Object reference <%s> is nil\n",
ior.c_str ()),
1);
}
CORBA::Object_var current_obj = orb->resolve_initial_references ("RTScheduler_Current");
RTScheduling::Current_var current = RTScheduling::Current::_narrow (current_obj.in ());
const char * name = 0;
CORBA::Policy_ptr sched_param = 0;
CORBA::Policy_ptr implicit_sched_param = 0;
current->begin_scheduling_segment (name,
sched_param,
implicit_sched_param);
ACE_DEBUG ((LM_DEBUG,
"Making a one-way request\n"));
server->one_way (ACE_TEXT_ALWAYS_CHAR(ior.c_str ()));
ACE_DEBUG ((LM_DEBUG,
"Making a two-way request\n"));
server->two_way (ACE_TEXT_ALWAYS_CHAR(ior.c_str ()));
current->end_scheduling_segment (name);
}
catch (const CORBA::THREAD_CANCELLED& )
{
ACE_DEBUG ((LM_DEBUG,
"Distributable Thread Cancelled - Expected Exception\n"));
server->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 0;
}
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught unexpected exception:");
return 1;
}
return 0;
}
