/// send a data frame. int TimeStamp_Protocol_Object::send_frame (ACE_Message_Block *frame, TAO_AV_frame_info *) { ACE_DEBUG ((LM_DEBUG, "TimeStamp_Protocol_Object::send_frame\n")); ACE_Message_Block* timestamp; ACE_NEW_RETURN (timestamp, ACE_Message_Block (BUFSIZ), -1); ACE_hrtime_t now = ACE_OS::gethrtime (); ACE_UINT64 usec = now; ACE_UINT32 val_1 = ACE_CU64_TO_CU32 (usec); ACE_DEBUG ((LM_DEBUG, "Time Stamp %u usecs\n", val_1)); ACE_OS_String::memcpy (timestamp->wr_ptr (), &now, sizeof (now)); timestamp->wr_ptr (sizeof (now)); frame->cont (timestamp); ssize_t result = this->transport_->send (frame); if (result < 0) return result; return 0; }
void Task_Stats::dump_samples ( const ACE_TCHAR *file_name, const ACE_TCHAR *msg, ACE_High_Res_Timer::global_scale_factor_type scale_factor) { FILE* output_file = ACE_OS::fopen (file_name, "w"); // first dump what the caller has to say. ACE_OS::fprintf (output_file, "%s\n", ACE_TEXT_ALWAYS_CHAR (msg)); // next, compose and dump what we want to say. // calc throughput. ACE_TCHAR out_msg[BUFSIZ]; ACE_hrtime_t elapsed_microseconds = (end_time_ - base_time_) / scale_factor; double elapsed_seconds = ACE_CU64_TO_CU32(elapsed_microseconds) / 1000000.0; double throughput = double(samples_count_) / elapsed_seconds; ACE_OS::sprintf (out_msg, ACE_TEXT("#Throughtput: %f\n"), throughput); ACE_OS::fprintf (output_file, ACE_TEXT("%s\n"),out_msg); // dump latency stats. this->dump_latency_stats (out_msg, scale_factor); ACE_OS::fprintf (output_file, "%s\n", ACE_TEXT_ALWAYS_CHAR (out_msg)); ACE_OS::fprintf (output_file, "#Invocation time \t Execution time\n"); // dump the samples recorded. for (size_t i = 0; i != this->samples_count_; ++i) { ACE_UINT64 x = this->time_inv_[i] / scale_factor; ACE_UINT32 val_1 = ACE_CU64_TO_CU32 (x); ACE_UINT64 y = this->time_exec_[i] / scale_factor; ACE_UINT32 val_2 = ACE_CU64_TO_CU32 (y); ACE_OS::fprintf (output_file, "%u \t %u\n",val_1, val_2); } ACE_OS::fclose (output_file); }
/////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // function per_iteration /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Given an elapsed time in nanoseconds, returns the time per iteration // in microseconds. static inline double per_iteration (const ACE_hrtime_t elapsed /* nanoseconds */) { double ms_per_iteration = (double) ACE_CU64_TO_CU32 (elapsed) / 1000.0 / (double) iterations; // Don't print out "-0.000" or "-0.001" . . . return -0.002 < ms_per_iteration && ms_per_iteration < 0.0 ? 0.0 : ms_per_iteration; }
void Receiver_Stats::dump_results (const ACE_TCHAR *msg, FILE *file, ACE_UINT32 sf) const { if (this->samples_count () == 0u) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%s : no data collected\n"), msg)); return; } ACE_UINT64 avg = this->sum_ / this->samples_count_; ACE_UINT64 dev = this->sum2_ / this->samples_count_ - avg * avg; double l_min = ACE_CU64_TO_CU32 (this->min_) / sf; double l_max = ACE_CU64_TO_CU32 (this->max_) / sf; double l_avg = ACE_CU64_TO_CU32 (avg) / sf; double l_dev = ACE_CU64_TO_CU32 (dev) / (sf * sf); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%s latency : %.2f[%d]/%.2f/%.2f[%d]/%.2f (min/avg/max/var^2)\n"), msg, l_min, this->min_at_, l_avg, l_max, this->max_at_, l_dev)); ACE_OS::fprintf (file, ACE_TEXT ("Inter Frame Arrival Time Statistics in msecs : %.2f[%d]/%.2f/%.2f[%d]/%.2f (min/avg/max/var^2)\n"), l_min, this->min_at_, l_avg, l_max, this->max_at_, l_dev); }
int Receiver_Callback::receive_frame (ACE_Message_Block *frame, TAO_AV_frame_info *, const ACE_Addr &) { // // Upcall from the AVStreams when there is data to be received from // the sender. // ACE_DEBUG ((LM_DEBUG, "Receiver_Callback::receive_frame for frame %d\n", this->frame_count_++)); int frame_size = BUFSIZ; // Write the received data to the file. size_t result = ACE_OS::fwrite (frame->rd_ptr (), frame_size, 1, output_file); if (result == frame->length ()) ACE_ERROR_RETURN ((LM_ERROR, "Receiver_Callback::fwrite failed\n"), -1); frame->rd_ptr (frame_size); ACE_hrtime_t stamp; ACE_OS_String::memcpy (&stamp, frame->rd_ptr (), sizeof (stamp)); ACE_UINT64 usec = stamp; ACE_UINT32 val_1 = ACE_CU64_TO_CU32 (usec); ACE_DEBUG ((LM_DEBUG, "Time Stamp %u\n", val_1)); frame->reset (); return 0; }
void Task_Stats::dump_latency_stats ( ACE_TCHAR *out_msg, ACE_High_Res_Timer::global_scale_factor_type sf) { if (this->samples_count_ == 0u) { ACE_OS::sprintf (out_msg, ACE_TEXT ("# no data collected\n")); return; } ACE_UINT64 avg = this->sum_ / this->samples_count_; ACE_UINT64 dev = this->sum2_ / this->samples_count_ - avg * avg; ACE_UINT64 l_min_ = this->exec_time_min_ / sf; ACE_UINT32 l_min = ACE_CU64_TO_CU32 (l_min_); ACE_UINT64 l_max_ = this->exec_time_max_ / sf; ACE_UINT32 l_max = ACE_CU64_TO_CU32 (l_max_); ACE_UINT32 l_avg = ACE_CU64_TO_CU32(avg / sf); ACE_UINT32 l_dev = ACE_CU64_TO_CU32(dev / (sf * sf)); ACE_UINT64 tmin_ = this->time_inv_[0] / sf; ACE_UINT32 tmin = ACE_CU64_TO_CU32 (tmin_); ACE_UINT64 tmax_ = this->time_inv_[samples_count_-1] / sf; ACE_UINT32 tmax = ACE_CU64_TO_CU32 (tmax_); ACE_OS::sprintf(out_msg, ACE_TEXT ("#latency : %u[%d]/%u/%u[%d]/%u (min/avg/max/var^2)\n #first invocation time = %u, last invocation time = %u\n"), l_min, this->exec_time_min_at_, l_avg, l_max, this->exec_time_max_at_, l_dev, tmin,tmax); }
void ACE_Throughput_Stats::dump_results (const ACE_TCHAR* msg, ACE_UINT32 sf) { if (this->samples_count () == 0u) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%s : no data collected\n"), msg)); return; } this->ACE_Basic_Stats::dump_results (msg, sf); ACE_Throughput_Stats::dump_throughput (msg, sf, this->throughput_last_, this->samples_count ()); #if 0 // @@TODO: This is what I really wanted to generate, but it just // doesn't work. double t_sum_x = ACE_CU64_TO_CU32 (this->throughput_sum_x_);// / sf); //t_sum_x /= 1000000.0; double t_sum_y = ACE_CU64_TO_CU32 (this->throughput_sum_y_); double t_sum_x2 = ACE_CU64_TO_CU32 (this->throughput_sum_x2_);// / (sf*sf)); //t_sum_x2 /= 1000000.0; //t_sum_x2 /= 1000000.0; double t_sum_y2 = ACE_CU64_TO_CU32 (this->throughput_sum_y2_); double t_sum_xy = ACE_CU64_TO_CU32 (this->throughput_sum_xy_);// / sf); //t_sum_xy /= 1000000.0; double t_avgx = t_sum_x / this->samples_count (); double t_avgy = t_sum_y / this->samples_count (); double t_a = (this->samples_count () * t_sum_xy - t_sum_x * t_sum_y) / (this->samples_count () * t_sum_x2 - t_sum_x * t_sum_x); double t_b = (t_avgy - t_a * t_avgx); t_a *= 1000000.0; double d_r = (t_sum_xy - t_avgx * t_sum_y - t_avgy * t_sum_x + this->samples_count () * t_avgx * t_avgy); double n_r = (t_sum_x2 - this->samples_count () * t_avgx * t_avgx) * (t_sum_y2 - this->samples_count () * t_avgy * t_avgy); double t_r = d_r * d_r / n_r; // ACE_DEBUG ((LM_DEBUG, // "%s throughput: %.2f/%.2f/%.2f/%.6f/%.2f (avg/a/b/r/elapsed)\n", // msg, t_avg, t_a, t_b, t_r, seconds)); // ACE_DEBUG ((LM_DEBUG, // "%s data: %.2f/%.2f/%.2f/%.6f/%.2f (x/x2/y/y2/xy)\n", // msg, t_sum_x, t_sum_x2, t_sum_y, t_sum_y2, t_sum_xy)); #endif }