/** * 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; }