DiameterSessionEntryList::DiameterSessionEntryList() { ACE_Time_Value tm = ACE_OS::gettimeofday(); m_LastKnownCounter.High() = tm.sec(); m_LastKnownCounter.Low() = tm.usec(); }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("NDDS_Timer_Test")); RTIClock *timer = RTIHighResolutionClock_new(); u_int errors = 0; u_int iterations = 1; ACE_Get_Opt getoptarg (argc, argv, ACE_TEXT ("i:")); for (int c; (c = getoptarg ()) != -1; ) { switch (c) { case 'i': iterations = ACE_OS::atoi (getoptarg.opt_arg ()); break; } } // We don't check for errors if the interval is shorter than this // value because the OS has a finite resolution anyway. static u_int const TIMER_RESOLUTION = 10000; for (u_int i = 0; i < sizeof intervals / sizeof (u_int); ++i) { for (u_int j = 0; j < iterations; ++j) { ACE_Time_Value const interval (0, intervals[i]); RTINtpTime duration; time_interval (timer, interval, duration); unsigned long long microseconds, nanoseconds; int sec; RTINtpTime_unpackToMicrosec (sec, microseconds, duration); RTINtpTime_unpackToNanosec (sec, nanoseconds, duration); time_t const interval_usec = interval.sec () * ACE_ONE_SECOND_IN_USECS + interval.usec (); time_t const measured_usec = sec * ACE_ONE_SECOND_IN_USECS + microseconds; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("interval: %: usec, measured: %: usec %s\n"), interval_usec, measured_usec, (intervals[i] <= TIMER_RESOLUTION ? ACE_TEXT (" (interval and measured may differ)") : ACE_TEXT ("")))); if (intervals[i] > TIMER_RESOLUTION) { errors += check (interval.sec () * ACE_ONE_SECOND_IN_USECS + interval.usec (), sec * ACE_ONE_SECOND_IN_USECS + microseconds); // Don't check for error for intervals below 10 msec. } errors += check_micro_nano (microseconds, nanoseconds); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("NDDS_Timer usec: %Q, nsec: %Q\n"), microseconds, nanoseconds)); } } ACE_END_TEST; return errors == 0 ? 0 : 1; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { if ( argc < 2 ) ACE_ERROR_RETURN ((LM_ERROR, "Usage: %s <rate> <PDU> <session> <host> <selector> [ host sel ] ...\n" "\tUse 0 for default values\n", argv[0]), 1); int rate = ACE_OS::atoi( argv[ 1 ]); rate = ( rate != 0 ) ? rate : 170000; int pdu_size = ACE_OS::atoi( argv[ 2 ]) * 1024; pdu_size = ( pdu_size != 0 ) ? pdu_size : 8192; int session = ACE_OS::atoi( argv[ 3 ]); session = ( session != 0 ) ? session : 100; ACE_OS::printf( "ATM_Client: rate: %d c/s, PDU: %dB, session: %d pkts\n", rate, pdu_size, session ); // Record all hosts/selectors ACE_ATM_Addr hosts[ MAX_LEAVES ]; int num_leaves = argc / 2 - 2; ACE_OS::printf( "ATM_Client: Connecting to ...\n" ); for ( int i = 0; i < num_leaves; i++ ) { hosts[ i ].set( argv[ i*2 + 4 ], ( argv[ i*2 + 5 ] != 0 ) ? ACE_OS::atoi( argv[ i*2 + 5 ]) : ACE_ATM_Addr::DEFAULT_SELECTOR ); ACE_OS::printf( "ATM_Client: leaf: %s (%s), sel: %d\n", argv[ i*2 + 4 ], hosts[ i ].addr_to_string(), hosts[ i ].get_selector()); } // The timeout really gets ignored since FORE's drivers don't work when // ioctl or fcntl calls are made on the transport id/file descriptor int timeout = ACE_DEFAULT_TIMEOUT; char buf[BUFSIZ]; ACE_ATM_Stream atm_stream; char hostname[ MAXNAMELEN ]; ACE_OS::hostname( hostname, MAXNAMELEN ); ACE_ATM_Addr local_addr( hostname, hosts[ 0 ].get_selector()); ACE_OS::printf( "ATM_Client: local host: %s(%s)\n", hostname, local_addr.addr_to_string()); // In order to construct connections options the file handle is // needed. Therefore, we need to open the ATM_Stream before we // construct the options. ACE_OS::printf( "ATM_Client: to open a stream\n" ); if (atm_stream.open () == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open failed"), 1); ACE_DEBUG ((LM_DEBUG, "ATM_Client: starting non-blocking connection\n")); // Initiate timed, non-blocking connection with server. ACE_ATM_Connector con; // Construct QoS options - currently FORE only supports bandwidth ACE_OS::printf( "ATM_Client: specify cell rate at %d c/s\n", rate ); ACE_ATM_QoS qos; qos.set_rate(atm_stream.get_handle (), rate, ACE_ATM_QoS::OPT_FLAGS_CPID); if ( num_leaves == 1 ) { // Point-to-point connection // Not sure why but reuse_addr set to true/1 causes problems for // FORE/XTI/ATM - this is now handled in ACE_ATM_Connector::connect() ACE_OS::printf( "ATM_Client: to open a connection \n" ); ACE_ATM_Params params = ACE_ATM_Params(); if (con.connect (atm_stream, hosts[ 0 ], params, qos, (ACE_Time_Value *) &ACE_Time_Value::zero, local_addr, 0, 0 ) == -1) { if (errno != EWOULDBLOCK) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ATM_Client: connection failed"), 1); ACE_DEBUG ((LM_DEBUG, "ATM_Client: starting timed connection\n")); // Check if non-blocking connection is in progress, and wait up // to timeout seconds for it to complete. ACE_Time_Value tv (timeout); ACE_OS::printf( "ATM_Client: connection completed\n" ); if (con.complete (atm_stream, &hosts[ 0 ], &tv) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ATM_Client: connection failed"), 1); else ACE_DEBUG ((LM_DEBUG, "ATM_Client: connected to %s\n", hosts[ 0 ].addr_to_string())); } } else { // Point-to-multipoint connection for ( int i = 0; i < num_leaves; i++ ) { con.add_leaf( atm_stream, hosts[ i ], i, NULL ); } } /* if num_leaves == 1 */ ACE_UINT16 vpi, vci; atm_stream.get_vpi_vci(vpi, vci); ACE_DEBUG ((LM_DEBUG, "ATM_Client: connected to VPI %d VCI %d\n", vpi, vci)); // Send data to server (correctly handles "incomplete writes"). int s_bytes; int total; int xmit = 0; ACE_High_Res_Timer timer; ACE_Time_Value elapsed; double real_time; double actual_rate; for ( ;; ) { total = 0; timer.start_incr(); for ( ;; ) { s_bytes = atm_stream.send_n( buf, BUFSIZ, 0 ); if ( s_bytes == -1 ) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "send_n"), 1); total += s_bytes; if ( total >= session * pdu_size ) break; } timer.stop_incr(); timer.elapsed_time_incr( elapsed ); real_time = elapsed.sec() * ACE_ONE_SECOND_IN_USECS + elapsed.usec(); xmit += total; actual_rate = ( double )xmit * ( double )8 / real_time; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) bytes = %d, usec = %f, rate = %0.00f Mbps\n"), xmit, real_time, actual_rate < 0 ? 0 : actual_rate )); } // Explicitly close the connection. ACE_OS::printf( "ATM_Client: close connection\n" ); if (atm_stream.close () == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "close"), -1); return 0; }
void Consumer::handleMessage(const Miro::DevMessage * _message) { ++Connection::gotTicks_; if (pOdometry_) { const FaulController::OdometryMessage * pFaulMsg = static_cast<const FaulController::OdometryMessage *>(_message); if (pFaulMsg->wheel_ == FaulController::OdometryMessage::LEFT) { // cout << "L: " << pFaulMsg->ticks_; ticksL_ = pFaulMsg->ticks_; timeStampL_ = pFaulMsg->time(); } else { // cout << "R: " << pFaulMsg->ticks_; ticksR_ = pFaulMsg->ticks_; timeStampR_ = pFaulMsg->time(); } if (prevTimeStampL_+ ACE_Time_Value(0, 10000) < timeStampR_ && prevTimeStampR_+ ACE_Time_Value(0, 10000) < timeStampL_ && prevTimeStampL_ != timeStampL_ && prevTimeStampR_ != timeStampR_) { if (init_ == 0) { double dL = -(ticksL_ - prevTicksL_) / params_->leftTicksPerMM; double dR = (ticksR_ - prevTicksR_) / params_->rightTicksPerMM; // cout << "dL: " << dL << " dR: " << dR << endl; // reset tick counters to minimize overhead //if ((pFaulMsg->lPos < 3000) or (pFaulMsg->lPos > 10000) pConnection->setPos1(0); //if ((pFaulMsg->RPos < 3000) or (pFaulMsg->RPos > 10000) pConnection->setPos0(0); // calculate new orientation double turn = (dR - dL) / wheelBase_; status_.position.heading += turn; Miro::Angle::normalize(status_.position.heading); double dist = (dL + dR) / 2.; xPos_ += cos(status_.position.heading) * dist; yPos_ += sin(status_.position.heading) * dist; ACE_Time_Value timeDelta = timeStampR_ - prevTimeStampR_; double deltaT = (double)timeDelta.sec() + (double)timeDelta.usec() / 1000000.; // compose odometry message Miro::timeA2C(timeStampR_, status_.time); if (!Sparrow::Parameters::instance()->goalie) { status_.position.point.x = (long) xPos_; status_.position.point.y = (long) yPos_; } else { status_.position.point.x = (long) yPos_; status_.position.point.y = (long) -xPos_; } status_.velocity.translation = (long)(dist / deltaT); status_.velocity.rotation = turn / deltaT; //cout << status_.time.sec<< " " << status_.time.usec <<endl; //(dL+dR) / 2*dtime<< endl; // berechnung if (false) { ACE_Time_Value dTR = timeStampR_ - prevTimeStampR_; deltaTR[counter] = (double)dTR.sec() + (double)dTR.usec() / 1000000.; ACE_Time_Value dTL = timeStampL_ - prevTimeStampL_; deltaTL[counter] = (double)dTL.sec() + (double)dTL.usec()/ 1000000.; ACE_Time_Value dTLR = (timeStampL_ > timeStampR_)? timeStampL_ - timeStampR_ : timeStampR_ - timeStampL_; deltaTLR[counter] = (double)dTLR.sec() + (double)dTLR.usec()/ 1000000.; cout << "TimerOdo dTR: " << dTR << " \tdTL: " << dTL << " \tdTLR: " << dTLR << endl; int i; if (counter == 0) { double meanL = deltaTL[0]; double meanR = deltaTR[0]; double meanLR = deltaTLR[0]; for ( i = 49; i > 0; --i) { meanL += deltaTL[i]; meanR += deltaTR[i]; meanLR += deltaTLR[i]; } meanL /= 50.; meanR /= 50.; meanLR /= 50.; double varL = 0.; double varR = 0.; double varLR = 0.; for ( i = 49; i >= 0; --i) { varL += (deltaTL[i] - meanL) * (deltaTL[i] - meanL); varR += (deltaTR[i] - meanR) * (deltaTR[i] - meanR); varLR += (deltaTLR[i] - meanLR) * (deltaTLR[i] - meanLR); } varL /= 49.; varR /= 49.; varLR /= 49.; cout << "TimerOdo L: mean=" << meanL << "sec \t var=" <<sqrt(varL)<< endl; cout << "TimerOdo R: mean=" << meanR << "sec \t var=" <<sqrt(varR)<< endl; cout << "TimerOdo LR: mean=" << meanLR << "sec \t var=" <<sqrt(varLR)<< endl; counter = 50; } --counter; } // save current values for next iteration prevTimeStampL_ = timeStampL_; prevTimeStampR_ = timeStampR_; prevTicksL_ = ticksL_; prevTicksR_ = ticksR_; pOdometry_->integrateData(status_); return; } else { // save current values for next iteration prevTimeStampL_ = timeStampL_; prevTimeStampR_ = timeStampR_; prevTicksL_ = ticksL_; prevTicksR_ = ticksR_; --init_; } } } }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("High_Res_Timer_Test")); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("The ACE_High_Res_Timer scale factor is %u ") ACE_TEXT ("1/microsecond\n"), ACE_High_Res_Timer::global_scale_factor ())); u_int errors = 0; u_int iterations = 1; ACE_Get_Opt getoptarg (argc, argv, ACE_TEXT ("i:")); for (int c; (c = getoptarg ()) != -1; ) { switch (c) { case 'i': iterations = ACE_OS::atoi (getoptarg.opt_arg ()); break; } } // We don't check for errors if the interval is shorter than this // value because the OS has a finite resolution anyway. static u_int const TIMER_RESOLUTION = 10000; for (u_int i = 0; i < sizeof intervals / sizeof (u_int); ++i) { for (u_int j = 0; j < iterations; ++j) { ACE_Time_Value const interval (0, intervals[i]); ACE_hrtime_t nanoseconds; ACE_hrtime_t microseconds; ACE_Time_Value const measured = time_interval (interval, nanoseconds, microseconds); time_t const interval_usec = interval.sec () * ACE_ONE_SECOND_IN_USECS + interval.usec (); time_t const measured_usec = measured.sec () * ACE_ONE_SECOND_IN_USECS + measured.usec (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("interval: %: usec, measured: %: usec %s\n"), interval_usec, measured_usec, (intervals[i] <= TIMER_RESOLUTION ? ACE_TEXT (" (interval and measured may differ)") : ACE_TEXT ("")))); if (intervals[i] > TIMER_RESOLUTION) { errors += check (interval.sec () * ACE_ONE_SECOND_IN_USECS + interval.usec (), measured.sec () * ACE_ONE_SECOND_IN_USECS + measured.usec ()); // Don't check for error for intervals below 10 msec. } // Check the ACE_Timer_Value-calculated microseconds against // the ACE_High_Res_Timer-calculated nanoseconds. ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Time_Value usec: %:, ACE_HR nsec: %Q\n"), measured_usec, nanoseconds)); // This gives problems -> should be fixed errors += check_micro_nano (measured.sec () * ACE_ONE_SECOND_IN_USECS + measured.usec (), nanoseconds); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_High_Res_Timer usec: %Q, nsec: %Q\n"), microseconds, nanoseconds)); // Now check the ACE_High_Res_Timer-calculated values against // each other. errors += check_micro_nano (microseconds, nanoseconds); } } ACE_END_TEST; return errors == 0 ? 0 : 1; }
void Writer::start() { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Writer::start \n"))); try { OpenDDS::DCPS::DataReaderImpl* dr_servant = dynamic_cast<OpenDDS::DCPS::DataReaderImpl*>(reader_); ::Xyz::Foo foo; foo.x = 0.0; foo.y = 0.0; ::OpenDDS::DCPS::SequenceNumber seq; if (!multiple_instances_) { foo.key = default_key; } for (int i = 0; i < num_writes_per_thread_; ++i) { ++seq; foo.x = (float)i; foo.y = (float)i; if (multiple_instances_) { foo.key = i + 1; } ACE_Time_Value now = ACE_OS::gettimeofday(); ACE_OS::printf("\"writing\" foo.x = %f foo.y = %f, foo.key = %d\n", foo.x, foo.y, foo.key); OpenDDS::DCPS::ReceivedDataSample sample(0); sample.header_.message_length_ = sizeof(foo); sample.header_.message_id_ = OpenDDS::DCPS::SAMPLE_DATA; sample.header_.sequence_ = seq.getValue(); // RepoIds are conventionally created and managed by the DCPSInfoRepo. Those // generated here are for the sole purpose of verifying internal behavior. OpenDDS::DCPS::RepoIdBuilder builder(sample.header_.publication_id_); builder.participantId(1); builder.entityKey(1); builder.entityKind(OpenDDS::DCPS::ENTITYKIND_OPENDDS_NIL_WRITER); sample.header_.source_timestamp_sec_ = static_cast<ACE_INT32>(now.sec()); sample.header_.source_timestamp_nanosec_ = now.usec() * 1000; sample.sample_ = new ACE_Message_Block(sizeof(foo)); ::OpenDDS::DCPS::Serializer ser(sample.sample_); ser << foo; dr_servant->data_received(sample); } } catch (const CORBA::Exception& ex) { ex._tao_print_exception("Exception caught in svc:"); } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_Service_Config daemon; daemon.open (argv[0]); parse_args (argc, argv); if (child) { worker (n_iterations); ACE_OS::exit (exit_code); } ACE_DEBUG ((LM_DEBUG, "(%P|%t@%T) Process_Manager test. Expect output from" "2 or 3 processes...\n")); ACE_Process_Manager::instance ()->register_handler (new ExitHandler ("default")); pid_t pid1 = respawn_self (argv[0], n_iterations, 111); pid_t pid2 = respawn_self (argv[0], n_iterations + 500, 222); #if !defined (ACE_WIN32) pid_t pid3 = ACE_OS::fork (); if (!pid3) { worker (n_iterations); return 999; } #endif /* ACE_WIN32 */ ACE_Process_Manager::instance ()->register_handler (new ExitHandler ("specific"), pid2); if (pid1 == ACE_INVALID_PID || pid2 == ACE_INVALID_PID) ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) %p\n", "start_n"), 1); ACE_DEBUG ((LM_DEBUG, "(%P|%t@%T) Test parent waiting (synchronously, " "up to 6 seconds) for children...\n")); int result = ACE_Process_Manager::instance ()->wait (ACE_Time_Value (6)); ACE_DEBUG ((LM_DEBUG, "(%P|%t@%T) Test parent: %d processes left\n", result)); if (result > 0) { ACE_DEBUG ((LM_DEBUG, "(%P|%t@%T) Test parent waiting (synchronously, " "indefinitely) for remaining children...\n")); result = ACE_Process_Manager::instance ()->wait (); ACE_DEBUG ((LM_DEBUG, "(%P|%t@%T) Test parent finished waiting: %d\n", result)); } ACE_DEBUG ((LM_DEBUG, "(%P|%t@%T) Test parent: try auto-reap functions\n")); ACE_Process_Manager::instance ()->open (ACE_Process_Manager::DEFAULT_SIZE, ACE_Reactor::instance ()); pid1 = respawn_self (argv[0], n_iterations + 200, 333 ); pid2 = respawn_self (argv[0], n_iterations + 500, 444); #if !defined (ACE_WIN32) pid3 = ACE_OS::fork (); if (!pid3) { worker (n_iterations); return 888; } #endif /* ACE_WIN32 */ ExitHandler *main_thread_work = 0; ACE_NEW_RETURN (main_thread_work, ExitHandler ("main thread worker"), 1); ACE_Reactor::instance ()->schedule_timer (main_thread_work, 0, ACE_Time_Value (2), ACE_Time_Value (1, 500000)); ACE_DEBUG ((LM_DEBUG, "(%P|%t@%T) Test parent: expect several Processes " "to be auto-detected over the next 30 seconds.\n" "The main thread will do some other work, too.\n" )); ACE_Time_Value briefly (30); result = ACE_Reactor::run_event_loop (briefly); ACE_DEBUG ((LM_DEBUG, "(%P|%t@%T) Test parent: finished (%d) %d.%d. Close" "Process_Manager...\n", result, briefly.sec (), briefly.usec ())); ACE_Process_Manager::instance ()->close (); return 0; }
int Client::svc (void) { try { Octet_Seq octetSeq(SIZE_BLOCK); Char_Seq charSeq(SIZE_BLOCK); ACE_High_Res_Timer timer; ACE_OS::printf("Start sending %d Msgs...\n",this->niterations_); charSeq.length(SIZE_BLOCK); octetSeq.length(SIZE_BLOCK); // This sets up the connector, so that we do not incur // the overhead on the first call in the loop. server_->sendCharSeq (charSeq); timer.start (); ACE_UINT32 client_count = 0; for (ACE_UINT32 i = 0; i < this->niterations_; ++i) { client_count++; server_->sendCharSeq (charSeq); //server_->sendOctetSeq (octetSeq); //ACE_DEBUG ((LM_DEBUG, ".")); } timer.stop (); ACE_Time_Value measured; timer.elapsed_time (measured); //ACE_DEBUG ((LM_DEBUG, "...finished\n")); time_t dur = measured.sec () * 1000000 + measured.usec (); if (dur == 0 || this->niterations_ == 0) ACE_DEBUG ((LM_DEBUG, "Time not measurable, calculation skipped\n")); else { ACE_DEBUG ((LM_DEBUG, "Time for %u Msgs: %u usec\n", this->niterations_, dur)); ACE_DEBUG ((LM_DEBUG, "Time for 1 Msg: %u usec, %u calls/sec\n", dur / this->niterations_, 1000000 / (dur / this->niterations_))); } for (int c = 0; c < 10; ++c) server_->shutdown (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("MT_Client: exception raised"); } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int n = 100; int low = 64; int hi = 4096; int s = 4; int quiet = 0; ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("dn:l:h:s:q")); int opt; while ((opt = get_opt ()) != EOF) { switch (opt) { case 'd': TAO_debug_level++; break; case 'n': n = ACE_OS::atoi (get_opt.opt_arg ()); break; case 'l': low = ACE_OS::atoi (get_opt.opt_arg ()); break; case 'h': hi = ACE_OS::atoi (get_opt.opt_arg ()); break; case 's': s = ACE_OS::atoi (get_opt.opt_arg ()); break; case 'q': quiet = 1; break; case '?': default: ACE_DEBUG ((LM_DEBUG, "Usage: %s " "-d debug" "-l low " "-h high " "-s step " "-n n " "\n" "Writes and then reads longs to a CDR stream " "starting from <low> up to <high> incrementing " "by <step>, at each step run <n> iterations to " "average." "\n", argv[0])); return -1; } } for (int x = low; x <= hi; x += s) { ACE_High_Res_Timer writing; ACE_High_Res_Timer reading; if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "\nx= %d\n", x)); for (int i = 0; i < n; ++i) { writing.start_incr (); TAO_OutputCDR output; if (test_write (output, x) != 0) { return 1; } writing.stop_incr (); reading.start_incr (); TAO_InputCDR input (output); if (test_read (input, x) != 0) { return 1; } reading.stop_incr (); } double m = n * x; ACE_Time_Value wtv; writing.elapsed_time_incr (wtv); ACE_hrtime_t wusecs = wtv.sec (); wusecs *= static_cast<ACE_UINT32> (ACE_ONE_SECOND_IN_USECS); wusecs += wtv.usec (); ACE_Time_Value rtv; reading.elapsed_time_incr (rtv); ACE_hrtime_t rusecs = rtv.sec (); rusecs *= static_cast<ACE_UINT32> (ACE_ONE_SECOND_IN_USECS); rusecs += rtv.usec (); double write_average = ACE_HRTIME_CONVERSION(wusecs) / m; double read_average = ACE_HRTIME_CONVERSION(rusecs) / m; if (!quiet) ACE_OS::printf ("AVE: %d %f %f\n", x, write_average, read_average); } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT); //unsigned char selector = ACE_ATM_Addr::DEFAULT_SELECTOR; //int selector_specified = 0; if (argc > 2) ACE_ERROR_RETURN ((LM_ERROR, "Usage: %s [selector]\n", argv[0]), 1); // Create a server address. ACE_ATM_Addr addr; //if (selector_specified) unsigned char selector = ( argc == 2 ) ? ACE_OS::atoi( argv[ 1 ]) : ACE_ATM_Addr::DEFAULT_SELECTOR; addr.set_selector( selector ); ACE_OS::printf( "ATM_Server: selector changed to %d\n", addr.get_selector()); // Create a server, reuse the addr. ACE_ATM_Acceptor peer_acceptor; ACE_ATM_Params params; // Not sure why but reuse_addr set to true/1 causes problems for // FORE/XTI/ATM - this is now handled in ACE_ATM_Acceptor::open() ACE_HANDLE ret = peer_acceptor.open (addr, 5, params); if ( ret == ACE_INVALID_HANDLE ) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open"), -1); ACE_ATM_Stream new_stream; ACE_ATM_Addr local_addr; local_addr.set_selector( selector ); peer_acceptor.get_local_addr( local_addr ); ACE_DEBUG ((LM_DEBUG, "starting server at address %s\n", local_addr.addr_to_string ())); // Performs the iterative server activities char buf[BUFSIZ]; ACE_High_Res_Timer timer; int total; ACE_Time_Value tv; double real_time; double actual_rate; for (;;) { // Create a new ACE_ATM_Stream endpoint (note automatic restart // if errno == EINTR). ACE_OS::printf( "ATM_Server: expecting clients\n" ); if (peer_acceptor.accept (new_stream, &addr, &timeout) == -1) { ACE_ERROR ((LM_ERROR, "%p\n", "accept")); continue; } ACE_OS::printf( "ATM_Server: got a connection\n" ); ACE_UINT16 vpi, vci; vpi = vci = 0; // This has problem on PMP connections on NT //new_stream.get_vpi_vci(vpi, vci); ACE_DEBUG ((LM_DEBUG, "connected to VPI %d VCI %d\n", vpi, vci)); ACE_OS::printf( "ATM_Server: connection accepted\n" ); ACE_DEBUG ((LM_DEBUG, "client %s connected\n", addr.addr_to_string ())); ACE_DEBUG ((LM_DEBUG, "client %s connected to host\n", new_stream.get_peer_name ())); // Read data from client (terminate on error). int recvd = 0; for ( ;; ) { total = 0; timer.start_incr(); for (int r_bytes; (r_bytes = new_stream.recv (buf, sizeof buf, 0)) > 0; ) { // ACE_OS::printf( "ATM_Server: received %dB\n", r_bytes ); // if (ACE_OS::write (ACE_STDOUT, // buf, // r_bytes) != r_bytes) // ACE_ERROR ((LM_ERROR, // "%p\n", // "ACE::send_n")); total += r_bytes; if ( total > 10000000 ) break; } timer.stop_incr(); timer.elapsed_time_incr( tv ); real_time = tv.sec() * ACE_ONE_SECOND_IN_USECS + tv.usec(); recvd += total; actual_rate = ( double )recvd * ( double )8 / real_time; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) bytes = %d, usec = %f, rate = %0.00f Mbps\n"), recvd, real_time, actual_rate < 0 ? 0 : actual_rate )); } // Close new endpoint (listening endpoint stays open). if (new_stream.close () == -1) ACE_ERROR ((LM_ERROR, "%p\n", "close")); } /* NOTREACHED */ return 0; }
int Timer_Helper::handle_timeout (const ACE_Time_Value &, const void *) { int no_of_servers = 0; CORBA::ULongLong sum = 0; // The following are used to keep a track of the inaccuracy // in synchronization. CORBA::ULongLong lowest_time = ACE_UINT64_LITERAL (0xFFFFFFFFFFFFFFFF); CORBA::ULongLong highest_time = 0; try { IORS::TYPE* value; for (IORS::ITERATOR server_iterator (this->clerk_->server_); server_iterator.next (value) != 0; server_iterator.advance ()) { // This is a remote call. CosTime::UTO_var UTO_server = (*value)->universal_time (); if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG, "\nTime = %Q\nInaccuracy = %Q\nTimeDiff = %d\nstruct.time = %Q\n" "struct.inacclo = %d\nstruct.inacchi = %d\nstruct.Tdf = %d\n", UTO_server->time (), UTO_server->inaccuracy (), UTO_server->tdf (), (UTO_server->utc_time ()).time, (UTO_server->utc_time ()).inacclo, (UTO_server->utc_time ()).inacchi, (UTO_server->utc_time ()).tdf)); CORBA::ULongLong curr_server_time = UTO_server->time (); sum += curr_server_time; ++no_of_servers; // Set the highest time to the largest time seen so far. if (curr_server_time > highest_time) highest_time = curr_server_time; // Set the lowest time to the smallest time seen so far. if (curr_server_time < lowest_time) lowest_time = curr_server_time; } if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG, "\nUpdated time from %d servers in the network", no_of_servers)); // Return the average of the times retrieved from the various // servers. clerk_->time_ = sum / no_of_servers ; // Set the Time Displacement Factor. The TZ environment variable is // read to set the time zone. We convert the timezone value from seconds // to minutes. ACE_OS::tzset (); long arg = ACE_OS::timezone () / 60; CORBA::Short goodarg = static_cast<CORBA::Short> (arg); clerk_->time_displacement_factor (goodarg); // Set the inaccuracy. if (highest_time > lowest_time) clerk_->inaccuracy (highest_time - lowest_time); else clerk_->inaccuracy (0); const ACE_Time_Value timeofday = ACE_OS::gettimeofday (); // Record the current time in a timestamp to know when global // updation of time was done. clerk_->update_timestamp_ = static_cast<CORBA::ULongLong> (timeofday.sec ()) * static_cast<ACE_UINT32> (10000000) + static_cast<CORBA::ULongLong> (timeofday.usec () * 10); } catch (const CORBA::Exception& ex) { if (TAO_debug_level > 0) ex._tao_print_exception ("Exception in handle_timeout()\n"); return -1; } return 0; }
// reads incoming packets from the canBus connection and stores the values // in the local (class internal) variables. void Consumer::handleMessage(const Miro::DevMessage * _message) { const Can::Message& message = *((Can::Message*)_message); int versNr, versSub; connection->boardReply = 1; Can::Parameters *CanParams = new Can::Parameters(); CanId msgID = message.id(); if (CanParams->module == "pcan") msgID = (msgID | 0x80000000); switch (msgID) { // Motor Messages case CAN_R_MOTOR_ALIVE: { MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: MOTOR_ALIVE"); versSub = message.shortData(0); versNr = versSub >> 4; versSub = versSub & 0x0F; // versNr loeschen mit AND 00001111 MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "MOTOR_ALIVE_VERSION: "<< versNr << "." << versSub); MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "MOTOR_TIME_STAMP (sec): " << message.shortData(2)); Miro::Guard guard(motorAliveMutex); motorAliveCond.broadcast(); break; } case CAN_R_GET_ACCELS: MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: GET_ACCELS"); // Odometry Messages case CAN_R_GET_POS: if (pOdometry_) { // get data xPos_ = message.shortData(0); yPos_ = message.shortData(2); phi_ = ticks2rad(message.shortData(4)); // the goalie is special if (params_->goalie) { std::swap(xPos_, yPos_); yPos_ *= -1; xPos_ += (short)(125 * cos(phi_) + 85 * sin(phi_)); yPos_ += (short)(125 * sin(phi_) - 85 * cos(phi_)); } double dx = (short)(xPos_ - xPrev_); double dy = (short)(yPos_ - yPrev_); x_ += dx; y_ += dy; double dPhi = phi_ - phiPrev_; xPrev_ = xPos_; yPrev_ = yPos_; phiPrev_ = phi_; // fill motion status data struct double deltaT = 1000. / (double) (params_->odometryPulse.msec()); Miro::timeA2C(message.time(), status_.time); status_.position.point.x = x_ * params_->transFactor; status_.position.point.y = y_ * params_->transFactor; status_.position.heading = phi_; status_.velocity.translation = (long) rint(sqrt(dx * dx + dy * dy) * deltaT); status_.velocity.rotation = dPhi * deltaT; pOdometry_->integrateData(status_); break; } case 0x82820201: { // DISTANCE LR MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: DISTANCE LR " << message.shortData(0) << " " << message.shortData(2)); Miro::Guard guard(distanceLRMutex); distanceL = message.shortData(0); distanceR = message.shortData(2); distanceLRCond.broadcast(); break; } case CAN_R_ODO_ALIVE: { MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: ODO_ALIVE"); versSub = message.shortData(0); versNr = versSub >> 4; versSub = versSub & 0x0F; // versNr loeschen mit AND 00001111 MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "ODO_ALIVE_VERSION: "<< versNr << "." << versSub); MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "ODO_TIME_STAMP (sec): " << message.shortData(2)); Miro::Guard guard(odoAliveMutex); odoAliveCond.broadcast(); break; } // Port Messages case CAN_R_READ_PORTS: { // DIGITAL MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: DIGITAL "); Miro::Guard guard(digitalMutex); for (int i = 1; i >= 0; --i) { if ( ((message.byteData(1) ^ digital[1]) & (0x01 << i)) && pButtons_) { ACE_Time_Value t = ACE_OS::gettimeofday(); ButtonStatusIDL * pEvent = new ButtonStatusIDL(); pEvent->time.usec = t.usec(); pEvent->time.sec = t.sec(); pEvent->number = i; pEvent->event = (message.byteData(1) & (0x01 << i))? Miro::Button::ON_RELEASE : Miro::Button::ON_PRESS; pButtons_->pushEvent(pEvent); } } for (int i = 7; i >= 0; --i) { digital[i] = message.byteData(i); } digitalCond.broadcast(); break; } case CAN_R_READ_ANALOG: { MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: ANALOG " << message.shortData(0) << " " << message.shortData(2)); Miro::Guard guard(analogMutex); analog[message.shortData(0)]= message.shortData(2); analogCond.broadcast(); break; } case CAN_R_PORTS_ALIVE: { MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: PORTS_ALIVE"); versSub = message.shortData(0); versNr = versSub >> 4; versSub = versSub & 0x0F; // versNr loeschen mit AND 00001111 MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "PORTS_ALIVE_VERSION: "<< versNr << "." << versSub); MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "PORTS_TIME_STAMP (sec): " << message.shortData(2)); Miro::Guard guard(portsAliveMutex); portsAliveCond.broadcast(); break; } // Stall Messages case CAN_R_STALL: connection->stallTimerStart(); if (pStall_) pStall_->pushEvent(); break; case CAN_R_STALL_ALIVE: { MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: STALL_ALIVE"); versSub = message.shortData(0); versNr = versSub >> 4; versSub = versSub & 0x0F; // versNr loeschen mit AND 00001111 MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "STALL_ALIVE_VERSION: "<< versNr << "." << versSub); MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "STALL_TIME_STAMP (sec): " << message.shortData(2)); Miro::Guard guard(stallAliveMutex); stallAliveCond.broadcast(); break; } // Kicker Messages case CAN_R_KICK_ALIVE: { MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: KICK_ALIVE"); versSub = message.shortData(0); versNr = versSub >> 4; versSub = versSub & 0x0F; // versNr loeschen mit AND 00001111 MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "KICK_ALIVE_VERSION: "<< versNr << "." << versSub); MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "KICK_TIME_STAMP (sec): " << message.shortData(2)); Miro::Guard guard(kickerAliveMutex); kickerAliveCond.broadcast(); break; } // Servo Messages case CAN_R_SERVO_ALIVE: { MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: SERVO_ALIVE"); versSub = message.shortData(0); versNr = versSub >> 4; versSub = versSub & 0x0F; // versNr loeschen mit AND 00001111 MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "SERVO_ALIVE_VERSION: "<< versNr << "." << versSub); MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "SERVO_TIME_STAMP (sec): " << message.shortData(2)); Miro::Guard guard(servoAliveMutex); servoAliveCond.broadcast(); break; } // Infrared Messages: case CAN_R_IR_GET_CONT: MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: receiveThread message: IR_CONT"); if (pIR_) { Sparrow::Parameters * param = Sparrow::Parameters::instance(); //uli long calRange; Miro::RangeGroupEventIDL * data = new Miro::RangeGroupEventIDL(); Miro::timeA2C(message.time(), data->time); data->group = 0; data->range.length(8); for (int i = 7; i >= 0; --i) { if (message.charData(i) != -1) { calRange = ((int)message.charData(i) * 10 - param->irScaling[i].offset); calRange = calRange - param->irScaling[i].minDistance; calRange = (long) (calRange * param->irScaling[i].scaling); calRange = calRange + param->irScaling[i].minDistance ; if ((calRange < param->irScaling[i].minDistance) || (calRange > param->irScaling[i].maxDistance)) { calRange = -1; } } else { calRange = -1; } data->range[i] = calRange; } pIR_->integrateData(data); } break; case CAN_R_IR_ALIVE: { MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: IR_ALIVE"); versSub = message.shortData(0); versNr = versSub >> 4; versSub = versSub & 0x0F; // versNr loeschen mit AND 00001111 MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "IR_ALIVE_VERSION: "<< versNr << "." << versSub); MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "IR_TIME_STAMP (sec): " << message.shortData(2)); Miro::Guard guard(irAliveMutex); irAliveCond.broadcast(); break; } // Debug Messages case CAN_R_DBG_PRINT: for (int k = 0; k < std::min(message.length(), 8); ++k) //if (message.canMessage()->d[k] != 0) // cout << message.canMessage()->d[k] << flush; break; case CAN_R_DBG_ALIVE: { MIRO_DBG(SPARROW, LL_PRATTLE, "Consumer::receiveThread: received message: DBG_ALIVE"); versSub = message.shortData(0); versNr = versSub >> 4; versSub = versSub & 0x0F; // versNr loeschen mit AND 00001111 MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "DBG_ALIVE_VERSION: "<< versNr << "." << versSub); MIRO_DBG_OSTR(SPARROW, LL_PRATTLE, "DBG_TIME_STAMP (sec): " << message.shortData(2)); Miro::Guard guard(dbgAliveMutex); dbgAliveCond.broadcast(); break; } default: MIRO_LOG_OSTR(LL_ERROR, "SparrowConsumer: Unhandled can bus message: " << message); } }
int run_domain_test () { ::DDS::ReturnCode_t ret; // create participant ::DDS::DomainParticipant_var new_dp = dpf->create_participant(MY_DOMAIN, PARTICIPANT_QOS_DEFAULT, ::DDS::DomainParticipantListener::_nil (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); TEST_CHECK (! CORBA::is_nil (new_dp.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(! CORBA::is_nil (new_dp.in ()))") ACE_TEXT("\n") )); ::DDS::DomainId_t domain_id = new_dp->get_domain_id (); TEST_CHECK (domain_id == MY_DOMAIN); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(domain_id == MY_DOMAIN)") ACE_TEXT("\n") )); MyTypeSupport_var fts (new MyTypeSupportImpl); if (::DDS::RETCODE_OK != fts->register_type(new_dp.in (), MY_TYPE)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to register the FooTypeSupport."))); return 1; } // lookup existent participant ::DDS::DomainParticipant_var looked_dp = dpf->lookup_participant(MY_DOMAIN); OpenDDS::DCPS::DomainParticipantImpl* new_dp_servant = dynamic_cast<OpenDDS::DCPS::DomainParticipantImpl*>(new_dp.in()); OpenDDS::DCPS::DomainParticipantImpl* looked_dp_servant = dynamic_cast<OpenDDS::DCPS::DomainParticipantImpl*>(looked_dp.in ()); TEST_CHECK (looked_dp_servant == new_dp_servant); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(looked_dp_servant == new_dp_servant)") ACE_TEXT("\n") )); // create topic ::DDS::Topic_var new_topic = new_dp->create_topic(MY_TOPIC, MY_TYPE, TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); OpenDDS::DCPS::TopicImpl* new_topic_servant = dynamic_cast<OpenDDS::DCPS::TopicImpl*>(new_topic.in ()); ::DDS::Duration_t timeout; timeout.sec = static_cast<long>(find_topic_timeout.sec ()); timeout.nanosec = find_topic_timeout.usec (); // find existent topic ::DDS::Topic_var found_topic = new_dp->find_topic(MY_TOPIC, timeout); ::OpenDDS::DCPS::TopicImpl* found_topic_servant = dynamic_cast<OpenDDS::DCPS::TopicImpl*> (found_topic.in ()); TEST_CHECK (new_topic_servant == found_topic_servant); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(new_topic_servant == found_topic_servant)") ACE_TEXT("\n") )); // find existent topicdescription ::DDS::TopicDescription_var found_topicdescription = new_dp->lookup_topicdescription(MY_TOPIC); TEST_CHECK (! CORBA::is_nil (found_topicdescription.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(! CORBA::is_nil (found_topicdescription.in ()))") ACE_TEXT("\n") )); // widen the topicdescription to topic ::DDS::Topic_var widened_topic = ::DDS::Topic::_narrow(found_topicdescription.in ()); TEST_CHECK (! CORBA::is_nil (widened_topic.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(! CORBA::is_nil (widened_topic.in ()))") ACE_TEXT("\n") )); ACE_ERROR((LM_ERROR, "We expect to see an error message from delete_participant\n")); ret = dpf->delete_participant(new_dp.in ()); TEST_CHECK (ret == ::DDS::RETCODE_PRECONDITION_NOT_MET); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_PRECONDITION_NOT_MET)") ACE_TEXT("\n") )); // delete existent topic first time ret = new_dp->delete_topic(found_topic.in ()); TEST_CHECK (ret == ::DDS::RETCODE_OK); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_OK)") ACE_TEXT("\n") )); // delete existent topic second time ret = new_dp->delete_topic(new_topic.in ()); TEST_CHECK (ret == ::DDS::RETCODE_OK); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_OK)") ACE_TEXT("\n") )); // an extra delete existent topic ACE_ERROR((LM_ERROR, "We expect to see an error message from delete_topic\n")); ret = new_dp->delete_topic(new_topic.in ()); TEST_CHECK (ret == ::DDS::RETCODE_ERROR); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_ERROR)") ACE_TEXT("\n") )); // Look up the topicdescription after the topic is deleted will // return nil. found_topicdescription = new_dp->lookup_topicdescription(MY_TOPIC); TEST_CHECK (CORBA::is_nil(found_topicdescription.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(CORBA::is_nil(found_topicdescription.in ()))") ACE_TEXT("\n") )); // find a non-existent topic - return nil ACE_High_Res_Timer timer; ACE_Time_Value elapsedTime(0, 0); timer.start (); found_topic = new_dp->find_topic(OTHER_TOPIC, timeout); timer.stop(); timer.elapsed_time(elapsedTime); ACE_Time_Value tenMillis (0, 10000); elapsedTime += tenMillis; // some systems can be short by up to 10 milliseconds ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(CORBA::is_nil(found_topic.in ()) && elapsedTime.msec() >= find_topic_timeout.msec())") ACE_TEXT("\n") )); // delete the existent participant ret = dpf->delete_participant(new_dp.in ()); TEST_CHECK (ret == ::DDS::RETCODE_OK); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_OK)") ACE_TEXT("\n") )); // lookup the participant after it's deleted - return nil looked_dp = dpf->lookup_participant(MY_DOMAIN); TEST_CHECK (CORBA::is_nil(looked_dp.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(CORBA::is_nil(looked_dp.in ()))") ACE_TEXT("\n") )); return 0; }
int TAO_AV_RTP_Object::send_frame (const iovec *iov, int iovcnt, TAO_AV_frame_info *frame_info) { int result = -1; RTP_Packet *rtp_packet = 0; ACE_UINT32 csrc_count = 0; // Assume for now no mixers/translators ACE_UINT32 *csrc_list = 0; if (this->connection_gone_) { errno = ECONNRESET; return -1; } if (frame_info != 0) { if (frame_info->format != this->format_) ORBSVCS_DEBUG ((LM_DEBUG, "TAO_AV_RTP_Object::send_frame - error: format type mismatch")); this->sequence_num_ = static_cast<ACE_UINT16> (frame_info->sequence_num); if (frame_info->ssrc != 0) this->ssrc_ = frame_info->ssrc; TAO_AV_RTCP_Object *rtcp_prot_obj = dynamic_cast<TAO_AV_RTCP_Object*> (this->control_object_); // set the ssrc on the control object so the RTCP traffic can be matched // to the RTP traffic rtcp_prot_obj->ssrc(this->ssrc_); ACE_UINT16 data_size = static_cast<ACE_UINT16> (iov[0].iov_len); ACE_NEW_RETURN (rtp_packet, RTP_Packet (0, // padding frame_info->boundary_marker, // marker static_cast<unsigned char> (this->format_), // payload type frame_info->sequence_num, // sequence num frame_info->timestamp, // time stamp this->ssrc_, // ssrc static_cast<unsigned char> (csrc_count), // csrc count csrc_list, // csrc list (char *)iov[0].iov_base, // data data_size), // data size -1); frame_info->sequence_num ++; } else { // TODO: For periodic RTP packets (constant rate), the RFC suggests // increasing the clock by the number of samples each frame rather // than relying on the system time // The RFC specifies at least one timestamp unit per sample as well as a // random offset. It used to be in milliseconds so I left it that way // for non-audio streams. unsigned int samples_per_sec; double samples_per_usec; switch (this->format_) { case RTP_PT_PCMU: case RTP_PT_CELP: case RTP_PT_G721: case RTP_PT_GSM: case RTP_PT_DVI: case RTP_PT_LPC: case RTP_PT_PCMA: case RTP_PT_G722: samples_per_sec = 8000; break; case RTP_PT_L16_STEREO: case RTP_PT_L16_MONO: samples_per_sec = 44100; break; default: samples_per_sec = 1000000; }; samples_per_usec = samples_per_sec/1000000.0; ACE_Time_Value now = ACE_OS::gettimeofday(); ACE_UINT32 ts = (ACE_UINT32) (now.sec () * samples_per_sec + ((double)now.usec () * samples_per_usec) + this->timestamp_offset_); ACE_UINT16 data_size = static_cast<ACE_UINT16> (iov[0].iov_len); ACE_NEW_RETURN (rtp_packet, RTP_Packet (0, // padding 0, // marker static_cast<unsigned char> (this->format_), // payload type this->sequence_num_, // sequence num ts, // time stamp this->ssrc_, // ssrc static_cast<unsigned char> (csrc_count), // csrc count csrc_list, // csrc list (char *)iov[0].iov_base, // data data_size), // data size -1); this->sequence_num_ ++; } char *data_ptr; ACE_UINT16 data_length; rtp_packet->get_packet_data (&data_ptr, data_length); iovec send_iov[ACE_IOV_MAX]; send_iov [0].iov_base = data_ptr; send_iov [0].iov_len = data_length; for (int i=1;i<iovcnt; i++) send_iov [i] = iov [i]; result = this->transport_->send (send_iov, iovcnt); delete rtp_packet; if (result < 0) ORBSVCS_ERROR_RETURN ((LM_ERROR,"TAO_AV_RTP::send_frame failed\n"),result); return 0; }
static int run_test (int disable_notify_pipe, const ACE_Time_Value &tv) { // Create special reactors with the appropriate flags enabled. ACE_Select_Reactor *reactor_impl = 0; if (disable_notify_pipe) ACE_NEW_RETURN (reactor_impl, ACE_Select_Reactor (0, 0, 1), -1); else ACE_NEW_RETURN (reactor_impl, ACE_Select_Reactor, -1); ACE_Reactor *reactor; ACE_NEW_RETURN (reactor, ACE_Reactor (reactor_impl, 1), // Delete implementation -1); // Make sure this stuff gets cleaned up when this function exits. auto_ptr<ACE_Reactor> r (reactor); // Set the Singleton Reactor. ACE_Reactor *orig_reactor = ACE_Reactor::instance (reactor); ACE_TEST_ASSERT (ACE_LOG_MSG->op_status () != -1); ACE_TEST_ASSERT (ACE_Reactor::instance () == reactor); Supplier_Task task (disable_notify_pipe, tv); ACE_TEST_ASSERT (ACE_LOG_MSG->op_status () != -1); int result; result = task.open (); ACE_TEST_ASSERT (result != -1); if (tv.sec () == LONG_TIMEOUT) // Sleep for a while so that the <ACE_Reactor>'s notification // buffers will fill up! ACE_OS::sleep (tv); int shutdown = 0; // Run the event loop that handles the <handle_output> and // <handle_exception> notifications. for (int iteration = 1; shutdown == 0; iteration++) { ACE_Time_Value timeout (tv); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) starting handle_events() on iteration %d") ACE_TEXT (" with time-out = %d seconds\n"), iteration, timeout.sec ())); // Use a timeout to inform the Reactor when to shutdown. switch (ACE_Reactor::instance ()->handle_events (timeout)) { case -1: if (! disable_notify_pipe) ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%t) %p\n"), ACE_TEXT ("reactor"))); shutdown = 1; break; /* NOTREACHED */ case 0: ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) handle_events timed out\n"))); shutdown = 1; break; /* NOTREACHED */ default: break; /* NOTREACHED */ } } if (tv.sec () == LONG_TIMEOUT) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) releasing supplier task thread\n"))); task.release (); } ACE_Reactor::instance (orig_reactor); return 0; }
inline RtecScheduler::Period_t time_val_to_period (const ACE_Time_Value &tv) { //100s of nanoseconds return static_cast<RtecScheduler::Period_t> (tv.sec () * 1000000 + tv.usec ())*10; }
bool XML_Saver::open(const ACE_TString & base_name, size_t backup_count) { this->base_name_ = base_name; this->backup_count_ = backup_count; if (base_name == ACE_TEXT("cout")) { this->output_ = stdout; this->close_out_ = false; } else if (base_name == ACE_TEXT("cerr")) { this->output_ = stderr; this->close_out_ = false; } else { ACE_TString file_name = base_name; file_name += ACE_TEXT(".new"); this->output_ = ACE_OS::fopen (file_name.c_str(), ACE_TEXT("wb")); if (this->output_) { this->close_out_ = true; } else { ORBSVCS_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) XML_Saver unable to open %s\n"), base_name.c_str())); } } if (this->output_ != 0) { FILE * const out = this->output_; ACE_OS::fprintf (out, "<?xml version=\"1.0\"?>\n"); try { bool changed = true; NVPList attrs; ACE_Time_Value const now = ACE_High_Res_Timer::gettimeofday(); ACE_UINT64 nowus = now.usec(); static const ACE_UINT64 USECSPERSEC = 1000 * 1000; ACE_UINT64 const tmpus = now.sec(); nowus += tmpus * USECSPERSEC; ACE_TCHAR nowusstr[128]; ACE_OS::sprintf(nowusstr, ACE_UINT64_FORMAT_SPECIFIER, nowus); attrs.push_back(NVP("version", "1.0")); if (this->timestamp_) { attrs.push_back(NVP("timestamp", ACE_TEXT_ALWAYS_CHAR(nowusstr))); } this->begin_object(0, "notification_service", attrs, changed); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( ACE_TEXT ( "(%P|%t) XML_Saver Unknown exception\n")); if (this->close_out_ && this->output_ != 0) { (void) ACE_OS::fclose (this->output_); } this->output_ = 0; } } return this->output_ != 0; }