/**
* wait until the next period.
*/
static void edf_wait_period(resch_task_t *rt)
{
if (rt->release_time > jiffies) {
rt->task->state = TASK_UNINTERRUPTIBLE;
sleep_interval(rt, rt->release_time - jiffies);
}
else {
schedule();
}
}
// service method
int
net_ace::
svc (void)
{
// NEW_THREAD net_ace runs as ACE_TASK
_reactor = new ACE_Reactor;
_acceptor = new net_ace_acceptor (this);
ACE_INET_Addr addr (_port_self, getIPFromHost ());
printf ("net_ace::svc () default port: %d\n", _port_self);
// obtain a valid server TCP listen port
while (true)
{
// NEW_THREAD (ACE_DEBUG called for 1st time?)
ACE_DEBUG ((LM_DEBUG, "(%5t) attempting to start server at %s:%d\n", addr.get_host_addr (), addr.get_port_number ()));
if (_acceptor->open (addr, _reactor) == 0)
break;
_port_self++;
addr.set_port_number (_port_self);
}
ACE_DEBUG ((LM_DEBUG, "net_ace::svc () called. actual port binded: %d\n", _port_self));
// create new handler for listening to UDP packets
// NEW_THREAD will be created (new handler that will listen to port?)
ACE_NEW_RETURN (_udphandler, net_ace_handler, -1);
_udp = _udphandler->openUDP (addr);
_udphandler->open (_reactor, this);
// NOTE: this is a private IP, publicIP is obtained from server
// register my own address
_self_addr.setPublic ((uint32_t)addr.get_ip_address (),
(uint16_t)addr.get_port_number ());
// self-determine preliminary hostID first
_self_addr.host_id = this->resolveHostID (&_self_addr.publicIP);
// wait a bit to avoid signalling before the main thread tries to wait
ACE_Time_Value sleep_interval (0, 200000);
ACE_OS::sleep (sleep_interval);
// continue execution of original thread in open()
_up_cond->signal ();
// enter into event handling state
while (_active)
{
_reactor->handle_events();
}
ACE_DEBUG ((LM_DEBUG, "(%5t) net_ace::svc () leaving event handling loop\n"));
_reactor->remove_handler (_acceptor, ACE_Event_Handler::DONT_CALL);
// NOTE: _acceptor will be deleted when reactor is deleted as one of its
// event handlers
if (_reactor != NULL)
{
_reactor->close ();
delete _reactor;
_reactor = NULL;
// NOTE: acceptor is self deleted when its handle_close () is called by reactor,
// so no need to delete again here
_acceptor = NULL;
}
// wait a bit to avoid signalling before the main thread tries to wait
ACE_OS::sleep (sleep_interval);
// continue execution of original thread in close()
// to ensure that svc () will exit
if (_down_cond != NULL)
_down_cond->signal ();
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the ORB.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Initialize options based on command-line arguments.
int parse_args_result = parse_args (argc, argv);
if (parse_args_result != 0)
return parse_args_result;
CORBA::Object_var base =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (base.in ());
// Get an object reference from the argument string.
base = orb->string_to_object (IOR);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// Try to narrow the object reference to a <test> reference.
test_var test_object = test::_narrow (base.in ());
Reply_Handler reply_handler_servant;
AMI_testHandler_var reply_handler_object = reply_handler_servant._this ();
if (setup_buffering)
{
setup_buffering_constraints (orb.in ());
}
for (CORBA::ULong i = 1; i <= iterations; ++i)
{
ACE_DEBUG ((LM_DEBUG,
"client: Iteration %d @ %T\n",
i));
if (invoke_ami_style)
{
// Invoke the AMI method.
test_object->sendc_method (reply_handler_object.in (),
i);
}
else
{
CORBA::ULong reply_number = 0;
// Invoke the regular method.
test_object->method (i,
reply_number);
ACE_DEBUG ((LM_DEBUG,
"client: Regular Reply %d @ %T\n",
reply_number));
}
// Interval between successive calls.
ACE_Time_Value sleep_interval (0,
interval * 1000);
orb->run (sleep_interval);
}
// Loop until all replies have been received.
while (!received_all_replies)
{
orb->perform_work ();
}
// Shutdown server.
if (shutdown_server)
{
test_object->shutdown ();
}
root_poa->destroy (1,
1);
// Destroy the ORB. On some platforms, e.g., Win32, the socket
// library is closed at the end of main(). This means that any
// socket calls made after main() fail. Hence if we wait for
// static destructors to flush the queues, it will be too late.
// Therefore, we use explicit destruction here and flush the
// queues before main() ends.
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[])
{
try
{
// Initialize the ORB.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Initialize options based on command-line arguments.
int parse_args_result = parse_args (argc, argv);
if (parse_args_result != 0)
return parse_args_result;
// Get an object reference from the argument string.
CORBA::Object_var base =
orb->string_to_object (IOR);
// Try to narrow the object reference to a <test> reference.
test_var test_object = test::_narrow (base.in ());
// Obtain PolicyCurrent.
base = orb->resolve_initial_references ("PolicyCurrent");
// Narrow down to correct type.
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (base.in ());
// Setup the none sync scope policy, i.e., the ORB will buffer
// oneways.
Messaging::SyncScope sync_none = Messaging::SYNC_NONE;
// Setup the none sync scope any.
CORBA::Any sync_none_any;
sync_none_any <<= sync_none;
// Setup the none sync scope policy list.
CORBA::PolicyList sync_none_policy_list (1);
sync_none_policy_list.length (1);
// Setup the none sync scope policy.
sync_none_policy_list[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
sync_none_any);
// Setup the none sync scope.
policy_current->set_policy_overrides (sync_none_policy_list,
CORBA::ADD_OVERRIDE);
// We are now done with this policy.
sync_none_policy_list[0]->destroy ();
// Start off with no constraints.
TAO::BufferingConstraint buffering_constraint;
buffering_constraint.mode = TAO::BUFFER_FLUSH;
buffering_constraint.message_count = 0;
buffering_constraint.message_bytes = 0;
buffering_constraint.timeout = 0;
// If valid <message_count>, set the implicit flushing to
// account for queued messages.
if (message_count != -1)
{
buffering_constraint.mode |= TAO::BUFFER_MESSAGE_COUNT;
buffering_constraint.message_count = message_count;
}
// If valid <message_bytes>, set the implicit flushing to
// account for queued bytes.
if (message_bytes != -1)
{
buffering_constraint.mode |= TAO::BUFFER_MESSAGE_BYTES;
buffering_constraint.message_bytes = message_bytes;
}
// If valid <timeout>, set the implicit flushing to account for
// timeouts.
if (timeout != -1)
{
buffering_constraint.mode |= TAO::BUFFER_TIMEOUT;
buffering_constraint.timeout = timeout * 10000;
}
// Setup the buffering constraint any.
CORBA::Any buffering_constraint_any;
buffering_constraint_any <<= buffering_constraint;
// Setup the buffering constraint policy list.
CORBA::PolicyList buffering_constraint_policy_list (1);
buffering_constraint_policy_list.length (1);
// Setup the buffering constraint policy.
buffering_constraint_policy_list[0] =
orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE,
buffering_constraint_any);
if (buffering_constraint.mode == TAO::BUFFER_FLUSH)
{
ACE_ERROR((LM_ERROR, "Error : Must specify a timeout, message"
" count, or message bytes constraint.\n"));
return 1;
}
// Setup the constraints.
policy_current->set_policy_overrides (buffering_constraint_policy_list,
CORBA::ADD_OVERRIDE);
//
// We use this policy again later. Therefore, we don't destroy
// it right away.
//
// Setup the explicit flushing policy.
TAO::BufferingConstraint buffering_flush;
buffering_flush.mode = TAO::BUFFER_FLUSH;
buffering_flush.message_count = 0;
buffering_flush.message_bytes = 0;
buffering_flush.timeout = 0;
// Setup the buffering flush any.
CORBA::Any buffering_flush_any;
buffering_flush_any <<= buffering_flush;
// Setup the buffering flush policy list.
CORBA::PolicyList buffering_flush_policy_list (1);
buffering_flush_policy_list.length (1);
// Setup the buffering flush policy.
buffering_flush_policy_list[0] =
orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE,
buffering_flush_any);
//
// Explicit flushing policy will be used later.
//
for (CORBA::ULong i = 1; i <= iterations; ++i)
{
// Explicit flushing (is specified).
if (flush_count != -1 &&
i % flush_count == 0)
{
// Setup explicit flushing.
policy_current->set_policy_overrides (buffering_flush_policy_list,
CORBA::ADD_OVERRIDE);
ACE_DEBUG ((LM_DEBUG,
"client: Iteration %d @ %T\n",
i));
// Invoke the oneway method.
test_object->method (i);
// Reset buffering policy.
policy_current->set_policy_overrides (buffering_constraint_policy_list,
CORBA::ADD_OVERRIDE);
}
else
{
ACE_DEBUG ((LM_DEBUG,
"client: Iteration %d @ %T\n",
i));
// Invoke the oneway method.
test_object->method (i);
}
// Interval between successive calls.
ACE_Time_Value sleep_interval (0,
interval * 1000);
orb->run (sleep_interval);
}
// Shutdown server.
if (shutdown_server)
{
test_object->shutdown ();
}
// We are done with the policy.
buffering_constraint_policy_list[0]->destroy ();
// We are done with the policy.
buffering_flush_policy_list[0]->destroy ();
// Destroy the ORB. On some platforms, e.g., Win32, the socket
// library is closed at the end of main(). This means that any
// socket calls made after main() fail. Hence if we wait for
// static destructors to flush the queues, it will be too late.
// Therefore, we use explicit destruction here and flush the
// queues before main() ends.
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
