int ACE_System_Time::get_local_system_time (ACE_Time_Value &time_out) { ACE_TRACE ("ACE_System_Time::get_local_system_time"); time_out.set (ACE_OS::time (0), 0); return 0; }
int main (int argc, char *argv[]) { // First you need a handler for the timeout. My_Handler my_handler; // This is the timeout period in seconds. ACE_Time_Value period (ACE_DEFAULT_TIMEOUT); if (argc > 1) period.set (ACE_OS::atoi (argv[1])); // Set up the periodic interval timer. if (ACE_Reactor::instance ()->schedule_timer (&my_handler, "hello", period, period) == -1) ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "schedule_timer"), -1); // Set up an ACE signal handler. if (ACE_Reactor::instance ()->register_handler (SIGINT, &my_handler) == -1) ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "register_handler"), -1); // Set up a non-ACE signal handler. When this goes off, the Reactor // should return from its <run_event_loop> method. ACE_Sig_Action sig ((ACE_SignalHandler) my_signal_function, SIGQUIT); ACE_UNUSED_ARG (sig); ACE_DEBUG ((LM_DEBUG, "starting event loop that runs until you've typed ^C a total of 10 times or ^\\ once.\n")); // This call executes the reactor events until we're finished. int result = ACE_Reactor::run_event_loop (); ACE_DEBUG ((LM_DEBUG, "result = %d\n", result)); // Make sure to remove my_handler before exiting main() since // otherwise weird things can happen... if (ACE_Reactor::instance ()->cancel_timer (&my_handler) == -1) ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "cancel_timer"), -1); return 0; }
int parse_args (int argc, ACE_TCHAR *argv[]) { ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:p:ci:s:f:")); int c; while ((c = get_opts ()) != -1) switch (c) { case 'f': filter = get_opts.opt_arg (); break; case 'k': monitor_ior = get_opts.opt_arg (); break; case 'p': { if (monitor_point == 0) { ACE_NEW_THROW_EX (monitor_point, ::Monitor::NameList, CORBA::NO_MEMORY ()); } monitor_point->length (monitor_point->length () + 1); (*monitor_point)[monitor_point->length () - 1] = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(get_opts.opt_arg ())); break; } case 'c': mp_clear = true; break; case 'i': n_iterations = ACE_OS::atoi (get_opts.opt_arg ()); break; case 's': sleep_time.set(ACE_OS::atoi (get_opts.opt_arg ()), 0); break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " "-k <ior> " "-p <point> " "-i <iterations> " "-c clear " "-s <sleeptime> " "-f <filter> " "\n", argv [0]), -1); } // Indicates successful parsing of the command line return 0; }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Reactor_Notify_Test")); int test_result = 0; // Innocent until proven guilty if (0 == run_notify_purge_test ()) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("purge_pending_notifications test OK\n"))); } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("purge_pending_notifications test FAIL\n"))); test_result = 1; } #if defined (ACE_HAS_THREADS) if (0 != run_quiet_notify_test ()) test_result = 1; ACE_Time_Value timeout (SHORT_TIMEOUT); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) running tests with notify pipe enabled") ACE_TEXT (" and time-out = %d seconds\n"), timeout.sec ())); run_test (0, timeout); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) running tests with notify pipe disabled") ACE_TEXT (" and time-out = %d seconds\n"), timeout.sec ())); run_test (1, timeout); timeout.set (LONG_TIMEOUT, 0); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) running tests with reactor notification ") ACE_TEXT ("pipe enabled\n") ACE_TEXT (" and time-out = %d seconds\n"), timeout.sec ())); run_test (0, timeout); #else ACE_ERROR ((LM_INFO, ACE_TEXT ("threads not supported on this platform\n"))); #endif /* ACE_HAS_THREADS */ ACE_END_TEST; return test_result; }
void yarp::os::impl::sleepThread(ACE_Time_Value& sleep_period) { #ifdef YARP_HAS_ACE if (sleep_period.usec() < 0 || sleep_period.sec() < 0) sleep_period.set(0,0); ACE_OS::sleep(sleep_period); #else if (sleep_period.tv_usec < 0 || sleep_period.tv_sec < 0) { sleep_period.tv_usec = 0; sleep_period.tv_sec = 0; } usleep(sleep_period.tv_sec * 1000000 + sleep_period.tv_usec ); #endif }
void EC_Schedule::build_supplier_qos ( int i, RtecEventChannelAdmin::SupplierQOS& qos, int& shutdown_event_type) { char name[128]; ACE_OS::sprintf (name, "EC_Schedule::Supplier::%04x", i); RtecScheduler::handle_t rt_info = this->scheduler_->create (name); ACE_Time_Value tv (0, this->burst_pause_); RtecScheduler::Period_t rate = tv.usec () * 10; // The execution times are set to reasonable values, but // actually they are changed on the real execution, i.e. we // lie to the scheduler to obtain right priorities; but we // don't care if the set is schedulable. tv.set (0, 2000); TimeBase::TimeT time; ORBSVCS_Time::Time_Value_to_TimeT (time, tv); this->scheduler_->set (rt_info, RtecScheduler::VERY_HIGH_CRITICALITY, time, time, time, rate, RtecScheduler::VERY_LOW_IMPORTANCE, time, 1, RtecScheduler::OPERATION); int type_start = this->supplier_type_start_ + i*this->supplier_type_shift_; int supplier_id = i + 1; shutdown_event_type = type_start + this->supplier_type_count_; ACE_SupplierQOS_Factory qos_factory; for (int j = 0; j != this->supplier_type_count_; ++j) qos_factory.insert (supplier_id, type_start + j, rt_info, 1); qos_factory.insert (supplier_id, shutdown_event_type, rt_info, 1); qos = qos_factory.get_SupplierQOS (); }
virtual void push_structured_event(CosNotification::StructuredEvent const& event) throw(CosEventComm::Disconnected) { cout << "domain_name: " << event.header.fixed_header.event_type.domain_name << " type_name: " << event.header.fixed_header.event_type.type_name << " " << flush; if (false) { Miro::Client client; DynamicAny::DynAnyFactory_var daf = client.resolveInit<DynamicAny::DynAnyFactory>("DynAnyFactory"); DynamicAny::DynAny_var da = daf->create_dyn_any(event.remainder_of_body); CORBA::TypeCode_var tc = da->type(); if (tc->kind() == CORBA::tk_struct) { CORBA::String_var name = tc->name(); CORBA::String_var id = tc->id(); DynamicAny::DynStruct_var ds = DynamicAny::DynStruct::_narrow(da); for (CORBA::ULong i = 0; i < ds->component_count(); ++i) { DynamicAny::DynAny_var member = ds->current_component(); CORBA::String_var name = ds->current_member_name(); if (std::string("timestamp") == name.in()) { long long int i = member->get_ulonglong(); ACE_Time_Value t; ORBSVCS_Time::Absolute_TimeT_to_Time_Value(t, i); cout << "latency: " << ACE_OS::gettimeofday() - t << endl; break; } ds->next(); } } else { cerr << "unknown event layout" << endl; } } ACE_Time_Value t; t.set(time_out); ACE_OS::sleep(t); cout << "waking up after sleep" << endl; }
int parseArgs(int& argc, char* argv[]) { int rc = 0; int c; ACE_Get_Opt get_opts (argc, argv, "c:t:?"); while ((c = get_opts()) != -1) { switch (c) { break; case 'c': channelName = get_opts.optarg; break; case 'v': verbose = true; break; case 't': timeout.set(atof(get_opts.optarg)); case '?': default: rc = 1; } } if (rc) { cerr << "usage: " << argv[0] << "[-t timeout [-c channel_name] [-v?]" << endl << " -c <channel name> name of the event channel (default: NotifyEventChannel)" << endl << " -t <sec> timeout (default: 5s)" << endl << " -v verbose mode" << endl << " -? help: emit this text and stop" << endl; } if (verbose) { cerr << "timeout: " << timeout << endl << "channel name: " << channelName << endl; } return rc; }
int CoAPWrapper::time_out(ACE_Time_Value& tm) { struct timeval tv, *timeout; int result; coap_tick_t now; coap_queue_t *nextpdu; coap_context_t *ctx; if (coap_ctx_ == 0 ) return 0; ctx = coap_ctx_; nextpdu = coap_peek_next( ctx ); coap_ticks(&now); while ( nextpdu && nextpdu->t <= now ) { coap_retransmit( ctx, coap_pop_next( ctx ) ); nextpdu = coap_peek_next( ctx ); } if ( nextpdu && nextpdu->t <= now + COAP_RESOURCE_CHECK_TIME ) { /* set timeout if there is a pdu to send before our automatic timeout occurs */ tv.tv_usec = ((nextpdu->t - now) % COAP_TICKS_PER_SECOND) * 1000000 / COAP_TICKS_PER_SECOND; tv.tv_sec = (nextpdu->t - now) / COAP_TICKS_PER_SECOND; timeout = &tv; } else { tv.tv_usec = 0; tv.tv_sec = COAP_RESOURCE_CHECK_TIME; timeout = &tv; } tm.set(*timeout); return 0; }
int SocketTwoWayStream::open(const Contact& address) { if (address.getPort()==-1) { return -1; } String host = address.getHost(); #ifdef YARP_HAS_ACE ACE_SOCK_Connector connector; if (address.getHost() == "localhost") { // ACE does not like localhost. At all. NameConfig config; host = config.getHostName(true); } ACE_INET_Addr addr(address.getPort(),host.c_str()); ACE_Time_Value openTimeout; ACE_Time_Value *timeout = NULL; if (address.hasTimeout()) { openTimeout.set(address.getTimeout()); timeout = &openTimeout; } int result = connector.connect(stream,addr,timeout,ACE_Addr::sap_any,1); #else TcpConnector connector; int result = connector.connect(stream, address); #endif if (result>=0) { happy = true; } else { YARP_SPRINTF2(Logger::get(), debug, "TCP connection to tcp://%s:%d failed to open", host.c_str(), address.getPort()); } updateAddresses(); return result; }
int PlatConnMgrEx::send_recv(const void * send_buf, int send_len , void * recv_buf, int recv_len, const unsigned int uin) { int ip_idx = get_ip_idx(uin); int index = get_index(ip_idx, uin); ACE_SOCK_Stream* conn = get_conn(index, ip_idx); if (conn == NULL) { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx get conn failed" ",can't get a useful conn" ",index=%d,ip_idx=%d,uin=%u\n" , index, ip_idx, uin )); return -1; } ACE_Guard<ACE_Thread_Mutex> guard(conn_lock_[ip_idx][index]);// 加锁需要放在获取的后面 if (conn_[ip_idx][index] == NULL) // 加锁后增加一次非法判断 { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx send_recv failed" ",conn is null" ",index=%d,ip_idx=%d,uin=%u\n" , index, ip_idx, uin )); return -1; } conn_use_flag_[ip_idx][index] = 1; //清除原缓冲 add by awayfang 2010-03-02 ACE_Time_Value zero; zero.set(0); int max_recv_len = recv_len; int tmp_ret = conn_[ip_idx][index]->recv(recv_buf, max_recv_len, &zero);//不等待直接返返回 // 检测到连接关闭时, 重建连接 if((tmp_ret < 0 && errno != ETIME) // 连接上无数据的情况,会返回超时,不需重连 || tmp_ret == 0) // 连接已经被对端关闭, 处于close wait状态 { ACE_DEBUG((LM_INFO, "[%D] PlatConnMgrEx send_recv connection close detected," "uin=%u,ip=%s,index=%d\n", uin, ip_[ip_idx], index)); init_conn(index, ip_idx); if(conn_[ip_idx][index] == NULL) { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx send_recv reconnect failed," "index=%d,ip_idx=%d\n", index, ip_idx)); return -1; } } ACE_DEBUG((LM_TRACE, "[%D] PlatConnMgrEx send_recv msg" ",index=%d,ip_idx=%d,uin=%u\n", index, ip_idx, uin)); int ret = conn_[ip_idx][index]->send(send_buf, send_len, &time_out_); if (ret <= 0) //异常或者对端关闭 { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx send_recv send msg failed" ",index=%d,ip_idx=%d,ret=%d,uin=%u,errno=%d\n", index, ip_idx, ret, uin, errno)); //关闭连接 fini(index, ip_idx); Stat::instance()->incre_stat(STAT_CODE_SEND_FAIL); return ret; } // ret = conn_[ip_idx][index]->recv(recv_buf, recv_len, &time_out_); if (ret <= 0) //异常或者对端关闭 { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx send_recv recv msg failed" ",index=%d,ip_idx=%d,ret=%d,uin=%u,errno=%d\n", index, ip_idx, ret, uin, errno)); //关闭连接 fini(index, ip_idx); Stat::instance()->incre_stat(STAT_CODE_RECV_FAIL); return ret; } ACE_DEBUG((LM_TRACE, "[%D] PlatConnMgrEx send_recv msg succ" ",index=%d,ip_idx=%d,ret=%d,uin=%u\n", index, ip_idx, ret, uin)); conn_use_flag_[ip_idx][index] = 0;//退出前清理使用状态 return ret; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { ACE_UNUSED_ARG (config_run); //TAO_EC_Default_Factory::init_svcs (); TAO_EC_Kokyu_Factory::init_svcs (); try { // ORB initialization boiler plate... CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) == -1) { ACE_ERROR ((LM_ERROR, "Usage: Service [-o IOR_file_name]\n")); return 1; } CORBA::Object_var object = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow (object.in ()); PortableServer::POAManager_var poa_manager = poa->the_POAManager (); poa_manager->activate (); // **************************************************************** // Create an scheduling service POA_RtecScheduler::Scheduler* sched_impl = 0; if (ACE_OS::strcasecmp(sched_type.c_str(), "rms") == 0) { ACE_DEBUG ((LM_DEBUG, "Creating RMS scheduler\n")); ACE_NEW_RETURN (sched_impl, RECONFIG_RMS_SCHED_TYPE, 1); } else if (ACE_OS::strcasecmp(sched_type.c_str(), "muf") == 0) { ACE_DEBUG ((LM_DEBUG, "Creating MUF scheduler\n")); ACE_NEW_RETURN (sched_impl, RECONFIG_MUF_SCHED_TYPE, 1); } RtecScheduler::Scheduler_var scheduler = sched_impl->_this (); // **************************************************************** TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ()); attributes.scheduler = scheduler.in (); // no need to dup TAO_EC_Event_Channel ec_impl (attributes); RtecEventChannelAdmin::EventChannel_var event_channel = ec_impl._this (); // **************************************************************** // Create a consumer, intialize its RT_Info structures, and // connnect to the event channel.... Consumer consumer_impl1, consumer_impl2; RtecScheduler::handle_t consumer1_rt_info = scheduler->create ("consumer1"); RtecScheduler::handle_t consumer2_rt_info = scheduler->create ("consumer2"); //consumer's rate will get propagated from the supplier. //so no need to specify a period here. Specifying //criticality is crucial since it propagates from //consumer to supplier. ACE_Time_Value tv (0,0); TimeBase::TimeT tmp; ORBSVCS_Time::Time_Value_to_TimeT (tmp, tv); scheduler->set (consumer1_rt_info, RtecScheduler::VERY_LOW_CRITICALITY, tmp, tmp, tmp, time_val_to_period (tv), RtecScheduler::VERY_LOW_IMPORTANCE, tmp, 0, RtecScheduler::OPERATION); scheduler->set (consumer2_rt_info, RtecScheduler::VERY_HIGH_CRITICALITY, tmp, tmp, tmp, time_val_to_period (tv), RtecScheduler::VERY_HIGH_IMPORTANCE, tmp, 0, RtecScheduler::OPERATION); ACE_ConsumerQOS_Factory consumer_qos1, consumer_qos2; //consumer_qos.start_disjunction_group (); // The types int the range [0,ACE_ES_EVENT_UNDEFINED) are // reserved for the EC... consumer_qos1.insert_type (ACE_ES_EVENT_UNDEFINED, consumer1_rt_info); RtecEventChannelAdmin::ConsumerQOS qos = consumer_qos1.get_ConsumerQOS (); /* for (int i=0;i<qos.dependencies.length (); ++i) { ACE_DEBUG ((LM_DEBUG, "consumer_qos1[%d] event.header.type = %d, " "consumer_qos1[%d] rt_info = %d, " "consumer_qos1[%d] event.header.source = %d\n", i,qos.dependencies[i].event.header.type, i,qos.dependencies[i].rt_info, i,qos.dependencies[i].event.header.source)); } */ consumer_qos2.insert_type (ACE_ES_EVENT_UNDEFINED + 1, consumer2_rt_info); // The canonical protocol to connect to the EC RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin = event_channel->for_consumers (); RtecEventChannelAdmin::ProxyPushSupplier_var supplier_proxy1 = consumer_admin->obtain_push_supplier (); RtecEventChannelAdmin::ProxyPushSupplier_var supplier_proxy2 = consumer_admin->obtain_push_supplier (); RtecEventComm::PushConsumer_var consumer1 = consumer_impl1._this (); RtecEventComm::PushConsumer_var consumer2 = consumer_impl2._this (); ACE_DEBUG ((LM_DEBUG, "connecting consumers\n")); ACE_DEBUG ((LM_DEBUG, "connecting consumer1\n")); supplier_proxy1->connect_push_consumer (consumer1.in (), consumer_qos1.get_ConsumerQOS ()); ACE_DEBUG ((LM_DEBUG, "connecting consumer2\n")); supplier_proxy2->connect_push_consumer (consumer2.in (), consumer_qos2.get_ConsumerQOS ()); ACE_DEBUG ((LM_DEBUG, "consumers connected\n")); // **************************************************************** RtecScheduler::handle_t supplier1_rt_info = scheduler->create ("supplier1"); RtecScheduler::handle_t supplier2_rt_info = scheduler->create ("supplier2"); RtecEventComm::EventSourceID supplier_id1 = 1, supplier_id2 = 2; ACE_SupplierQOS_Factory supplier_qos1, supplier_qos2; supplier_qos1.insert (supplier_id1, ACE_ES_EVENT_UNDEFINED, supplier1_rt_info, 1 /* number of calls, but what does that mean? */); supplier_qos2.insert (supplier_id2, ACE_ES_EVENT_UNDEFINED + 1, supplier2_rt_info, 1 /* number of calls, but what does that mean? */); // The canonical protocol to connect to the EC RtecEventChannelAdmin::SupplierAdmin_var supplier_admin = event_channel->for_suppliers (); RtecEventChannelAdmin::ProxyPushConsumer_var consumer_proxy1 = supplier_admin->obtain_push_consumer (); RtecEventChannelAdmin::ProxyPushConsumer_var consumer_proxy2 = supplier_admin->obtain_push_consumer (); Supplier supplier_impl1(supplier_id1, consumer_proxy1.in ()); Supplier supplier_impl2(supplier_id2, consumer_proxy2.in ()); RtecEventComm::PushSupplier_var supplier1 = supplier_impl1._this (); RtecEventComm::PushSupplier_var supplier2 = supplier_impl2._this (); ACE_DEBUG ((LM_DEBUG, "connecting suppliers\n")); ACE_DEBUG ((LM_DEBUG, "connecting supplier1\n")); consumer_proxy1->connect_push_supplier (supplier1.in (), supplier_qos1.get_SupplierQOS ()); ACE_DEBUG ((LM_DEBUG, "connecting supplier2\n")); consumer_proxy2->connect_push_supplier (supplier2.in (), supplier_qos2.get_SupplierQOS ()); ACE_DEBUG ((LM_DEBUG, "suppliers connected\n")); // **************************************************************** //Timer Registration part //Timeout consumers for the two suppliers. Timeout_Consumer timeout_consumer_impl1(&supplier_impl1); Timeout_Consumer timeout_consumer_impl2(&supplier_impl2); RtecScheduler::handle_t supplier1_timeout_consumer_rt_info = scheduler->create ("supplier1_timeout_consumer"); //Period = 1sec tv.set (1,0); ORBSVCS_Time::Time_Value_to_TimeT (tmp, tv); scheduler->set (supplier1_timeout_consumer_rt_info, RtecScheduler::VERY_LOW_CRITICALITY, tmp, tmp, tmp, time_val_to_period (tv), RtecScheduler::VERY_LOW_IMPORTANCE, tmp, 0, RtecScheduler::OPERATION); RtecScheduler::handle_t supplier2_timeout_consumer_rt_info = scheduler->create ("supplier2_timeout_consumer"); //Period = 3sec tv.set (3, 0); ORBSVCS_Time::Time_Value_to_TimeT (tmp, tv); scheduler->set (supplier2_timeout_consumer_rt_info, RtecScheduler::VERY_HIGH_CRITICALITY, tmp, tmp, tmp, time_val_to_period (tv), RtecScheduler::VERY_HIGH_IMPORTANCE, tmp, 0, RtecScheduler::OPERATION); ACE_ConsumerQOS_Factory timer_qos1, timer_qos2; timer_qos1.insert_time (ACE_ES_EVENT_INTERVAL_TIMEOUT, 10000000, //in 100s of nanosec supplier1_timeout_consumer_rt_info); timer_qos2.insert_time (ACE_ES_EVENT_INTERVAL_TIMEOUT, 30000000, //in 100s of nanosec supplier2_timeout_consumer_rt_info); RtecEventChannelAdmin::ProxyPushSupplier_var timeout_supplier_proxy1 = consumer_admin->obtain_push_supplier (); RtecEventChannelAdmin::ProxyPushSupplier_var timeout_supplier_proxy2 = consumer_admin->obtain_push_supplier (); RtecEventComm::PushConsumer_var safe_timeout_consumer1 = timeout_consumer_impl1._this (); RtecEventComm::PushConsumer_var safe_timeout_consumer2 = timeout_consumer_impl2._this (); ACE_DEBUG ((LM_DEBUG, "connecting timeout consumers\n")); timeout_supplier_proxy1-> connect_push_consumer (safe_timeout_consumer1.in (), timer_qos1.get_ConsumerQOS ()); timeout_supplier_proxy2-> connect_push_consumer (safe_timeout_consumer2.in (), timer_qos2.get_ConsumerQOS ()); ACE_DEBUG ((LM_DEBUG, "timeout consumers connected\n")); // **************************************************************** //Registering dependency between timeout consumers and our suppliers //with the scheduler scheduler->add_dependency (supplier1_timeout_consumer_rt_info, supplier1_rt_info, 1, RtecBase::TWO_WAY_CALL); scheduler->add_dependency (supplier2_timeout_consumer_rt_info, supplier2_rt_info, 1, RtecBase::TWO_WAY_CALL); // **************************************************************** // At this point the consumer and supplier are connected to the // EC, they have provided their QoS info to the Scheduling // Service and the EC has informed the Scheduler about the // dependencies between them. // We can now compute the schedule for this configuration... // The schedule is returned in this variables.... ACE_DEBUG ((LM_DEBUG, "Computing schedule\n")); RtecScheduler::RT_Info_Set_var infos; RtecScheduler::Config_Info_Set_var configs; RtecScheduler::Dependency_Set_var dependencies; RtecScheduler::Scheduling_Anomaly_Set unsafe_anomalies; RtecScheduler::Scheduling_Anomaly_Set_var anomalies; scheduler->get_rt_info_set (infos.out() ); scheduler->get_dependency_set (dependencies.out() ); scheduler->get_config_info_set (configs.out() ); ACE_DEBUG ((LM_DEBUG, "Printing intermediate results\n")); ACE_Scheduler_Factory::dump_schedule (infos.in (), dependencies.in (), configs.in (), unsafe_anomalies, ACE_TEXT("schedule.out")); // Obtain the range of valid priorities in the current // platform, the scheduler hard-code this values in the // generated file, but in the future we may just use the // "logical" priorities and define the mapping to OS // priorities at run-time. int min_os_priority = ACE_Sched_Params::priority_min (ACE_SCHED_FIFO, ACE_SCOPE_THREAD); int max_os_priority = ACE_Sched_Params::priority_max (ACE_SCHED_FIFO, ACE_SCOPE_THREAD); scheduler->compute_scheduling (min_os_priority, max_os_priority, infos.out (), dependencies.out (), configs.out (), anomalies.out ()); // Dump the schedule to a file.. ACE_Scheduler_Factory::dump_schedule (infos.in (), dependencies.in (), configs.in (), anomalies.in (), ACE_TEXT("schedule.out")); // **************************************************************** ACE_DEBUG ((LM_DEBUG, "Pushing events\n")); ACE_hthread_t thr_handle; ACE_Thread::self (thr_handle); int prio = ACE_Sched_Params::priority_max (ACE_SCHED_FIFO); ACE_OS::thr_setprio (thr_handle, prio); // // Generate a few events.... // RtecEventComm::EventSet event1 (1); // event1.length (1); // event1[0].header.type = ACE_ES_EVENT_UNDEFINED; // event1[0].header.source = supplier_id1; // event1[0].header.ttl = 1; // RtecEventComm::EventSet event2 (1); // event2.length (1); // event2[0].header.type = ACE_ES_EVENT_UNDEFINED + 1; // event2[0].header.source = supplier_id2; // event2[0].header.ttl = 1; // for (int i = 0; i != 200; ++i) // { // if (i % 2 == 0) // { // consumer_proxy1->push (event1); // } // else // { // consumer_proxy2->push (event2); // } // ACE_Time_Value rate (0, 10000); // ACE_OS::sleep (rate); // } ACE_DEBUG ((LM_DEBUG, "(%t) activating EC\n")); ec_impl.activate (); ACE_DEBUG ((LM_DEBUG, "EC activated\n")); orb->run (); // **************************************************************** // We should do a lot of cleanup (disconnect from the EC, // deactivate all the objects with the POA, etc.) but this is // just a simple demo so we are going to be lazy. } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Service"); return 1; } return 0; }
int Publisher_impl::Worker::svc (void) { double data = 0.0; bool doShutdown = false; unsigned long iteration = 0; ACE_Time_Value tv; tv.set(0.01); while (!terminated) { data += 0.01; ++iteration; { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex, 0); doShutdown = subscribers.size() > 0; for (vector<_Subscriber>::iterator iter = subscribers.begin(); iter != subscribers.end(); ++iter) { if (!iter->unsubscribed) { doShutdown = false; try { if (!CORBA::is_nil(iter->subscriber.in ())) iter->subscriber->onData(data); else iter->unsubscribed = true; ++iter->count; } catch (...) { iter->unsubscribed = true; } } } } if (iteration % 200 == 0) { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex, 0); for (vector<_Subscriber>::iterator iter = subscribers.begin(); iter != subscribers.end(); ++iter) { if (!iter->unsubscribed) { try { iter->subscriber->isAlive(); } catch (...) { iter->unsubscribed = true; } } } } if (doShutdown) owner->shutdown(); else ACE_OS::sleep(tv); } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { int err = 0; CosNaming::Name the_name (0); CORBA::ORB_var orb; try { // Contact the orb orb = CORBA::ORB_init (argc, argv); // Scan through the command line options bool failed = false, quiet = false, destroy = false; const ACE_TCHAR *const pname = argv[0]; const ACE_TCHAR *nameService = 0; ACE_TCHAR kindsep = ACE_TEXT('.'); ACE_TCHAR ctxsep[] = ACE_TEXT("/"); ACE_TCHAR *name = 0; ACE_Time_Value rtt = ACE_Time_Value::zero; if (0 < argc) { while (0 < --argc) { ++argv; if (0 == ACE_OS::strcmp (*argv, ACE_TEXT ("--ns"))) { if (!--argc) { ACE_DEBUG ((LM_DEBUG, "Error: --ns requires an argument\n")); failed= true; } else { ++argv; if (nameService) { ACE_DEBUG ((LM_DEBUG, "Error: more than one --ns.\n")); failed= true; } else nameService = *argv; } } else if (0 == ACE_OS::strcmp (*argv, ACE_TEXT ("--quiet"))) { quiet = true; } else if (0 == ACE_OS::strcmp (*argv, ACE_TEXT ("--name"))) { if (name) { ACE_DEBUG ((LM_DEBUG, "Error: more than one --name\n")); failed = true; } else if (!--argc) { ACE_DEBUG ((LM_DEBUG, "Error: --name requires an argument\n")); failed = true; } else name = *(++argv); } else if (0 == ACE_OS::strcmp (*argv, ACE_TEXT ("--ctxsep"))) { if (!--argc) { ACE_DEBUG ((LM_DEBUG, "Error: --ctxsep requires a character\n")); failed = true; } else if (1 != ACE_OS::strlen(*(++argv))) { ACE_DEBUG ((LM_DEBUG, "Error: --ctxsep takes a single character (not %s)\n", *argv)); failed = true; } else ctxsep[0] = (*argv)[0]; } else if (0 == ACE_OS::strcmp (*argv, ACE_TEXT ("--kindsep"))) { if (!--argc) { ACE_DEBUG ((LM_DEBUG, "Error: --kindsep requires a character\n")); failed = true; } else if (1 != ACE_OS::strlen(*(++argv))) { ACE_DEBUG ((LM_DEBUG, "Error: --kindsep takes a single character (not %s)\n", *argv)); failed = true; } else kindsep = (*argv)[0]; } else if (0 == ACE_OS::strcmp(*argv, ACE_TEXT ("--rtt"))) { if (rtt != ACE_Time_Value::zero) { ACE_DEBUG ((LM_DEBUG, "Error: --rtt given more than once\n")); failed = true; } else if (!--argc || !ACE_OS::ace_isdigit (ACE_TEXT_ALWAYS_CHAR (*(++argv))[0])) { ACE_DEBUG ((LM_DEBUG, "Error: --rtt requires a number\n")); failed = true; } else rtt.set(ACE_OS::atoi (ACE_TEXT_ALWAYS_CHAR (*argv)), 0); } else if (0 == ACE_OS::strcmp (*argv, ACE_TEXT ("--destroy"))) { destroy = true; } else { ACE_DEBUG ((LM_DEBUG, "Unknown option %s\n", *argv)); failed = true; } } } if (!name || failed) { ACE_DEBUG ((LM_DEBUG, "\nUsage:\n %s --name <name>\n" "optional:\n" " --ns <ior>\n" " --ctxsep <character>\n" " --kindsep <character>\n" " --destroy\n" " --quiet\n" " --rtt <seconds> {Sets the relative round trip timeout policy}\n\n", "where <name> uses the --ctxsep character (defaults to /)\n" "to separate sub-contexts and --kindsep (defaults to .)\n" "to separate ID & Kind. Will destroy a naming context\n" "before unbinding if --destroy is given, otherwise it\n" "will orphan them. Connects to default NameService\n" "unless --ns is given. Displays all ID/Kinds found\n" "on path unless --quiet is given.\n", pname)); orb->destroy (); return 1; } // Contact the name service CORBA::Object_var nc_obj; if (nameService) nc_obj = orb->string_to_object (nameService); else nc_obj = orb->resolve_initial_references ("NameService"); nc_obj = set_rtt(orb.in(), nc_obj.in (), rtt); CosNaming::NamingContext_var root_nc = CosNaming::NamingContext::_narrow (nc_obj.in ()); if (CORBA::is_nil (root_nc.in ())) { ACE_DEBUG ((LM_DEBUG, "Error: nil naming context\n")); orb->destroy (); return 1; } // Assemble the name from the user string given ACE_TCHAR *cp; while (0 != (cp = ACE_OS::strtok (name, ctxsep))) { const int index= the_name.length(); the_name.length (index+1); ACE_TCHAR *kind = const_cast<ACE_TCHAR*> (ACE_OS::strchr (cp, kindsep)); if (kind) { *kind = '\0'; the_name[index].kind= CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(++kind)); } the_name[index].id = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(cp)); name = 0; // way strtok works } // Attempt to locate the object and destroy/unbind it CORBA::Object_var obj = root_nc->resolve (the_name); root_nc->unbind (the_name); if (!quiet) { unsigned int index; for (index= 0u; index < the_name.length()-1u; ++index) { if (the_name[index].kind && the_name[index].kind[0]) ACE_DEBUG ((LM_DEBUG, "Found ID: %C (Kind: %C)\n", the_name[index].id.in(), the_name[index].kind.in())); else ACE_DEBUG ((LM_DEBUG, "Found ID: %C\n", the_name[index].id.in())); } ACE_DEBUG ((LM_DEBUG, "UnBound ID: %C", the_name[index].id.in())); if (the_name[index].kind && the_name[index].kind[0]) ACE_DEBUG ((LM_DEBUG, " (Kind: %C)\n", the_name[index].kind.in())); ACE_DEBUG ((LM_DEBUG, "\n")); } if (!quiet || destroy) { bool failure = false; try { obj = set_rtt(orb.in (), obj.in (), rtt); CosNaming::NamingContext_var this_nc = CosNaming::NamingContext::_narrow (obj.in ()); if (!CORBA::is_nil (this_nc.in ())) { if (destroy) { if (!quiet) ACE_DEBUG ((LM_DEBUG,"Destroying\n")); this_nc->destroy( ); } else if (!quiet) { CORBA::String_var str = orb->object_to_string (obj.in ()); ACE_DEBUG ((LM_DEBUG, "\n*** Possiably Orphaned Naming Context ***\n%C\n\n", str.in())); } } else if (destroy && !quiet) ACE_DEBUG ((LM_DEBUG,"Can't Destroy object, it is not a naming context!\n")); } catch (const CORBA::OBJECT_NOT_EXIST&) { if (!quiet) ACE_DEBUG ((LM_DEBUG, "{Object does not exist!}\n")); failure = true; } catch (const CORBA::TRANSIENT&) { if (!quiet) ACE_DEBUG ((LM_DEBUG, "{Object is transient!}\n")); failure = true; } catch (const CORBA::TIMEOUT&) { if (!quiet) ACE_DEBUG ((LM_DEBUG, "{Operation timed out!}\n")); failure = true; } if (failure && !quiet) { if (destroy) { ACE_DEBUG ((LM_DEBUG, "Failed to destroy context.\n")); } else { ACE_DEBUG ((LM_DEBUG, "Failed to check for orphaned naming context.\n")); } } } } catch (const CosNaming::NamingContext::NotFound& nf) { unsigned int index; const unsigned int limit= the_name.length()-nf.rest_of_name.length(); ACE_DEBUG ((LM_DEBUG, "\nError:\n")); for (index= 0u; index < limit; ++index) { if (the_name[index].kind && the_name[index].kind[0]) ACE_DEBUG ((LM_DEBUG, "ID: %C (Kind: %C)\n", the_name[index].id.in(), the_name[index].kind.in())); else ACE_DEBUG ((LM_DEBUG, "ID: %C\n", the_name[index].id.in())); } const char *why= "Unknown reason"; switch (nf.why) { case CosNaming::NamingContext::missing_node: why= "\nThe following node is missing"; break; case CosNaming::NamingContext::not_context: why= "\nThe following is a final object binding, not a naming context"; break; case CosNaming::NamingContext::not_object: why= "\nThe following is a naming context, not a final object binding"; break; } nf._tao_print_exception (why); for (index= 0u; index < nf.rest_of_name.length(); ++index) { if (nf.rest_of_name[index].kind && nf.rest_of_name[index].kind[0]) ACE_DEBUG ((LM_DEBUG, "ID: %C (Kind: %C)\n", nf.rest_of_name[index].id.in(), nf.rest_of_name[index].kind.in())); else ACE_DEBUG ((LM_DEBUG, "ID: %C\n", nf.rest_of_name[index].id.in())); } ++err; } catch (const CORBA::Exception& ex) { ACE_DEBUG ((LM_DEBUG, "\nError:\n")); ex._tao_print_exception ("Exception in nsdel"); ++err; } try { orb->destroy (); } catch (const CORBA::Exception& ex) { ACE_DEBUG ((LM_DEBUG, "\nError:\n")); ex._tao_print_exception ("Exception in while shutting down"); ++err; } return err; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { TAO_EC_Default_Factory::init_svcs (); try { // ORB initialization boiler plate... CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) == -1) { ACE_ERROR ((LM_ERROR, "Usage: Service [-o IOR_file_name]\n")); return 1; } CORBA::Object_var object = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow (object.in ()); PortableServer::POAManager_var poa_manager = poa->the_POAManager (); poa_manager->activate (); // **************************************************************** #if 0 // Obtain a reference to the naming service... CORBA::Object_var naming_obj = orb->resolve_initial_references ("NameService"); CosNaming::NamingContext_var naming_context = CosNaming::NamingContext::_narrow (naming_obj.in ()); #endif /* 0 */ // **************************************************************** // Create an scheduling service POA_RtecScheduler::Scheduler* sched_impl = 0; if (config_run) { ACE_NEW_RETURN (sched_impl, RECONFIG_SCHED_TYPE, 1); } else { ACE_NEW_RETURN (sched_impl, RECONFIG_SCHED_TYPE (configs_size, configs, infos_size, infos, 0, 0, 0), 1); } RtecScheduler::Scheduler_var scheduler = sched_impl->_this (); #if 0 // Bind the scheduler with the naming service so clients // (consumers and suppliers) can resolve it, some (old) // implementations of the EC will try to do the same thing // (yikes!) CosNaming::Name schedule_name (1); schedule_name.length (1); schedule_name[0].id = CORBA::string_dup ("ScheduleService"); // Register the servant with the Naming Context.... naming_context->rebind (schedule_name, scheduler.in ()); #endif /* 0 */ // **************************************************************** TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ()); attributes.scheduler = scheduler.in (); // no need to dup TAO_EC_Event_Channel ec_impl (attributes); ACE_DEBUG ((LM_DEBUG, "activating EC\n")); ec_impl.activate (); ACE_DEBUG ((LM_DEBUG, "EC activated\n")); RtecEventChannelAdmin::EventChannel_var event_channel = ec_impl._this (); // **************************************************************** // Create a consumer, intialize its RT_Info structures, and // connnect to the event channel.... Consumer consumer_impl; RtecScheduler::handle_t consumer_rt_info1 = scheduler->create ("consumer_event_1"); // Let's say that the execution time for event 1 is 2 // milliseconds... ACE_Time_Value tv (0, 2000); TimeBase::TimeT time; ORBSVCS_Time::Time_Value_to_TimeT (time, tv); scheduler->set (consumer_rt_info1, RtecScheduler::VERY_HIGH_CRITICALITY, time, time, time, 0, RtecScheduler::VERY_LOW_IMPORTANCE, time, 0, RtecScheduler::OPERATION); RtecScheduler::handle_t consumer_rt_info2 = scheduler->create ("consumer_event_2"); // Let's say that the execution time for event 2 is 1 // milliseconds... tv.set (0, 1000); ORBSVCS_Time::Time_Value_to_TimeT (time, tv); scheduler->set (consumer_rt_info2, RtecScheduler::VERY_LOW_CRITICALITY, time, time, time, 0, RtecScheduler::VERY_LOW_IMPORTANCE, time, 0, RtecScheduler::OPERATION); ACE_ConsumerQOS_Factory consumer_qos; consumer_qos.start_disjunction_group (); // The types int the range [0,ACE_ES_EVENT_UNDEFINED) are // reserved for the EC... consumer_qos.insert_type (ACE_ES_EVENT_UNDEFINED, consumer_rt_info1); consumer_qos.insert_type (ACE_ES_EVENT_UNDEFINED + 1, consumer_rt_info2); // The canonical protocol to connect to the EC RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin = event_channel->for_consumers (); RtecEventChannelAdmin::ProxyPushSupplier_var supplier_proxy = consumer_admin->obtain_push_supplier (); RtecEventComm::PushConsumer_var consumer = consumer_impl._this (); ACE_DEBUG ((LM_DEBUG, "connecting consumer\n")); supplier_proxy->connect_push_consumer (consumer.in (), consumer_qos.get_ConsumerQOS ()); ACE_DEBUG ((LM_DEBUG, "consumer connected\n")); // **************************************************************** Supplier supplier_impl; RtecScheduler::handle_t supplier_rt_info1 = scheduler->create ("supplier_event_1"); // The execution times are set to reasonable values, but // actually they are changed on the real execution, i.e. we // lie to the scheduler to obtain right priorities; but we // don't care if the set is schedulable. tv.set (0, 10000); TimeBase::TimeT tmp; ORBSVCS_Time::Time_Value_to_TimeT (tmp, tv); RtecScheduler::Period_t rate = ACE_U64_TO_U32(tmp); scheduler->set (supplier_rt_info1, RtecScheduler::VERY_HIGH_CRITICALITY, 0, 0, 0, rate, RtecScheduler::VERY_LOW_IMPORTANCE, 0, 1, RtecScheduler::OPERATION); RtecScheduler::handle_t supplier_rt_info2 = scheduler->create ("supplier_event_2"); // The execution times are set to reasonable values, but // actually they are changed on the real execution, i.e. we // lie to the scheduler to obtain right priorities; but we // don't care if the set is schedulable. tv.set (0, 20000); ORBSVCS_Time::Time_Value_to_TimeT (tmp, tv); rate = ACE_U64_TO_U32(tmp); scheduler->set (supplier_rt_info2, RtecScheduler::VERY_HIGH_CRITICALITY, 0, 0, 0, rate, RtecScheduler::VERY_LOW_IMPORTANCE, 0, 1, RtecScheduler::OPERATION); RtecEventComm::EventSourceID supplier_id = 1; ACE_SupplierQOS_Factory supplier_qos; supplier_qos.insert (supplier_id, ACE_ES_EVENT_UNDEFINED, supplier_rt_info1, 1 /* number of calls, but what does that mean? */); supplier_qos.insert (supplier_id, ACE_ES_EVENT_UNDEFINED + 1, supplier_rt_info2, 1 /* number of calls, but what does that mean? */); // The canonical protocol to connect to the EC RtecEventChannelAdmin::SupplierAdmin_var supplier_admin = event_channel->for_suppliers (); RtecEventChannelAdmin::ProxyPushConsumer_var consumer_proxy = supplier_admin->obtain_push_consumer (); RtecEventComm::PushSupplier_var supplier = supplier_impl._this (); ACE_DEBUG ((LM_DEBUG, "connecting supplier\n")); consumer_proxy->connect_push_supplier (supplier.in (), supplier_qos.get_SupplierQOS ()); ACE_DEBUG ((LM_DEBUG, "supplier connected\n")); // **************************************************************** // At this point the consumer and supplier are connected to the // EC, they have provided their QoS info to the Scheduling // Service and the EC has informed the Scheduler about the // dependencies between them. // We can now compute the schedule for this configuration... // The schedule is returned in this variables.... if (config_run) { ACE_DEBUG ((LM_DEBUG, "Computing schedule\n")); RtecScheduler::RT_Info_Set_var infos; RtecScheduler::Dependency_Set_var deps; RtecScheduler::Config_Info_Set_var configs; RtecScheduler::Scheduling_Anomaly_Set_var anomalies; // Obtain the range of valid priorities in the current // platform, the scheduler hard-code this values in the // generated file, but in the future we may just use the // "logical" priorities and define the mapping to OS // priorities at run-time. int min_os_priority = ACE_Sched_Params::priority_min (ACE_SCHED_FIFO, ACE_SCOPE_THREAD); int max_os_priority = ACE_Sched_Params::priority_max (ACE_SCHED_FIFO, ACE_SCOPE_THREAD); scheduler->compute_scheduling (min_os_priority, max_os_priority, infos.out (), deps.out (), configs.out (), anomalies.out ()); // Dump the schedule to a file.. ACE_Scheduler_Factory::dump_schedule (infos.in (), deps.in (), configs.in (), anomalies.in (), ACE_TEXT("schedule.out")); } // **************************************************************** ACE_DEBUG ((LM_DEBUG, "Pushing events\n")); // Generate a few events.... RtecEventComm::EventSet event1 (1); event1.length (1); event1[0].header.type = ACE_ES_EVENT_UNDEFINED; event1[0].header.source = supplier_id; event1[0].header.ttl = 1; RtecEventComm::EventSet event2 (1); event2.length (1); event2[0].header.type = ACE_ES_EVENT_UNDEFINED + 1; event2[0].header.source = supplier_id; event2[0].header.ttl = 1; for (int i = 0; i != 200; ++i) { if (i % 2 == 0) { consumer_proxy->push (event1); } else { consumer_proxy->push (event2); } ACE_Time_Value rate (0, 10000); ACE_OS::sleep (rate); } // **************************************************************** // We should do a lot of cleanup (disconnect from the EC, // deactivate all the objects with the POA, etc.) but this is // just a simple demo so we are going to be lazy. } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Service"); return 1; } return 0; }
int test_assignments () { int errors {}; ACE_Time_Value tv { std::chrono::nanoseconds {100} }; if (tv.sec () != 0 || tv.usec () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::nanoseconds (100) to an ACE_Time_Value. ") ACE_TEXT ("<sec=0,usec=0> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } tv = ACE_Time_Value { std::chrono::nanoseconds {10005} }; if (tv.sec () != 0 || tv.usec () != 10) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::nanoseconds (10005) to an ACE_Time_Value. ") ACE_TEXT ("<sec=0,usec=10> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } tv = ACE_Time_Value { std::chrono::microseconds {1} }; if (tv.sec () != 0 || tv.usec () != 1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::microseconds (1) to an ACE_Time_Value. ") ACE_TEXT ("<sec=0,usec=1> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } tv = ACE_Time_Value { std::chrono::microseconds {10005} }; if (tv.sec () != 0 || tv.usec () != 10005) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::microseconds (10005) to an ACE_Time_Value. ") ACE_TEXT ("<sec=0,usec=10005> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } std::chrono::milliseconds ms_test { tv.msec () }; if (ms_test.count () != 10) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after get_chrono_msec. ") ACE_TEXT ("Expected <10> - got <%q>\n"), ms_test.count ())); ++errors; } tv = ACE_Time_Value { std::chrono::milliseconds {1} }; if (tv.sec () != 0 || tv.usec () != 1000) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::milliseconds (1) to an ACE_Time_Value. ") ACE_TEXT ("<sec=0,usec=1000> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } tv = ACE_Time_Value { std::chrono::milliseconds {10005} }; if (tv.sec () != 10 || tv.usec () != 5000) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::milliseconds (10005) to an ACE_Time_Value. ") ACE_TEXT ("<sec=10,usec=5000> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } tv = ACE_Time_Value { std::chrono::seconds {1} }; if (tv.sec () != 1 || tv.usec () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::seconds (1) to an ACE_Time_Value. ") ACE_TEXT ("<sec=1,usec=0> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } tv = ACE_Time_Value { std::chrono::seconds {10005} }; if (tv.sec () != 10005 || tv.usec () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::seconds (10005) to an ACE_Time_Value. ") ACE_TEXT ("<sec=10005,usec=0> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } tv = ACE_Time_Value { std::chrono::hours {1} }; if (tv.sec () != 3600 || tv.usec () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::hours (1) to an ACE_Time_Value. ") ACE_TEXT ("<sec=3600,usec=0> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } tv = ACE_Time_Value { std::chrono::hours {10005} }; if (tv.sec () != 3600*10005 || tv.usec () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("std::chrono::hours (10005) to an ACE_Time_Value. ") ACE_TEXT ("<sec=%d,usec=0> - got <sec=%d,usec=%d>\n"), 3600*10005, tv.sec (), tv.usec ())); ++errors; } // Two times half a day, 3 hours, 24 minutes, 54 seconds, 238 milliseconds, // 754 microseconds and 342 nanoseconds. std::chrono::duration<double, std::ratio<(24*3600)>> half_day {0.5}; std::chrono::microseconds const usec { 2 * ( std::chrono::duration_cast<std::chrono::microseconds> ( half_day + std::chrono::hours {3} + std::chrono::minutes {24} + std::chrono::seconds {54} + std::chrono::milliseconds {238} + std::chrono::microseconds {754} + std::chrono::nanoseconds {342})) }; tv = ACE_Time_Value {usec}; // half a day 3 hours 24 minutes 54 seconds time_t expected_sec = { ((12*3600) + (3*3600) + (24*60) + 54 ) * 2 }; // 238 milli usec 342 nano suseconds_t expected_usec = { ((238*1000) + 754 + 0) * 2 }; if (tv.sec () != expected_sec || tv.usec () != expected_usec) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("two times half a day, 3 hours, 24 minutes, 54 seconds, ") ACE_TEXT ("238 milliseconds, 754 microseconds and 342 nanoseconds ") ACE_TEXT ("to an ACE_Time_Value. Expected <sec=%d,usec=%d> - ") ACE_TEXT ("got <sec=%d,usec=%d>\n"), expected_sec, expected_usec, tv.sec (), tv.usec ())); ++errors; } tv.set (std::chrono::milliseconds {1120}); if (tv.sec () != 1 || tv.usec () != 120 * std::kilo::num) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unexpected value after converting ") ACE_TEXT ("a std::chrono::milliseconds of 1120 to an ACE_Time_Value ") ACE_TEXT ("Expected <sec=1,usec=120000> - got <sec=%d,usec=%d>\n"), tv.sec (), tv.usec ())); ++errors; } return errors; }
RtecEventChannelAdmin::EventChannel_ptr get_event_channel(int argc, ACE_TCHAR** argv) { FtRtecEventChannelAdmin::EventChannel_var channel; ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("hi:nt:?")); int opt; int use_gateway = 1; while ((opt = get_opt ()) != EOF) { switch (opt) { case 'i': { CORBA::Object_var obj = orb->string_to_object(get_opt.opt_arg ()); channel = FtRtecEventChannelAdmin::EventChannel::_narrow(obj.in()); } break; case 'n': use_gateway = 0; break; case 't': timer_interval.set(ACE_OS::atof(get_opt.opt_arg ())); case 'h': case '?': ACE_DEBUG((LM_DEBUG, ACE_TEXT("Usage: %s ") ACE_TEXT("-i ftrt_eventchannel_ior\n") ACE_TEXT("-n do not use gateway\n") ACE_TEXT("-t time Time interval in seconds between events (default 1.0)\n") ACE_TEXT("\n"), argv[0])); return 0; } } if (CORBA::is_nil(channel.in())) { /// Find the FTRTEC from the Naming Service CosNaming::Name name(1); name.length(1); name[0].id = CORBA::string_dup("FT_EventService"); CosNaming::NamingContext_var naming_context = resolve_init<CosNaming::NamingContext>(orb.in(), "NameService"); channel = resolve<FtRtecEventChannelAdmin::EventChannel> (naming_context.in (), name); } if (use_gateway) { // use local gateway to communicate with FTRTEC ACE_auto_ptr_reset (gateway, new TAO_FTRTEC::FTEC_Gateway (orb.in (), channel.in ())); return gateway->_this (); } else return channel._retn (); }
// 支持指定接收的结束符来接收数据 add by awayfang 2010-03-02 int PlatConnMgrEx::send_recv_ex(const void * send_buf, int send_len , void * recv_buf, int recv_len, const char * separator, const unsigned int uin) { int ip_idx = get_ip_idx(uin); // ip 默认根据 uin 轮询 int index = get_index(ip_idx, uin); ACE_SOCK_Stream* conn = get_conn(index, ip_idx); if (conn == NULL) { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx get conn failed" ",can't get a useful conn" ",index=%d,ip_idx=%d,uin=%u\n" , index, ip_idx, uin )); return -1; } // 因为 ip_idx 可能被修改,加锁需要放在获取的后面 ACE_Guard<ACE_Thread_Mutex> guard(conn_lock_[ip_idx][index]); // 加锁后增加一次非法判断 不然有可能被其他线程释放连接对象 if (conn_[ip_idx][index] == NULL) { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx send_recv_ex failed" ",conn is null" ",index=%d,ip_idx=%d,uin=%u\n" , index, ip_idx, uin )); return -1; } conn_use_flag_[ip_idx][index] = 1; //清除原缓冲 add by awayfang 2010-03-02 ACE_Time_Value zero; zero.set(0); int max_recv_len = recv_len; int tmp_ret = conn_[ip_idx][index]->recv(recv_buf, max_recv_len, &zero);//不等特直接返返回 // 检测到连接关闭时, 重建连接 // 在对面进程重启时, 有可能发生 if((tmp_ret < 0 && errno != ETIME) // 连接上无数据的情况,会返回超时,不需重连 || tmp_ret == 0) // 连接已经被对端关闭, 处于close wait状态 { ACE_DEBUG((LM_INFO, "[%D] PlatConnMgrEx send_recv_ex connection close detected," "uin=%u,ip=%s,index=%d\n", uin, ip_[ip_idx], index)); init_conn(index, ip_idx); if(conn_[ip_idx][index] == NULL) { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx send_recv_ex reconnect failed," "index=%d,ip_idx=%d\n", index, ip_idx)); return -1; } } ACE_DEBUG((LM_TRACE, "[%D] PlatConnMgrEx send_recv_ex msg" ",index=%d,ip_idx=%d,uin=%u\n", index, ip_idx, uin)); int ret = conn_[ip_idx][index]->send_n(send_buf, send_len, &time_out_); if (ret <= 0) //异常或者对端关闭 { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx send_recv_ex send msg failed" ",index=%d,ip_idx=%d,ret=%d,uin=%u,errno=%d\n", index, ip_idx, ret, uin, errno)); //关闭连接,清理状态 fini(index, ip_idx); Stat::instance()->incre_stat(STAT_CODE_SEND_FAIL); return ret; } ACE_DEBUG((LM_TRACE, "[%D] PlatConnMgrEx send_recv_ex send msg succ" ",index=%d,ip_idx=%d,ret=%d,uin=%u\n", index, ip_idx, ret, uin)); // ret = conn_[ip_idx][index]->recv(recv_buf, recv_len, &time_out_); if (ret <= 0) //异常或者对端关闭 { ACE_DEBUG((LM_ERROR, "[%D] PlatConnMgrEx send_recv_ex recv msg failed" ",index=%d,ip_idx=%d,ret=%d,uin=%u,errno=%d\n", index, ip_idx, ret, uin, errno)); //关闭连接,清理状态 fini(index, ip_idx); Stat::instance()->incre_stat(STAT_CODE_RECV_FAIL); return ret; } // 判断结束符 if (separator != NULL) { int tmp_recv_len = ret; //判断消息是否结束 while (strstr((const char*)recv_buf, separator) == NULL && tmp_recv_len < max_recv_len) //未结束,继续接收 { ret = conn_[ip_idx][index]->recv((char*)recv_buf + tmp_recv_len , max_recv_len - tmp_recv_len, &time_out_); if (ret <= 0) //异常或者对端关闭 { ACE_DEBUG((LM_ERROR, "[%D] [%N,%l]PlatConnMgrEx send_recv_ex" " recv msg failed" ",index=%d,ip_idx=%d,ret=%d,uin=%u,errno=%d\n", index, ip_idx, ret, uin, errno)); //关闭连接,清理状态 fini(index, ip_idx); Stat::instance()->incre_stat(STAT_CODE_RECV_FAIL); return ret; } tmp_recv_len += ret; ACE_DEBUG((LM_TRACE, "[%D] PlatConnMgrEx send_recv_ex msg" ",index=%d,ip_idx=%d,ret=%d,uin=%u\n", index, ip_idx, ret, uin)); } ret = tmp_recv_len; } ACE_DEBUG((LM_TRACE, "[%D] PlatConnMgrEx send_recv_ex msg succ" ",index=%d,ip_idx=%d,ret=%d,uin=%u\n", index, ip_idx, ret, uin)); conn_use_flag_[ip_idx][index] = 0;//退出前清理使用状态 return ret; }
void Test_Supplier::connect (RtecScheduler::Scheduler_ptr scheduler, const char* name, int burst_count, int burst_size, int event_size, int burst_pause, int type_start, int type_count, RtecEventChannelAdmin::EventChannel_ptr ec) { this->burst_count_ = burst_count; this->burst_size_ = burst_size; this->event_size_ = event_size; this->burst_pause_ = burst_pause; this->type_start_ = type_start; this->type_count_ = type_count; RtecScheduler::handle_t rt_info = scheduler->create (name); ACE_Time_Value tv (0, burst_pause); RtecScheduler::Period_t rate = tv.usec () * 10; // The execution times are set to reasonable values, but // actually they are changed on the real execution, i.e. we // lie to the scheduler to obtain right priorities; but we // don't care if the set is schedulable. tv.set (0, 2000); TimeBase::TimeT time; ORBSVCS_Time::Time_Value_to_TimeT (time, tv); scheduler->set (rt_info, RtecScheduler::VERY_HIGH_CRITICALITY, time, time, time, rate, RtecScheduler::VERY_LOW_IMPORTANCE, time, 1, RtecScheduler::OPERATION); this->supplier_id_ = ACE::crc32 (name); ACE_DEBUG ((LM_DEBUG, "ID for <%s> is %04.4x\n", name, this->supplier_id_)); ACE_SupplierQOS_Factory qos; for (int i = 0; i != type_count; ++i) { qos.insert (this->supplier_id_, type_start + i, rt_info, 1); } qos.insert (this->supplier_id_, ACE_ES_EVENT_SHUTDOWN, rt_info, 1); RtecEventChannelAdmin::SupplierAdmin_var supplier_admin = ec->for_suppliers (); this->consumer_proxy_ = supplier_admin->obtain_push_consumer (); RtecEventComm::PushSupplier_var objref = this->supplier_._this (); this->consumer_proxy_->connect_push_supplier (objref.in (), qos.get_SupplierQOS ()); }