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