static int handleSynchSetup(CRtspSession* pSession, const unsigned int unTimeout,
const bool bTcpFlag, MEDIA_ADDR *pstPeerMediaAddr)
{
// 等待信号触发，否则阻塞在此
ACE_Time_Value wait = ACE_OS::gettimeofday();
wait.sec (wait.sec () + unTimeout);
int nRet = pSession->m_pRtspSemaphore->acquire(&wait);
// 接收超时，直接返回
if(0 != nRet)
{
ACE_Guard <ACE_Thread_Mutex> locker (pSession->m_Mutex);
IVS_RUN_LOG_ERR("receive rtsp setup response out of time, handle[%p].", pSession);
pSession->destroyRtspMsg();
return RTSP_ERR_TIMEOUT;
}
//IVS_RUN_LOG_ERR("----- handleSynchSetup 1, handle[%p].", pSession);
// 解析错误，直接返回
if (!pSession->m_bRecvRetFlag)
{
ACE_Guard <ACE_Thread_Mutex> locker (pSession->m_Mutex);
int iRet = pSession->m_iRetCode;
pSession->destroyRtspMsg();
IVS_RUN_LOG_ERR("receive rtsp setup response decode error, handle[%p], RetCode[%d].", pSession, iRet);
return iRet;
}
//IVS_RUN_LOG_ERR("----- handleSynchSetup 2, handle[%p].", pSession);
// UDP传输方式下，获取媒体流发送地址
//if (false == bTcpFlag)
CRtspSetupMessage* pRtspMsg = dynamic_cast<CRtspSetupMessage*>(pSession->m_pRtspMsg);
if (NULL == pRtspMsg)
{
IVS_RUN_LOG_ERR("receive rtsp setup response msg is null, handle[%p].", pSession);
return RET_FAIL;
}
if (0 != pRtspMsg->getServerIp())
{
pstPeerMediaAddr->unMediaIp = pRtspMsg->getServerIp(); //lint !e613
pstPeerMediaAddr->unMediaVideoPort = pRtspMsg->getServerVideoPort(); //lint !e613
pstPeerMediaAddr->unMediaAudioPort = pRtspMsg->getServerAudioPort(); //lint !e613
}
//IVS_RUN_LOG_ERR("----- handleSynchSetup 3, handle[%p].", pSession);
// 释放消息
pSession->destroyRtspMsg();
// 解析成功，更改状态为ready
pSession->setStatus(RTSP_SESSION_STATUS_READY);
IVS_RUN_LOG_INF("send setup message success, handle[%p].", pSession);
return RET_OK;
}
// get current physical timestamp, unit is milliseconds since 1970 (system clock)
timestamp_t
net_ace::
getTimestamp ()
{
ACE_Time_Value time = ACE_OS::gettimeofday();
timestamp_t now = (timestamp_t)(time.sec () * 1000 + time.usec () / 1000);
return now;
}
ScopedTimer::~ScopedTimer()
{
destroy_time_ = ACE_OS::gettimeofday();
ACE_Time_Value diff = destroy_time_ - init_time_;
printf("[ScopedTimer: %s Time: %ld.%03ldms]\n",
name_.c_str(),
diff.sec() * 1000 + diff.usec() / 1000,
diff.usec() % 1000);
}
//------------------------------------------------------------------------------
ACE_Time_Value
TimeUtil::duration2ace(const acstime::Duration &duration)
{
long sec = duration.value / 10000000LL;
ACE_Time_Value aceTime;
aceTime.sec(sec);
aceTime.usec((duration.value - (sec * 10000000LL)) / 10);
return aceTime;
}
void
test_i::shutdown (CORBA::Long start_time)
{
ACE_Time_Value start (0);
start.msec (static_cast<long> (start_time)); // HPUX seems to require this cast
ACE_DEBUG ((LM_DEBUG, "server: Shutting down... (%dms)\n",
(ACE_OS::gettimeofday() - start).msec ()));
this->orb_->shutdown (0);
}
bool CoAPRDService::initialize()
{
try
{
std::string conf("service.conf");
std::string reactor("service.reactor");
_confPtr = ServiceGetter::findByName<ConfService>(context(), conf);
_reactorPtr = ServiceGetter::findByName<ReactorService>(context(), reactor);
}
catch(toolkit::NullPointerException &e)
{
ACE_DEBUG((LM_DEBUG, "get service failed at SerialPortService\n"));
return false;
}
_coapWrapperPtr = new CoAPWrapper();
if (_coapWrapperPtr->Create(_confPtr->_rdAddr,
_confPtr->_rdAddrPort,
_confPtr->_coapDebugLevel
) < 0)
{
ACE_DEBUG((LM_DEBUG,"Failed to create coap\n"));
return false;
}
_rdRes = new CoAP_RD_Resource(_coapWrapperPtr.get());
if ((_rdRes->Create()) == 0)
{
ACE_DEBUG((LM_DEBUG,"Failed to craete rd resource\n"));
return false;
}
_rdLookup = new CoAPRDLookUpResource(_coapWrapperPtr.get());
if ((_rdLookup->Create()) == 0)
{
ACE_DEBUG((LM_DEBUG,"Failed to craete lookup resource\n"));
return false;
}
ACE_Time_Value timeout;
timeout.sec(5);
_reactorPtr->register_handler(this, ACE_Event_Handler::READ_MASK);
_reactorPtr->schedule_timer(this, 0, timeout);
return true;
}
/// WARNING: actual precision under WIN32 depends on setting scheduler
/// by means of MM functions.
///
void SystemClock::delaySystem(double seconds) {
#ifdef YARP_HAS_ACE
ACE_Time_Value tv;
tv.sec (long(seconds));
tv.usec (long((seconds-long(seconds)) * 1.0e6));
ACE_OS::sleep(tv);
#else
usleep(seconds*1000000);
#endif
}
int
STDIN_Handler::handle_timeout (const ACE_Time_Value &tv,
const void *)
{
ACE_DEBUG ((LM_DEBUG,
"(%t) timeout occurred at %d sec, %d usec\n",
tv.sec (),
tv.usec ()));
return 0;
}
CORBA::Object_ptr
ServantRetentionStrategyNonRetain::create_reference (
const char *intf,
CORBA::Short priority)
{
// This operation creates an object reference that encapsulates a
// POA-generated Object Id value and the specified interface
// repository id. This operation does not cause an activation to
// take place. The resulting reference may be passed to clients, so
// that subsequent requests on those references will cause the
// appropriate servant manager to be invoked, if one is
// available. The generated Object Id value may be obtained by
// invoking POA::reference_to_id with the created reference.
PortableServer::ObjectId_var system_id;
PortableServer::ObjectId user_id;
// Otherwise, it is the NON_RETAIN policy. Therefore, any ol'
// object id will do (even an empty one). However, to make an
// object id useful for discriminating objects in applications
// use a simple id of a counter and a time stamp. The use of a
// counter by itself is not sufficient for uniqueness over time
// and a timestamp isn't sufficient since multiple IDs may be
// requested within the same time unit.
PortableServer::ObjectId *sys_id = 0;
ACE_NEW_THROW_EX (sys_id,
PortableServer::ObjectId (8),
CORBA::NO_MEMORY ());
sys_id->length(8);
long count = this->sys_id_count_++;
ACE_Time_Value now = ACE_OS::gettimeofday();
ACE_UINT32 *id_ptr = reinterpret_cast<ACE_UINT32 *>(sys_id->get_buffer());
*(id_ptr++) = count;
*id_ptr = static_cast<ACE_UINT32>(now.sec());
system_id = sys_id;
// User id is the same as system id.
user_id = system_id.in ();
// Remember params for potentially invoking <key_to_object> later.
this->poa_->key_to_object_params_.set (system_id,
intf,
0,
1,
priority,
true);
return this->poa_->invoke_key_to_object_helper_i (intf, user_id);
}
int RDService::handle_timeout (const ACE_Time_Value &tv,
const void *arg)
{
ACE_Time_Value timeout;
timeout.sec(5);
coap_wrapper_->time_out(timeout);
net_->schedule_timer(this, 0, timeout);
return 0;
}
//------------------------------------------------------------------------------
ACE_Time_Value
TimeUtil::epoch2ace(const acstime::Epoch &epoch)
{
long long int time = epoch.value - acstime::ACE_BEGIN; // 100ns units
long sec = time / 10000000LL;
ACE_Time_Value aceTime;
aceTime.sec(sec);
aceTime.usec((time - (sec * 10000000LL)) / 10);
return aceTime;
}
ACE_Log_Record::ACE_Log_Record (ACE_Log_Priority lp,
const ACE_Time_Value &ts,
long p)
: length_ (0),
type_ (ACE_UINT32 (lp)),
secs_ ((ACE_UINT32) ts.sec ()),
usecs_ ((ACE_UINT32) ts.usec ()),
pid_ (ACE_UINT32 (p))
{
// ACE_TRACE ("ACE_Log_Record::ACE_Log_Record");
}
bool
Client::flood_connection (ACE_Time_Value& tv)
{
// Block flushing currently blocks even on SYNC_DELAYED_BUFFERING
// so we can't use it to flood connections.
// Set the policy value.
// SYNC_DELAYED_BUFFERING is used to ensure that the tcp buffer gets filled before
// buffering starts.
Messaging::SyncScope sync_scope = TAO::SYNC_DELAYED_BUFFERING;
//Messaging::SyncScope sync_scope = Messaging::SYNC_NONE;
CORBA::Any sync_scope_any;
sync_scope_any <<= sync_scope;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] = orb_->create_policy
(Messaging::SYNC_SCOPE_POLICY_TYPE, sync_scope_any);
// Apply the policy at the object level
CORBA::Object_var obj = test_obj_->_set_policy_overrides
(policy_list, CORBA::SET_OVERRIDE);
Test_var mod_test_obj = Test::_narrow (obj.in ());
policy_list[0]->destroy ();
policy_list.length(0);
ACE_Auto_Array_Ptr<char> tmp (new char [2000000]);
char* msg = tmp.get();
ACE_OS::memset (msg,'A',1999999);
msg[1999999] = 0;
test_obj_->sleep (static_cast<CORBA::Long>(tv.sec())
, static_cast<CORBA::Long>(tv.msec()));
/* BLOCK flush startegy always has SYNC_WITH_TRANSPORT semantics.
Trying to flood a BLOCKed flushing connection can lead to a TIMEOUT
exception being thrown. This will close out the connection and
the whole flooding attempt fails. Therefore in BLOCK flushing case
don't attempt to flood (unless BLOCK flush accepts SYNC_WITH_TRANSPORT
semantics).
*/
if (flush_strategy_ != BLOCKING)
{
mod_test_obj->dummy_one_way (msg);
// attempt again to flood connection.
ACE_Time_Value tv_tmp (2);
orb_->perform_work (tv_tmp);
}
return true;
}
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;
}
int CoAPRDService::handle_timeout (const ACE_Time_Value &tv,
const void *arg)
{
ACE_Time_Value timeout;
timeout.sec(5);
_coapWrapperPtr->time_out(timeout);
_reactorPtr->schedule_timer(this, 0, timeout);
_rdRes->timeout();
return 0;
}
int RDService::Init()
{
ACE_Time_Value timeout;
timeout.sec(5);
if ((coap_wrapper_ = new CoAPWrapper()) == 0)
{
ACE_DEBUG((LM_DEBUG, "Failed to allocate CoAPWrapper in RD\n"));
return -1;
}
if (coap_wrapper_->Create(conf_->rd_addr_,
conf_->rd_addr_port_,
conf_->coap_debug_level_
) < 0)
{
ACE_DEBUG((LM_DEBUG,"Failed to create coap\n"));
return -1;
}
if ((rd_resource_ = new CoAP_RD_Resource(coap_wrapper_)) == 0)
{
ACE_DEBUG((LM_DEBUG, "Failed to allocate rd resource in RD\n"));
return -1;
}
if ((rd_resource_->Create()) == 0)
{
ACE_DEBUG((LM_DEBUG,"Failed to craete rd resource\n"));
return -1;
}
if ((lookup_resource_ = new CoAPRDLookUpResource(coap_wrapper_)) == 0)
{
ACE_DEBUG((LM_DEBUG, "Failed to allocate lookup resource in RD\n"));
return -1;
}
if ((lookup_resource_->Create()) == 0)
{
ACE_DEBUG((LM_DEBUG,"Failed to craete lookup resource\n"));
return -1;
}
net_->join(coap_wrapper_->get_handle());
net_->RegHandler(this, ACE_Event_Handler::READ_MASK);
net_->schedule_timer(this, 0, timeout);
return 0;
}
// Tests the amount of time spent in a timed wait.
static int
test_timeout (void)
{
int status = 0;
// milliseconds...
long msecs_expected;
long msecs_waited;
long msecs_diff;
// Wait a little longer each time
static long wait_secs = 3;
ACE_Time_Value wait = ACE_OS::gettimeofday ();
ACE_Time_Value begin = wait;
wait.sec (wait.sec () + wait_secs);
if (s.acquire (wait) == -1)
{
if (errno != ETIME)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("test_timeout should be ETIME but is")));
status = -1;
}
}
ACE_Time_Value wait_diff = ACE_OS::gettimeofday () - begin;
msecs_waited = wait_diff.msec ();
msecs_expected = wait_secs * 1000;
msecs_diff = labs (msecs_expected - msecs_waited);
if (msecs_diff > ACE_ALLOWED_SLACK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Timed wait fails length test\n")));
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Expected %d ms, actual %d ms; %d allowed\n"),
(int)msecs_expected,
(int)msecs_waited,
(int)ACE_ALLOWED_SLACK));
status = -1;
}
++wait_secs;
return status;
}
int
Thr_Consumer_Handler::svc (void)
{
for (in_thread_ = 1;;)
{
ACE_DEBUG ((LM_DEBUG,
"(%t) Thr_Consumer_Handler's handle = %d\n",
this->peer ().get_handle ()));
// Since this method runs in its own thread it is OK to block on
// output.
for (ACE_Message_Block *mb = 0;
this->msg_queue ()->dequeue_head (mb) != -1;
)
if (this->send (mb) == -1)
ACE_ERROR ((LM_ERROR,
"(%t) %p\n",
"send failed"));
ACE_ASSERT (errno == ESHUTDOWN);
ACE_DEBUG ((LM_DEBUG,
"(%t) shutting down threaded Consumer_Handler %d on handle %d\n",
this->connection_id (),
this->get_handle ()));
this->peer ().close ();
// Re-establish the connection, using exponential backoff.
for (this->timeout (1);
// Default is to reconnect synchronously.
this->event_channel_->initiate_connection_connection (this, 1) == -1;
// Second parameter '1' means using sync mode directly,
// don't care Options::blocking_semantics(). If don't do
// so, async mode will be used to connect which won't
// satisfy original design.
)
{
ACE_Time_Value tv (this->timeout ());
ACE_ERROR ((LM_ERROR,
"(%t) reattempting connection, sec = %d\n",
tv.sec ()));
ACE_OS::sleep (tv);
}
}
ACE_NOTREACHED (return 0;)
}
CORBA::Boolean
TAO_Log_i::scheduled (void)
{
DsLogAdmin::TimeInterval interval =
this->recordstore_->get_interval ();
TimeBase::TimeT current_time;
ACE_Time_Value tv = ACE_OS::gettimeofday ();
ORBSVCS_Time::Time_Value_to_TimeT (current_time, tv);
if (current_time >= interval.start
&& (current_time <= interval.stop || interval.stop == 0))
{
if (weekly_intervals_.length () > 0)
{
// Work out when sunday is in nanoseconds.
time_t clock = tv.sec ();
struct tm *sunday = ACE_OS::localtime (&clock);
sunday->tm_sec = 0;
sunday->tm_min = 0;
sunday->tm_hour = 0;
sunday->tm_mday -= sunday->tm_wday;
tv.sec (ACE_OS::mktime (sunday));
tv.usec (0);
TimeBase::TimeT nano_sunday =
(CORBA::ULongLong) tv.sec () * 10000000;
for (CORBA::ULong i = 0; i < weekly_intervals_.length (); ++i)
{
if (current_time >= (weekly_intervals_[i].start + nano_sunday)
&& current_time <= (weekly_intervals_[i].stop + nano_sunday))
{
return true;
}
}
return false;
}
else
{
return true;
}
}
else
{
return false;
}
}
/// @todo: rather than is_error, use pacing interval so it will be configurable
/// @todo: find some way to use batch buffering stratgy for sequence consumers.
void
TAO_Notify_Consumer::schedule_timer (bool is_error)
{
if (this->timer_id_ != -1)
{
return; // We only want a single timeout scheduled.
}
// don't schedule timer if there's nothing that can be done
if (this->is_suspended ())
{
return;
}
ACE_ASSERT (this->timer_.get() != 0);
// If we're scheduling the timer due to an error then we want to
// use the retry timeout, otherwise we'll assume that the pacing
// interval is sufficient for now.
ACE_Time_Value tv (DEFAULT_RETRY_TIMEOUT);
if (! is_error)
{
if (this->pacing_.is_valid ())
{
tv = ORBSVCS_Time::to_Time_Value (this->pacing_.value ());
}
}
if (DEBUG_LEVEL > 5)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("Consumer %d: scheduling pacing/retry for %dms.\n"),
static_cast<int> (this->proxy ()->id ()), tv.msec ()));
}
this->timer_id_ =
this->timer_->schedule_timer (this, tv, ACE_Time_Value::zero);
if (this->timer_id_ == -1)
{
ORBSVCS_ERROR ((LM_ERROR,
ACE_TEXT ("TAO_Notify_Consumer %d::schedule_timer () ")
ACE_TEXT ("Error scheduling timer.\n"),
static_cast<int> (this->proxy ()->id ())
));
}
if (this->is_suspended()) // double check to avoid race
{
this->cancel_timer();
}
}
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 MgServerFeatureTransactionPool::RemoveExpiredTransaction()
{
ACE_MT(ACE_GUARD(ACE_Recursive_Thread_Mutex, ace_mon, sm_mutex));
MG_CONFIGURATION_TRY()
ACE_Time_Value now = ACE_OS::gettimeofday();
FeatureTransactionCollection::iterator iterator = m_featureTransactions.begin();
while (iterator != m_featureTransactions.end())
{
MgServerFeatureTransaction* featTransaction = iterator->second;
if (NULL != featTransaction)
{
INT64 time = now.sec() - featTransaction->LastUsed().sec();
if (time > m_transactionTimeout)
{
try
{
// Set timeout for this transaction object. It will release the internal FdoITransaction object.
featTransaction->SetTimeout();
}
catch (FdoException* e)
{
FDO_SAFE_RELEASE(e);
}
catch (...)
{
}
featTransaction->Release();
// Add the id to timeout list
m_transactionTimeoutIds.push_back(iterator->first);
m_featureTransactions.erase(iterator++);
}
else
{
++iterator;
}
}
else
{
assert(false);
++iterator;
}
}
MG_CONFIGURATION_CATCH_AND_THROW(L"MgServerFeatureTransactionPool.RemoveExpiredTransaction")
}
bool
Eager_Transport_Queueing_Strategy::timer_check (
const TAO::BufferingConstraint &buffering_constraint,
const ACE_Time_Value ¤t_deadline,
bool &set_timer,
ACE_Time_Value &new_deadline) const
{
set_timer = false;
if (!ACE_BIT_ENABLED (buffering_constraint.mode,
TAO::BUFFER_TIMEOUT))
{
return false;
}
// Compute the next deadline...
ACE_Time_Value const now = ACE_OS::gettimeofday ();
ACE_Time_Value timeout =
this->time_conversion (buffering_constraint.timeout);
new_deadline = now + timeout;
// Check if the new deadline is more stringent, or if the deadline
// has expired and thus must be reset anyway.
if (current_deadline > new_deadline
|| current_deadline < now)
{
set_timer = true;
}
// ... if there is no deadline we don't want to schedule output (the
// deadline will be set because set_timer is set to 1 in that case).
// If there is a deadline but but it has not been reached, we
// don't want to schedule any output either...
if (current_deadline == ACE_Time_Value::zero
|| current_deadline >= now)
{
return false;
}
if (TAO_debug_level > 6)
{
TAOLIB_DEBUG ((LM_DEBUG,
"TAO (%P|%t) - TAO_Eager_Buffering_Sync_Strategy::timer_check, "
"Now = %u, Current = %u, New = %u\n",
now.msec (), current_deadline.msec (),
new_deadline.msec ()));
}
return true;
}
static void *
worker (void *)
{
for (int iterations = 1;
iterations <= n_iterations;
iterations++)
{
//FUZZ: disable check_for_lack_ACE_OS
ACE_Time_Value wait (0,
iterations * 1000 * 100); // Wait 'iter' msec
//FUZZ: enable check_for_lack_ACE_OS
ACE_Time_Value tv = ACE_OS::gettimeofday () + wait;
if (evt.wait (&tv) == -1)
{
// verify that we have ETIME
if (ACE_OS::last_error() != ETIME)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("Worker should be ETIME but is")));
}
else
++timeouts;
ACE_Time_Value diff = ACE_OS::gettimeofday ();
diff = diff - tv; // tv should have been reset to time acquired
long diff_msec = diff.msec ();
if (diff_msec > ACE_ALLOWED_SLACK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Acquire fails time reset test\n")));
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Diff btw now and returned time: %d ms; ")
ACE_TEXT ("%d allowed\n"),
(int)diff_msec,
(int)ACE_ALLOWED_SLACK));
test_result = 1;
}
// Hold the lock for a while.
ACE_OS::sleep (ACE_Time_Value (0,
(ACE_OS::rand () % 1000) * 1000));
evt.signal ();
}
ACE_Thread::yield ();
}
return 0;
}
// TODO improve via loglevel
void log(int logLevel, std::string s) {
// cerr << __FILE__ << " : "
// << __LINE__ << ":"
// << __FUNCTION__<< s << endl;
ACE_Time_Value time;
time_t tt;
time = ACE_OS::gettimeofday();
tt = time.sec();
std::string label[]={"[INFO]","[WARNING]","[ERROR]","[FATAL ERROR]"};
cerr << "[main] " << label[logLevel] << " " << s << " " << ctime(&tt);
}
CORBA::ULongLong
TAO_Time_Service_Clerk::get_time (void)
{
// Globally sync. time is the latest global time plus the time
// elapsed since last updation was done.
const ACE_Time_Value timeofday = ACE_OS::gettimeofday ();
return (CORBA::ULongLong) (static_cast<CORBA::ULongLong> (timeofday.sec ()) *
static_cast<ACE_UINT32> (10000000) +
static_cast<CORBA::ULongLong> (timeofday.usec () * 10))
- this->update_timestamp_
+ this->time_;
}
int main()
{
ACE::init();
fprintf(stderr, "Starting timing test\n");
ACE_Time_Value now1,now2;
ACE_High_Res_Timer timer;
ACE_Profile_Timer profiler;
ACE_Time_Value sleep;
ACE_Time_Value elapsed;
double avErrors[wTimes];
int i,k;
for(i=0;i<wTimes;i++)
avErrors[i]=0;
for(i=0;i<iterations;i++)
{
double req;
double time;
for(k=0;k<wTimes;k++)
{
req=sleepT[k];
sleep.msec(sleepT[k]);
now1 = ACE_OS::gettimeofday ();
//ACE_OS::sleep(sleep);
usleep(sleep.sec()*1000000+sleep.usec()-1000);
now2 = ACE_OS::gettimeofday ();
time=(now2.sec()-now1.sec())*1000;
time+=(now2.usec()-now1.usec())/1000;
avErrors[k]+=fabs(req-time)/iterations;
fprintf(stderr, "*");
}
fprintf(stderr, "Completed %d out of %d\n", i+1, iterations);
}
for(i=0;i<wTimes;i++)
{
sleep.msec(sleepT[i]);
fprintf(stderr, "Req %us and %u[ms], average error %.3lf\n", (unsigned int)sleep.sec(), (unsigned int) sleep.usec()/1000, avErrors[i]);
}
ACE::fini();
}
int
Thread_Handler::handle_timeout (const ACE_Time_Value &time, const void *)
{
ACE_DEBUG ((LM_DEBUG,
"(%t) received timeout at (%u, %u), iterations = %d\n",
time.sec (),
time.usec (),
this->iterations_));
if (--this->iterations_ <= 0
|| Thread_Handler::interval_.sec () == 0)
ACE_Reactor::end_event_loop ();
return 0;
}
// this routine makes up the brains of the agent
// it knows only the MIB II system group set of variables for a get operation
int agent_impl::get_response(Vb& vb)
{
// these objects represent the MIB II system group per RFC 1213
static Oid sysDescr("1.3.6.1.2.1.1.1.0"),
sysObjectID("1.3.6.1.2.1.1.2.0"), sysUpTime("1.3.6.1.2.1.1.3.0"),
sysContact("1.3.6.1.2.1.1.4.0"), sysName("1.3.6.1.2.1.1.5.0"),
sysLocation("1.3.6.1.2.1.1.6.0"), sysServices("1.3.6.1.2.1.1.7.0");
Oid oid;
vb.get_oid(oid);
if (oid == sysDescr) {
OctetStr desc("ASNMP Prototype Agent 1.0");
vb.set_value(desc);
}
else if (oid == sysObjectID) { // the IANA gives assigns Enterprise Numbers
// see ftp://ftp.isi.edu/in-notes/iana/assignments/enterprise-numbers
// for the official list of enterprise numbers. Then under this tree
// assign a unique subtree to identify this agent
Oid id("1.3.6.1.4.1.2533.9.1");
vb.set_value(id);
}
else if (oid == sysUpTime) {
ACE_Time_Value tv;
agent_clock_.elapsed_time (tv);
TimeTicks tt(tv.msec());
vb.set_value(tt);
}
else if (oid == sysContact) {
OctetStr contact("*****@*****.**");
vb.set_value(contact);
}
else if (oid == sysName) {
OctetStr fqdn("foo.org"); // extract this from the gethostbyname() TODO
vb.set_value(fqdn);
}
else if (oid == sysLocation) {
OctetStr loc("");
vb.set_value(loc);
}
else if (oid == sysServices) {
SnmpInt32 svcs(72);
vb.set_value(svcs);
}
else
return 1; // noSuchName
return 0;
}
/*\brief Receive single datagram
\note The function employes dgram_port and dgram_recv_timeout variables
\retval -1 if not received,
\retval 0 received a datagrams
*/
int run_receiver ()
{
ACE_DEBUG
((LM_INFO,
ACE_TEXT ("Receiving datagrams from port %d with timeout %d ms\n"),
dgram_port, dgram_recv_timeout.msec ()));
ACE_SOCK_Dgram socket;
ACE_INET_Addr remote ;
static char dgram_buffer[BUFSIZ];
if (socket.open (ACE_INET_Addr (dgram_port)) != -1)
if (socket.recv (dgram_buffer, sizeof (dgram_buffer),
remote, 0, &dgram_recv_timeout) > 0)
{
ACE_DEBUG ((LM_INFO, ACE_TEXT ("%C received\n"), dgram_buffer));
return 0;
}
else
{
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"),
ACE_TEXT ("Cannot receive datagrams")), -1);
}
else
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p: %d\n"),
ACE_TEXT ("Cannot open broadcast socket on port"), dgram_port), -1);
}
}