diff options
Diffstat (limited to 'host/utils/latency/lib/Responder.cpp')
| -rw-r--r-- | host/utils/latency/lib/Responder.cpp | 1089 |
1 files changed, 534 insertions, 555 deletions
diff --git a/host/utils/latency/lib/Responder.cpp b/host/utils/latency/lib/Responder.cpp index 5597c0fcd..0d7a307dd 100644 --- a/host/utils/latency/lib/Responder.cpp +++ b/host/utils/latency/lib/Responder.cpp @@ -6,60 +6,55 @@ // #include "Responder.hpp" - -#include <iostream> -#include <iomanip> -#include <fstream> +#include <uhd/property_tree.hpp> +#include <uhd/utils/thread.hpp> +#include <boost/algorithm/string.hpp> +#include <boost/filesystem.hpp> +#include <boost/format.hpp> +#include <boost/thread/condition_variable.hpp> +#include <cmath> #include <complex> #include <csignal> -#include <cmath> +#include <fstream> +#include <iomanip> +#include <iostream> #include <sstream> -#include <boost/format.hpp> -#include <boost/algorithm/string.hpp> -#include <boost/thread/condition_variable.hpp> -#include <boost/filesystem.hpp> -#include <uhd/utils/thread.hpp> -#include <uhd/property_tree.hpp> - const std::string _eth_file("eths_info.txt"); // Redirect output to stderr -struct cerr_redirect { - cerr_redirect( std::streambuf * new_buffer ) - : old( std::cerr.rdbuf( new_buffer ) ) - { } +struct cerr_redirect +{ + cerr_redirect(std::streambuf* new_buffer) : old(std::cerr.rdbuf(new_buffer)) {} - ~cerr_redirect( ) { - std::cerr.rdbuf( old ); + ~cerr_redirect() + { + std::cerr.rdbuf(old); } private: - std::streambuf * old; + std::streambuf* old; }; - // Catch keyboard interrupts for clean manual abort static bool s_stop_signal_called = false; -static int s_signal = 0; +static int s_signal = 0; static void sig_int_handler(int signal) { s_stop_signal_called = true; - s_signal = signal; + s_signal = signal; } // member of Responder to register sig int handler -void -Responder::register_stop_signal_handler() +void Responder::register_stop_signal_handler() { std::signal(SIGINT, &sig_int_handler); } // For ncurses. Print everything in stream to screen -void -Responder::FLUSH_SCREEN() +void Responder::FLUSH_SCREEN() { printw(_ss.str().c_str()); refresh(); @@ -67,13 +62,12 @@ Responder::FLUSH_SCREEN() } // Like FLUSH_SCREEN but with new line -void -Responder::FLUSH_SCREEN_NL() +void Responder::FLUSH_SCREEN_NL() { do { int y, x; getyx(_window, y, x); - if (x > 0){ + if (x > 0) { printw("\n"); y++; } @@ -82,33 +76,39 @@ Responder::FLUSH_SCREEN_NL() } // Constructor -Responder::Responder( Options& opt) - : _opt(opt), - _stats_filename(opt.stats_filename), - _delay(opt.delay), - _samps_per_packet(opt.samps_per_packet), - _delay_step(opt.delay_step), - _simulate_frequency(opt.simulate_frequency), - _allow_late_bursts(opt.allow_late_bursts), - _no_delay(opt.no_delay), - //Initialize atributes not given by Options - _num_total_samps(0), // printed on exit - _overruns(0), // printed on exit - _max_success(0), // < 0 --> write results to file - _return_code(RETCODE_OK), - _stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS), - _timeout_burst_count(0), - _timeout_eob_count(0), - _y_delay_pos(-1), - _x_delay_pos(-1), // Remember the cursor position of delay line. +Responder::Responder(Options& opt) + : _opt(opt) + , _stats_filename(opt.stats_filename) + , _delay(opt.delay) + , _samps_per_packet(opt.samps_per_packet) + , _delay_step(opt.delay_step) + , _simulate_frequency(opt.simulate_frequency) + , _allow_late_bursts(opt.allow_late_bursts) + , _no_delay(opt.no_delay) + , + // Initialize atributes not given by Options + _num_total_samps(0) + , // printed on exit + _overruns(0) + , // printed on exit + _max_success(0) + , // < 0 --> write results to file + _return_code(RETCODE_OK) + , _stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS) + , _timeout_burst_count(0) + , _timeout_eob_count(0) + , _y_delay_pos(-1) + , _x_delay_pos(-1) + , // Remember the cursor position of delay line. _last_overrun_count(0) { - time( &_dbginfo.start_time ); // for debugging + time(&_dbginfo.start_time); // for debugging // Disable logging to console uhd::log::set_console_level(uhd::log::off); - if (uhd::set_thread_priority_safe(_opt.rt_priority, _opt.realtime) == false) // try to set realtime scheduling + if (uhd::set_thread_priority_safe(_opt.rt_priority, _opt.realtime) + == false) // try to set realtime scheduling { cerr << "Failed to set real-time" << endl; } @@ -120,16 +120,12 @@ Responder::Responder( Options& opt) create_ncurses_window(); print_create_usrp_msg(); - try - { + try { _usrp = create_usrp_device(); - } - catch (const std::runtime_error& e) - { - print_msg(e.what() ); + } catch (const std::runtime_error& e) { + print_msg(e.what()); _return_code = RETCODE_RUNTIME_ERROR; - } - catch(...){ + } catch (...) { print_msg("unhandled ERROR"); _return_code = RETCODE_UNKNOWN_EXCEPTION; print_msg_and_wait("create USRP device failed!\nPress key to abort test..."); @@ -141,12 +137,10 @@ Responder::Responder( Options& opt) // ensure that filename is set string test_id = _usrp->get_mboard_name(); - if (set_stats_filename(test_id) ) - { + if (set_stats_filename(test_id)) { _return_code = RETCODE_BAD_ARGS; // make sure run() does return! FLUSH_SCREEN(); - if (_opt.batch_mode == false) - { + if (_opt.batch_mode == false) { print_msg_and_wait("Press any key to end..."); } return; @@ -156,20 +150,19 @@ Responder::Responder( Options& opt) register_stop_signal_handler(); } -int -Responder::calculate_dependent_values() +int Responder::calculate_dependent_values() { - _response_length = _opt.response_length(); - _init_delay_count = (int64_t)(_opt.sample_rate * _opt.init_delay); - _dc_offset_countdown = (int64_t)(_opt.sample_rate * _opt.dc_offset_delay); + _response_length = _opt.response_length(); + _init_delay_count = (int64_t)(_opt.sample_rate * _opt.init_delay); + _dc_offset_countdown = (int64_t)(_opt.sample_rate * _opt.dc_offset_delay); _level_calibration_countdown = (int64_t)_opt.level_calibration_count(); - _original_simulate_duration = _simulate_duration = _opt.simulate_duration(_simulate_frequency); + _original_simulate_duration = _simulate_duration = + _opt.simulate_duration(_simulate_frequency); - if (_simulate_duration > 0) - { + if (_simulate_duration > 0) { // Skip settling period and calibration - _init_delay_count = 0; - _dc_offset_countdown = 0; + _init_delay_count = 0; + _dc_offset_countdown = 0; _level_calibration_countdown = 0; double highest_delay = 0.0; @@ -179,70 +172,78 @@ Responder::calculate_dependent_values() highest_delay = _delay; uint64_t highest_delay_samples = _opt.highest_delay_samples(highest_delay); - if ((highest_delay_samples + _response_length + _opt.flush_count) > _simulate_duration) - { - if (_opt.adjust_simulation_rate) // This is now done DURING the simulation based on active delay + if ((highest_delay_samples + _response_length + _opt.flush_count) + > _simulate_duration) { + if (_opt.adjust_simulation_rate) // This is now done DURING the simulation + // based on active delay { //_simulate_frequency = max_possible_rate; - //_simulate_duration = (uint64_t)((double)sample_rate / _simulate_frequency); - } - else - { - cerr << boost::format("Highest delay and response duration will exceed the pulse simulation rate (%ld + %ld > %ld samples)") % highest_delay_samples % _response_length % _simulate_duration << endl; - int max_possible_rate = (int) get_max_possible_frequency(highest_delay_samples, _response_length); - double max_possible_delay = (double)(_simulate_duration - (_response_length + _opt.flush_count)) / (double)_opt.sample_rate; - cerr << boost::format("Simulation rate must be less than %i Hz, or maximum delay must be less than %f s") % max_possible_rate % max_possible_delay << endl; + //_simulate_duration = (uint64_t)((double)sample_rate / + //_simulate_frequency); + } else { + cerr << boost::format( + "Highest delay and response duration will exceed the pulse " + "simulation rate (%ld + %ld > %ld samples)") + % highest_delay_samples % _response_length + % _simulate_duration + << endl; + int max_possible_rate = (int)get_max_possible_frequency( + highest_delay_samples, _response_length); + double max_possible_delay = + (double)(_simulate_duration - (_response_length + _opt.flush_count)) + / (double)_opt.sample_rate; + cerr << boost::format("Simulation rate must be less than %i Hz, or " + "maximum delay must be less than %f s") + % max_possible_rate % max_possible_delay + << endl; if (_opt.ignore_simulation_check == 0) return RETCODE_BAD_ARGS; } } - } - else - { - boost::format fmt("Simulation frequency too high (%f Hz with sample_rate %f Msps)"); - fmt % _simulate_frequency % (_opt.sample_rate/1e6); + } else { + boost::format fmt( + "Simulation frequency too high (%f Hz with sample_rate %f Msps)"); + fmt % _simulate_frequency % (_opt.sample_rate / 1e6); cerr << fmt << endl; return RETCODE_BAD_ARGS; } - if (_opt.test_iterations > 0) // Force certain settings during test mode + if (_opt.test_iterations > 0) // Force certain settings during test mode { - _no_delay = false; + _no_delay = false; _allow_late_bursts = false; - _delay = _opt.delay_min; + _delay = _opt.delay_min; } return RETCODE_OK; // default return code } // print test title to ncurses window -void -Responder::print_test_title() +void Responder::print_test_title() { - if (_opt.test_title.empty() == false) - { + if (_opt.test_title.empty() == false) { std::string title(_opt.test_title); boost::replace_all(title, "%", "%%"); print_msg(title + "\n"); } } -void -Responder::print_usrp_status() +void Responder::print_usrp_status() { std::string msg; - msg += (boost::format("Using device:\n%s\n") % _usrp->get_pp_string() ).str(); - msg += (boost::format("Setting RX rate: %f Msps\n") % (_opt.sample_rate/1e6)).str(); - msg += (boost::format("Actual RX rate: %f Msps\n") % (_usrp->get_rx_rate()/1e6) ).str(); - msg += (boost::format("Setting TX rate: %f Msps\n") % (_opt.sample_rate/1e6) ).str(); - msg += (boost::format("Actual TX rate: %f Msps") % (_usrp->get_tx_rate()/1e6) ).str(); + msg += (boost::format("Using device:\n%s\n") % _usrp->get_pp_string()).str(); + msg += (boost::format("Setting RX rate: %f Msps\n") % (_opt.sample_rate / 1e6)).str(); + msg += (boost::format("Actual RX rate: %f Msps\n") % (_usrp->get_rx_rate() / 1e6)) + .str(); + msg += (boost::format("Setting TX rate: %f Msps\n") % (_opt.sample_rate / 1e6)).str(); + msg += + (boost::format("Actual TX rate: %f Msps") % (_usrp->get_tx_rate() / 1e6)).str(); print_msg(msg); print_tx_stream_status(); print_rx_stream_status(); } -void -Responder::print_test_parameters() +void Responder::print_test_parameters() { // Some status output shoud be printed here! size_t rx_max_num_samps = _rx_stream->get_max_num_samps(); @@ -250,52 +251,58 @@ Responder::print_test_parameters() std::string msg; msg += (boost::format("Samples per buffer: %d\n") % _opt.samps_per_buff).str(); - msg += (boost::format("Maximum number of samples: RX = %d, TX = %d\n") % rx_max_num_samps % tx_max_num_samps).str(); - msg += (boost::format("Response length: %ld samples (%f us)") % _response_length % (_opt.response_duration * 1e6) ).str(); + msg += (boost::format("Maximum number of samples: RX = %d, TX = %d\n") + % rx_max_num_samps % tx_max_num_samps) + .str(); + msg += (boost::format("Response length: %ld samples (%f us)") % _response_length + % (_opt.response_duration * 1e6)) + .str(); if (_simulate_duration > 0) - msg += (boost::format("\nSimulating pulses at %f Hz (every %ld samples)") % _simulate_frequency % _simulate_duration ).str(); + msg += (boost::format("\nSimulating pulses at %f Hz (every %ld samples)") + % _simulate_frequency % _simulate_duration) + .str(); - if (_opt.test_iterations > 0) - { - msg += (boost::format("\nTest coverage: %f -> %f (%f steps)") % _opt.delay_min % _opt.delay_max % _opt.delay_step ).str(); + if (_opt.test_iterations > 0) { + msg += (boost::format("\nTest coverage: %f -> %f (%f steps)") % _opt.delay_min + % _opt.delay_max % _opt.delay_step) + .str(); if (_opt.end_test_after_success_count > 0) - msg += (boost::format("\nTesting will end after %d successful delays") % _opt.end_test_after_success_count ).str(); + msg += (boost::format("\nTesting will end after %d successful delays") + % _opt.end_test_after_success_count) + .str(); } - if ((_dc_offset_countdown == 0) && (_simulate_frequency == 0.0)) - { + if ((_dc_offset_countdown == 0) && (_simulate_frequency == 0.0)) { msg += "\nDC offset disabled"; } print_msg(msg); } -// e.g. B200 doesn't support this command. Check if possible and only set rx_dc_offset if available -void -Responder::set_usrp_rx_dc_offset(uhd::usrp::multi_usrp::sptr usrp, bool ena) +// e.g. B200 doesn't support this command. Check if possible and only set rx_dc_offset if +// available +void Responder::set_usrp_rx_dc_offset(uhd::usrp::multi_usrp::sptr usrp, bool ena) { uhd::property_tree::sptr tree = usrp->get_device()->get_tree(); // FIXME: Path needs to be build in a programmatic way. - bool dc_offset_exists = tree->exists( uhd::fs_path("/mboards/0/rx_frontends/A/dc_offset") ); - if(dc_offset_exists) - { + bool dc_offset_exists = + tree->exists(uhd::fs_path("/mboards/0/rx_frontends/A/dc_offset")); + if (dc_offset_exists) { usrp->set_rx_dc_offset(ena); } } -void -Responder::print_create_usrp_msg() +void Responder::print_create_usrp_msg() { std::string msg("Creating the USRP device"); if (_opt.device_args.empty() == false) - msg.append( (boost::format(" with args \"%s\"") % _opt.device_args ).str() ); + msg.append((boost::format(" with args \"%s\"") % _opt.device_args).str()); msg.append("..."); print_msg(msg); } -uhd::usrp::multi_usrp::sptr -Responder::create_usrp_device() +uhd::usrp::multi_usrp::sptr Responder::create_usrp_device() { uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(_opt.device_args); usrp->set_rx_rate(_opt.sample_rate); // set the rx sample rate @@ -307,22 +314,19 @@ Responder::create_usrp_device() return usrp; } -uhd::rx_streamer::sptr -Responder::create_rx_streamer(uhd::usrp::multi_usrp::sptr usrp) +uhd::rx_streamer::sptr Responder::create_rx_streamer(uhd::usrp::multi_usrp::sptr usrp) { - uhd::stream_args_t stream_args("fc32"); //complex floats - if (_samps_per_packet > 0) - { + uhd::stream_args_t stream_args("fc32"); // complex floats + if (_samps_per_packet > 0) { stream_args.args["spp"] = str(boost::format("%d") % _samps_per_packet); } uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); - _samps_per_packet = rx_stream->get_max_num_samps(); + _samps_per_packet = rx_stream->get_max_num_samps(); return rx_stream; } -void -Responder::print_rx_stream_status() +void Responder::print_rx_stream_status() { std::string msg; msg += (boost::format("Samples per packet set to: %d\n") % _samps_per_packet).str(); @@ -332,27 +336,22 @@ Responder::print_rx_stream_status() print_msg(msg); } -uhd::tx_streamer::sptr -Responder::create_tx_streamer(uhd::usrp::multi_usrp::sptr usrp) +uhd::tx_streamer::sptr Responder::create_tx_streamer(uhd::usrp::multi_usrp::sptr usrp) { - uhd::stream_args_t tx_stream_args("fc32"); //complex floats - if (_allow_late_bursts == false) - { + uhd::stream_args_t tx_stream_args("fc32"); // complex floats + if (_allow_late_bursts == false) { tx_stream_args.args["underflow_policy"] = "next_burst"; } uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(tx_stream_args); return tx_stream; } -void -Responder::print_tx_stream_status() +void Responder::print_tx_stream_status() { std::string msg; - if (_allow_late_bursts == false) - { + if (_allow_late_bursts == false) { msg += "Underflow policy set to drop late bursts"; - } - else + } else msg += "Underflow policy set to allow late bursts"; if (_opt.skip_send) msg += "\nNOT sending bursts"; @@ -362,35 +361,36 @@ Responder::print_tx_stream_status() } // handle transmit timeouts properly -void -Responder::handle_tx_timeout(int burst, int eob) +void Responder::handle_tx_timeout(int burst, int eob) { - if(_timeout_burst_count == 0 && _timeout_eob_count == 0) - time( &_dbginfo.first_send_timeout ); + if (_timeout_burst_count == 0 && _timeout_eob_count == 0) + time(&_dbginfo.first_send_timeout); _timeout_burst_count += burst; _timeout_eob_count += eob; print_timeout_msg(); } -void -Responder::print_timeout_msg() +void Responder::print_timeout_msg() { - move(_y_delay_pos+3, _x_delay_pos); - print_msg( (boost::format("Send timeout, burst_count = %ld\teob_count = %ld\n") % _timeout_burst_count % _timeout_eob_count ).str() ); + move(_y_delay_pos + 3, _x_delay_pos); + print_msg((boost::format("Send timeout, burst_count = %ld\teob_count = %ld\n") + % _timeout_burst_count % _timeout_eob_count) + .str()); } uhd::tx_metadata_t Responder::get_tx_metadata(uhd::time_spec_t rx_time, size_t n) { uhd::tx_metadata_t tx_md; tx_md.start_of_burst = true; - tx_md.end_of_burst = false; + tx_md.end_of_burst = false; if ((_opt.skip_eob == false) && (_opt.combine_eob)) { tx_md.end_of_burst = true; } if (_no_delay == false) { tx_md.has_time_spec = true; - tx_md.time_spec = rx_time + uhd::time_spec_t(0, n, _opt.sample_rate) + uhd::time_spec_t(_delay); + tx_md.time_spec = + rx_time + uhd::time_spec_t(0, n, _opt.sample_rate) + uhd::time_spec_t(_delay); } else { tx_md.has_time_spec = false; } @@ -402,22 +402,25 @@ bool Responder::send_tx_burst(uhd::time_spec_t rx_time, size_t n) if (_opt.skip_send == true) { return false; } - //send a single packet + // send a single packet uhd::tx_metadata_t tx_md = get_tx_metadata(rx_time, n); - const size_t length_to_send = _response_length + (_opt.flush_count - (tx_md.end_of_burst ? 0 : 1)); + const size_t length_to_send = + _response_length + (_opt.flush_count - (tx_md.end_of_burst ? 0 : 1)); - size_t num_tx_samps = _tx_stream->send(_pResponse, length_to_send, tx_md, _opt.timeout); // send pulse! + size_t num_tx_samps = + _tx_stream->send(_pResponse, length_to_send, tx_md, _opt.timeout); // send pulse! if (num_tx_samps < length_to_send) { handle_tx_timeout(1, 0); } if (_opt.skip_eob == false && _opt.combine_eob == false) { tx_md.start_of_burst = false; - tx_md.end_of_burst = true; - tx_md.has_time_spec = false; + tx_md.end_of_burst = true; + tx_md.has_time_spec = false; const size_t eob_length_to_send = 1; - size_t eob_num_tx_samps = _tx_stream->send(&_pResponse[length_to_send], eob_length_to_send, tx_md); // send EOB + size_t eob_num_tx_samps = _tx_stream->send( + &_pResponse[length_to_send], eob_length_to_send, tx_md); // send EOB if (eob_num_tx_samps < eob_length_to_send) { handle_tx_timeout(0, 1); } @@ -427,61 +430,69 @@ bool Responder::send_tx_burst(uhd::time_spec_t rx_time, size_t n) } // ensure that stats_filename is not empty. -bool -Responder::set_stats_filename(string test_id) +bool Responder::set_stats_filename(string test_id) { - if (_stats_filename.empty()) - { + if (_stats_filename.empty()) { string file_friendly_test_id(test_id); boost::replace_all(file_friendly_test_id, " ", "_"); - boost::format fmt = boost::format("%slatency-stats.id_%s-rate_%i-spb_%i-spp_%i%s") % _opt.stats_filename_prefix % file_friendly_test_id % (int)_opt.sample_rate % _opt.samps_per_buff % _samps_per_packet % _opt.stats_filename_suffix; - _stats_filename = str(fmt) + ".txt"; + boost::format fmt = boost::format("%slatency-stats.id_%s-rate_%i-spb_%i-spp_%i%s") + % _opt.stats_filename_prefix % file_friendly_test_id + % (int)_opt.sample_rate % _opt.samps_per_buff + % _samps_per_packet % _opt.stats_filename_suffix; + _stats_filename = str(fmt) + ".txt"; _stats_log_filename = str(fmt) + ".log"; } return check_for_existing_results(); } // Check if results file can be overwritten -bool -Responder::check_for_existing_results() +bool Responder::check_for_existing_results() { bool ex = false; - if ((_opt.skip_if_results_exist) && (boost::filesystem::exists(_stats_filename))) - { - print_msg( (boost::format("Skipping invocation as results file already exists: %s") % _stats_filename).str() ); + if ((_opt.skip_if_results_exist) && (boost::filesystem::exists(_stats_filename))) { + print_msg((boost::format("Skipping invocation as results file already exists: %s") + % _stats_filename) + .str()); ex = true; } return ex; } // Allocate an array with a burst response -float* -Responder::alloc_response_buffer_with_data(uint64_t response_length) // flush_count, output_value, output_scale are const +float* Responder::alloc_response_buffer_with_data( + uint64_t response_length) // flush_count, output_value, output_scale are const { float* pResponse = new float[(response_length + _opt.flush_count) * 2]; for (unsigned int i = 0; i < (response_length * 2); ++i) pResponse[i] = _opt.output_value * _opt.output_scale; - for (unsigned int i = (response_length * 2); i < ((response_length + _opt.flush_count) * 2); ++i) + for (unsigned int i = (response_length * 2); + i < ((response_length + _opt.flush_count) * 2); + ++i) pResponse[i] = 0.0f; return pResponse; } // print test parameters for current delay time -void -Responder::print_formatted_delay_line(const uint64_t simulate_duration, const uint64_t old_simulate_duration, const STATS& statsPrev, const double delay, const double simulate_frequency) +void Responder::print_formatted_delay_line(const uint64_t simulate_duration, + const uint64_t old_simulate_duration, + const STATS& statsPrev, + const double delay, + const double simulate_frequency) { - if(_y_delay_pos < 0 || _x_delay_pos < 0){ // make sure it gets printed to the same position everytime + if (_y_delay_pos < 0 + || _x_delay_pos < 0) { // make sure it gets printed to the same position everytime getyx(_window, _y_delay_pos, _x_delay_pos); } double score = 0.0; if (statsPrev.detected > 0) - score = 100.0 * (double)(statsPrev.detected - statsPrev.missed) / (double)statsPrev.detected; + score = 100.0 * (double)(statsPrev.detected - statsPrev.missed) + / (double)statsPrev.detected; std::string form; boost::format fmt0("Delay now: %.6f (previous delay %.6f scored %.1f%% [%ld / %ld])"); - fmt0 % delay % statsPrev.delay % score % (statsPrev.detected - statsPrev.missed) % statsPrev.detected; + fmt0 % delay % statsPrev.delay % score % (statsPrev.detected - statsPrev.missed) + % statsPrev.detected; form += fmt0.str(); - if (old_simulate_duration != simulate_duration) - { + if (old_simulate_duration != simulate_duration) { boost::format fmt1(" [Simulation rate now: %.1f Hz (%ld samples)]"); fmt1 % simulate_frequency % simulate_duration; form = form + fmt1.str(); @@ -491,8 +502,7 @@ Responder::print_formatted_delay_line(const uint64_t simulate_duration, const ui } // print message and wait for user interaction -void -Responder::print_msg_and_wait(std::string msg) +void Responder::print_msg_and_wait(std::string msg) { msg = "\n" + msg; print_msg(msg); @@ -502,114 +512,103 @@ Responder::print_msg_and_wait(std::string msg) } // print message to ncurses window -void -Responder::print_msg(std::string msg) +void Responder::print_msg(std::string msg) { _ss << msg << endl; FLUSH_SCREEN(); } // Check if error occured during call to receive -bool -Responder::handle_rx_errors(uhd::rx_metadata_t::error_code_t err, size_t num_rx_samps) +bool Responder::handle_rx_errors( + uhd::rx_metadata_t::error_code_t err, size_t num_rx_samps) { // handle errors - if (err == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) - { - std::string msg = (boost::format("Timeout while streaming (received %ld samples)") % _num_total_samps).str(); + if (err == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) { + std::string msg = (boost::format("Timeout while streaming (received %ld samples)") + % _num_total_samps) + .str(); print_error_msg(msg); _return_code = RETCODE_RECEIVE_TIMEOUT; return true; - } - else if (err == uhd::rx_metadata_t::ERROR_CODE_BAD_PACKET) - { - std::string msg = (boost::format("Bad packet (received %ld samples)") % _num_total_samps).str(); + } else if (err == uhd::rx_metadata_t::ERROR_CODE_BAD_PACKET) { + std::string msg = + (boost::format("Bad packet (received %ld samples)") % _num_total_samps).str(); print_error_msg(msg); _return_code = RETCODE_BAD_PACKET; return true; - } - else if ((num_rx_samps == 0) && (err == uhd::rx_metadata_t::ERROR_CODE_NONE)) - { + } else if ((num_rx_samps == 0) && (err == uhd::rx_metadata_t::ERROR_CODE_NONE)) { print_error_msg("Received no samples"); _return_code = RETCODE_RECEIVE_FAILED; return true; - } - else if (err == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW) - { + } else if (err == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW) { ++_overruns; print_overrun_msg(); // update overrun info on console. - } - else if (err != uhd::rx_metadata_t::ERROR_CODE_NONE) - { - throw std::runtime_error(str(boost::format( - "Unexpected error code 0x%x" - ) % err)); + } else if (err != uhd::rx_metadata_t::ERROR_CODE_NONE) { + throw std::runtime_error(str(boost::format("Unexpected error code 0x%x") % err)); } return false; } // print overrun status message. -void -Responder::print_overrun_msg() +void Responder::print_overrun_msg() { - if (_num_total_samps > (_last_overrun_count + (uint64_t)(_opt.sample_rate * 1.0))) - { + if (_num_total_samps > (_last_overrun_count + (uint64_t)(_opt.sample_rate * 1.0))) { int y, x, y_max, x_max; getyx(_window, y, x); getmaxyx(_window, y_max, x_max); - move(y_max-1, 0); - print_msg( (boost::format("Overruns: %d") % _overruns).str() ); + move(y_max - 1, 0); + print_msg((boost::format("Overruns: %d") % _overruns).str()); move(y, x); _last_overrun_count = _num_total_samps; } } // print error message on last line of ncurses window -void -Responder::print_error_msg(std::string msg) +void Responder::print_error_msg(std::string msg) { int y, x, y_max, x_max; getyx(_window, y, x); getmaxyx(_window, y_max, x_max); - move(y_max-2, 0); + move(y_max - 2, 0); clrtoeol(); print_msg(msg); move(y, x); } // calculate simulate frequency -double -Responder::get_simulate_frequency(double delay, uint64_t response_length, uint64_t original_simulate_duration) +double Responder::get_simulate_frequency( + double delay, uint64_t response_length, uint64_t original_simulate_duration) { - double simulate_frequency = _simulate_frequency; + double simulate_frequency = _simulate_frequency; uint64_t highest_delay_samples = _opt.highest_delay_samples(delay); - if ((_opt.optimize_simulation_rate) || - ((highest_delay_samples + response_length + _opt.flush_count) > original_simulate_duration)) - { - simulate_frequency = get_max_possible_frequency(highest_delay_samples, response_length); + if ((_opt.optimize_simulation_rate) + || ((highest_delay_samples + response_length + _opt.flush_count) + > original_simulate_duration)) { + simulate_frequency = + get_max_possible_frequency(highest_delay_samples, response_length); } return simulate_frequency; } // calculate max possible simulate frequency -double -Responder::get_max_possible_frequency(uint64_t highest_delay_samples, uint64_t response_length) // only 2 args, others are all const! +double Responder::get_max_possible_frequency(uint64_t highest_delay_samples, + uint64_t response_length) // only 2 args, others are all const! { - return std::floor((double)_opt.sample_rate / (double)(highest_delay_samples + response_length + _opt.flush_count + _opt.optimize_padding)); + return std::floor((double)_opt.sample_rate + / (double)(highest_delay_samples + response_length + + _opt.flush_count + _opt.optimize_padding)); } // Check if conditions to finish test are met. -bool -Responder::test_finished(size_t success_count) +bool Responder::test_finished(size_t success_count) { - if (success_count == _opt.end_test_after_success_count) - { - print_msg( (boost::format("\nTest complete after %d successes.") % success_count).str() ); + if (success_count == _opt.end_test_after_success_count) { + print_msg( + (boost::format("\nTest complete after %d successes.") % success_count).str()); return true; } - if (((_opt.delay_min <= _opt.delay_max) && (_delay >= _opt.delay_max)) || - ((_opt.delay_min > _opt.delay_max) && (_delay <= _opt.delay_max))) - { + if (((_opt.delay_min <= _opt.delay_max) && (_delay >= _opt.delay_max)) + || ((_opt.delay_min > _opt.delay_max) && (_delay <= _opt.delay_max))) { print_msg("\nTest complete."); return true; } @@ -617,45 +616,38 @@ Responder::test_finished(size_t success_count) } // handle keyboard input in interactive mode -bool -Responder::handle_interactive_control() +bool Responder::handle_interactive_control() { std::string msg = ""; - int c = wgetch(_window); - if (c > -1) - { + int c = wgetch(_window); + if (c > -1) { // UP/DOWN Keys control delay step width - if ((c == KEY_DOWN) || (c == KEY_UP)) - { + if ((c == KEY_DOWN) || (c == KEY_UP)) { double dMag = log10(_delay_step); - int iMag = (int)floor(dMag); + int iMag = (int)floor(dMag); iMag += ((c == KEY_UP) ? 1 : -1); _delay_step = pow(10.0, iMag); - msg += (boost::format("Step: %f") % _delay_step ).str(); + msg += (boost::format("Step: %f") % _delay_step).str(); } // LEFT/RIGHT Keys control absolute delay length - if ((c == KEY_LEFT) || (c == KEY_RIGHT)) - { + if ((c == KEY_LEFT) || (c == KEY_RIGHT)) { double step = _delay_step * ((c == KEY_RIGHT) ? 1 : -1); if ((_delay + step) >= 0.0) _delay += step; msg += (boost::format("Delay: %f") % _delay).str(); } // Enable/disable fixed delay <--> best effort mode - if (c == 'd') - { + if (c == 'd') { _no_delay = !_no_delay; if (_no_delay) msg += "Delay disabled (best effort)"; else msg += (boost::format("Delay: %f") % _delay).str(); - } - else if (c == 'q') // exit test + } else if (c == 'q') // exit test { return true; // signal test to stop - } - else if (c == 'l') // change late burst policy + } else if (c == 'l') // change late burst policy { _allow_late_bursts = !_allow_late_bursts; @@ -670,16 +662,13 @@ Responder::handle_interactive_control() } // print updated interactive control value -void -Responder::print_interactive_msg(std::string msg) +void Responder::print_interactive_msg(std::string msg) { - if(msg != "") - { + if (msg != "") { // move cursor back to beginning of line int y, x; getyx(_window, y, x); - if (x > 0) - { + if (x > 0) { move(y, 0); clrtoeol(); } @@ -689,36 +678,31 @@ Responder::print_interactive_msg(std::string msg) } // check if transmit burst is late -bool -Responder::tx_burst_is_late() +bool Responder::tx_burst_is_late() { uhd::async_metadata_t async_md; - if (_usrp->get_device()->recv_async_msg(async_md, 0)) - { - if (async_md.event_code == uhd::async_metadata_t::EVENT_CODE_TIME_ERROR) - { + if (_usrp->get_device()->recv_async_msg(async_md, 0)) { + if (async_md.event_code == uhd::async_metadata_t::EVENT_CODE_TIME_ERROR) { return true; } } return false; } -void -Responder::create_ncurses_window() +void Responder::create_ncurses_window() { _window = initscr(); - cbreak(); // Unbuffered key input, except for signals (cf. 'raw') + cbreak(); // Unbuffered key input, except for signals (cf. 'raw') noecho(); nonl(); intrflush(_window, FALSE); - keypad(_window, TRUE); // Enable function keys, arrow keys, ... + keypad(_window, TRUE); // Enable function keys, arrow keys, ... nodelay(_window, 0); timeout(0); } // print all fixed test parameters -void -Responder::print_init_test_status() +void Responder::print_init_test_status() { // Clear the window and write new data. erase(); @@ -740,30 +724,29 @@ Responder::print_init_test_status() } // in interactive mode with second usrp sending bursts. calibrate trigger level -float -Responder::calibrate_usrp_for_test_run() +float Responder::calibrate_usrp_for_test_run() { bool calibration_finished = false; - float threshold = 0.0f; + float threshold = 0.0f; double ave_high = 0, ave_low = 0; int ave_high_count = 0, ave_low_count = 0; - bool level_calibration_stage_2 = false; // 1. stage = rough calibration ; 2. stage = fine calibration + bool level_calibration_stage_2 = + false; // 1. stage = rough calibration ; 2. stage = fine calibration - std::vector<std::complex<float> > buff(_opt.samps_per_buff); - while (not s_stop_signal_called && !calibration_finished && _return_code == RETCODE_OK) - { + std::vector<std::complex<float>> buff(_opt.samps_per_buff); + while ( + not s_stop_signal_called && !calibration_finished && _return_code == RETCODE_OK) { uhd::rx_metadata_t rx_md; - size_t num_rx_samps = _rx_stream->recv(&buff.front(), buff.size(), rx_md, _opt.timeout); + size_t num_rx_samps = + _rx_stream->recv(&buff.front(), buff.size(), rx_md, _opt.timeout); // handle errors - if(handle_rx_errors(rx_md.error_code, num_rx_samps) ) - { + if (handle_rx_errors(rx_md.error_code, num_rx_samps)) { break; } // Wait for USRP for DC offset calibration - if (_dc_offset_countdown > 0) - { + if (_dc_offset_countdown > 0) { _dc_offset_countdown -= (int64_t)num_rx_samps; if (_dc_offset_countdown > 0) continue; @@ -772,8 +755,7 @@ Responder::calibrate_usrp_for_test_run() } // Wait for certain time to minimize POWER UP effects - if (_init_delay_count > 0) - { + if (_init_delay_count > 0) { _init_delay_count -= (int64_t)num_rx_samps; if (_init_delay_count > 0) continue; @@ -782,48 +764,35 @@ Responder::calibrate_usrp_for_test_run() //////////////////////////////////////////////////////////// // detect falling edges and calibrate detection values - if (_level_calibration_countdown > 0) - { - if (level_calibration_stage_2 == false) - { + if (_level_calibration_countdown > 0) { + if (level_calibration_stage_2 == false) { float average = 0.0f; for (size_t n = 0; n < num_rx_samps; n++) average += buff[n].real() * _opt.invert; average /= (float)num_rx_samps; - if (ave_low_count == 0) - { + if (ave_low_count == 0) { ave_low = average; ++ave_low_count; - } - else if (average < ave_low) - { + } else if (average < ave_low) { ave_low = average; ++ave_low_count; } - if (ave_high_count == 0) - { + if (ave_high_count == 0) { ave_high = average; ++ave_high_count; - } - else if (average > ave_high) - { + } else if (average > ave_high) { ave_high = average; ++ave_high_count; } - } - else { - for (size_t n = 0; n < num_rx_samps; n++) - { + } else { + for (size_t n = 0; n < num_rx_samps; n++) { float f = buff[n].real() * _opt.invert; - if (f >= threshold) - { + if (f >= threshold) { ave_high += f; ave_high_count++; - } - else - { + } else { ave_low += f; ave_low_count++; } @@ -832,43 +801,51 @@ Responder::calibrate_usrp_for_test_run() _level_calibration_countdown -= (int64_t)num_rx_samps; - if (_level_calibration_countdown <= 0) - { - if (level_calibration_stage_2 == false) - { - level_calibration_stage_2 = true; + if (_level_calibration_countdown <= 0) { + if (level_calibration_stage_2 == false) { + level_calibration_stage_2 = true; _level_calibration_countdown = _opt.level_calibration_count(); - threshold = ave_low + ((ave_high - ave_low) / 2.0); - print_msg( (boost::format("Phase #1: Ave low: %.3f (#%d), ave high: %.3f (#%d), threshold: %.3f") % ave_low % ave_low_count % ave_high % ave_high_count % threshold).str() ); + threshold = ave_low + ((ave_high - ave_low) / 2.0); + print_msg((boost::format("Phase #1: Ave low: %.3f (#%d), ave high: " + "%.3f (#%d), threshold: %.3f") + % ave_low % ave_low_count % ave_high % ave_high_count + % threshold) + .str()); ave_low_count = ave_high_count = 0; ave_low = ave_high = 0.0f; continue; - } - else - { + } else { ave_low /= (double)ave_low_count; ave_high /= (double)ave_high_count; threshold = ave_low + ((ave_high - ave_low) * _opt.trigger_level); - print_msg( (boost::format("Phase #2: Ave low: %.3f (#%d), ave high: %.3f (#%d), threshold: %.3f\n") % ave_low % ave_low_count % ave_high % ave_high_count % threshold).str() ); - - _stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS; + print_msg((boost::format("Phase #2: Ave low: %.3f (#%d), ave high: " + "%.3f (#%d), threshold: %.3f\n") + % ave_low % ave_low_count % ave_high % ave_high_count + % threshold) + .str()); + + _stream_cmd.stream_mode = + uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS; _stream_cmd.stream_now = true; _usrp->issue_stream_cmd(_stream_cmd); double diff = std::abs(ave_high - ave_low); - if (diff < _opt.pulse_detection_threshold) - { + if (diff < _opt.pulse_detection_threshold) { _return_code = RETCODE_BAD_ARGS; - print_error_msg( (boost::format("Did not detect any pulses (difference %.6f < detection threshold %.6f)") % diff % _opt.pulse_detection_threshold).str() ); + print_error_msg( + (boost::format("Did not detect any pulses (difference %.6f < " + "detection threshold %.6f)") + % diff % _opt.pulse_detection_threshold) + .str()); break; } - _stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; + _stream_cmd.stream_mode = + uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; _stream_cmd.stream_now = true; _usrp->issue_stream_cmd(_stream_cmd); } - } - else + } else continue; } // calibration finished calibration_finished = true; @@ -877,86 +854,82 @@ Responder::calibrate_usrp_for_test_run() } // try to stop USRP properly after tests -void -Responder::stop_usrp_stream() +void Responder::stop_usrp_stream() { - try - { - if (_usrp) - { + try { + if (_usrp) { _stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS; - _stream_cmd.stream_now = true; + _stream_cmd.stream_now = true; _usrp->issue_stream_cmd(_stream_cmd); } - } - catch (...) - { + } catch (...) { // } } // after each delay length update test parameters and print them -void -Responder::update_and_print_parameters(const STATS& statsPrev, const double delay) +void Responder::update_and_print_parameters(const STATS& statsPrev, const double delay) { uint64_t old_simulate_duration = _simulate_duration; - _simulate_frequency = get_simulate_frequency(delay, _response_length, _original_simulate_duration); + _simulate_frequency = + get_simulate_frequency(delay, _response_length, _original_simulate_duration); _simulate_duration = _opt.simulate_duration(_simulate_frequency); - print_formatted_delay_line(_simulate_duration, old_simulate_duration, statsPrev, delay, _simulate_frequency); + print_formatted_delay_line( + _simulate_duration, old_simulate_duration, statsPrev, delay, _simulate_frequency); _timeout_burst_count = 0; - _timeout_eob_count = 0; + _timeout_eob_count = 0; } // detect or simulate burst level. -bool -Responder::get_new_state(uint64_t total_samps, uint64_t simulate_duration, float val, float threshold) +bool Responder::get_new_state( + uint64_t total_samps, uint64_t simulate_duration, float val, float threshold) { bool new_state = false; if (simulate_duration > 0) // only simulated input bursts! new_state = (((total_samps) % simulate_duration) == 0); else - new_state = (val >= threshold); // TODO: Just measure difference in fall + new_state = (val >= threshold); // TODO: Just measure difference in fall return new_state; } // detect a pulse, respond to it and count number of pulses. // statsCurrent holds parameters. -uint64_t -Responder::detect_respond_pulse_count(STATS &statsCurrent, std::vector<std::complex<float> > &buff, uint64_t trigger_count, size_t num_rx_samps, float threshold, uhd::time_spec_t rx_time) +uint64_t Responder::detect_respond_pulse_count(STATS& statsCurrent, + std::vector<std::complex<float>>& buff, + uint64_t trigger_count, + size_t num_rx_samps, + float threshold, + uhd::time_spec_t rx_time) { // buff, threshold bool input_state = false; - for (size_t n = 0; n < num_rx_samps; n++) - { + for (size_t n = 0; n < num_rx_samps; n++) { float f = buff[n].real() * _opt.invert; - bool new_state = get_new_state(_num_total_samps + n, _simulate_duration, f, threshold); + bool new_state = + get_new_state(_num_total_samps + n, _simulate_duration, f, threshold); if ((new_state == false) && (input_state)) // == falling_edge { trigger_count++; statsCurrent.detected++; - if ((_opt.test_iterations > 0) - && (_opt.skip_iterations > 0) - && (statsCurrent.skipped == 0) - && (_opt.skip_iterations == statsCurrent.detected)) - { + if ((_opt.test_iterations > 0) && (_opt.skip_iterations > 0) + && (statsCurrent.skipped == 0) + && (_opt.skip_iterations == statsCurrent.detected)) { memset(&statsCurrent, 0x00, sizeof(STATS)); - statsCurrent.delay = _delay; + statsCurrent.delay = _delay; statsCurrent.detected = 1; - statsCurrent.skipped = _opt.skip_iterations; + statsCurrent.skipped = _opt.skip_iterations; trigger_count = 1; } - if( !send_tx_burst(rx_time, n) ) - { + if (!send_tx_burst(rx_time, n)) { statsCurrent.missed++; } - if(tx_burst_is_late() ) - { + if (tx_burst_is_late()) { statsCurrent.missed++; } } @@ -967,34 +940,33 @@ Responder::detect_respond_pulse_count(STATS &statsCurrent, std::vector<std::comp } // this is the actual "work" function. All the fun happens here -void -Responder::run_test(float threshold) +void Responder::run_test(float threshold) { STATS statsCurrent; //, statsPrev; memset(&statsCurrent, 0x00, sizeof(STATS)); - if (_opt.test_iterations > 0) - { + if (_opt.test_iterations > 0) { update_and_print_parameters(statsCurrent, _delay); statsCurrent.delay = _opt.delay_min; } /////////////////////////////////////////////////////////////////////////// - uint64_t trigger_count = 0; - size_t success_count = 0; + uint64_t trigger_count = 0; + size_t success_count = 0; uint64_t num_total_samps_test = 0; - std::vector<std::complex<float> > buff(_opt.samps_per_buff); - while (not s_stop_signal_called && _return_code == RETCODE_OK) - { + std::vector<std::complex<float>> buff(_opt.samps_per_buff); + while (not s_stop_signal_called && _return_code == RETCODE_OK) { // get samples from rx stream. uhd::rx_metadata_t rx_md; - size_t num_rx_samps = _rx_stream->recv(&buff.front(), buff.size(), rx_md, _opt.timeout); + size_t num_rx_samps = + _rx_stream->recv(&buff.front(), buff.size(), rx_md, _opt.timeout); // handle errors - if(handle_rx_errors(rx_md.error_code, num_rx_samps) ) - { + if (handle_rx_errors(rx_md.error_code, num_rx_samps)) { break; } - // detect falling edges, send respond pulse and check if response could be sent in time - trigger_count = detect_respond_pulse_count(statsCurrent, buff, trigger_count, num_rx_samps, threshold, rx_md.time_spec); + // detect falling edges, send respond pulse and check if response could be sent in + // time + trigger_count = detect_respond_pulse_count( + statsCurrent, buff, trigger_count, num_rx_samps, threshold, rx_md.time_spec); // increase counters for single test and overall test samples count. _num_total_samps += num_rx_samps; @@ -1003,40 +975,47 @@ Responder::run_test(float threshold) // control section for interactive mode if (_opt.test_iterations == 0) // == "interactive' { - if(handle_interactive_control() ) + if (handle_interactive_control()) break; } // control section for test mode if (_opt.test_iterations > 0) // == test mode / batch-mode { - int step_return = test_step_finished(trigger_count, num_total_samps_test, statsCurrent, success_count); - if(step_return == -2) // == test is finished with all desired delay steps + int step_return = test_step_finished( + trigger_count, num_total_samps_test, statsCurrent, success_count); + if (step_return == -2) // == test is finished with all desired delay steps break; - else if(step_return == -1) // just continue test + else if (step_return == -1) // just continue test continue; else // test with one delay is finished { - success_count = (size_t) step_return; - trigger_count = 0; + success_count = (size_t)step_return; + trigger_count = 0; num_total_samps_test = 0; - memset(&statsCurrent, 0x00, sizeof(STATS)); // reset current stats for next test iteration + memset(&statsCurrent, + 0x00, + sizeof(STATS)); // reset current stats for next test iteration statsCurrent.delay = _delay; } } // end test mode control section - }// exit outer loop after stop signal is called, test is finished or other break condition is met + } // exit outer loop after stop signal is called, test is finished or other break + // condition is met if (s_stop_signal_called) _return_code = RETCODE_MANUAL_ABORT; } // check if test with one specific delay is finished -int -Responder::test_step_finished(uint64_t trigger_count, uint64_t num_total_samps_test, STATS statsCurrent, size_t success_count) +int Responder::test_step_finished(uint64_t trigger_count, + uint64_t num_total_samps_test, + STATS statsCurrent, + size_t success_count) { - if ( ((_opt.test_iterations_is_sample_count == false) && (trigger_count >= _opt.test_iterations)) || - ((_opt.test_iterations_is_sample_count) && (num_total_samps_test > _opt.test_iterations)) ) - { + if (((_opt.test_iterations_is_sample_count == false) + && (trigger_count >= _opt.test_iterations)) + || ((_opt.test_iterations_is_sample_count) + && (num_total_samps_test > _opt.test_iterations))) { add_stats_to_results(statsCurrent, _delay); if (statsCurrent.missed == 0) // == NO late bursts @@ -1044,7 +1023,7 @@ Responder::test_step_finished(uint64_t trigger_count, uint64_t num_total_samps_t else success_count = 0; - if(test_finished(success_count) ) + if (test_finished(success_count)) return -2; // test is completely finished _delay += _delay_step; // increase delay by one step @@ -1056,58 +1035,50 @@ Responder::test_step_finished(uint64_t trigger_count, uint64_t num_total_samps_t } // save test results -void -Responder::add_stats_to_results(STATS statsCurrent, double delay) +void Responder::add_stats_to_results(STATS statsCurrent, double delay) { - _max_success = max(_max_success, (statsCurrent.detected - statsCurrent.missed)); // > 0 --> save results - uint64_t key = (uint64_t)(delay * 1e6); + _max_success = max(_max_success, + (statsCurrent.detected - statsCurrent.missed)); // > 0 --> save results + uint64_t key = (uint64_t)(delay * 1e6); _mapStats[key] = statsCurrent; } // run tests and handle errors -int -Responder::run() +int Responder::run() { if (_return_code != RETCODE_OK) return _return_code; if (_opt.pause) print_msg_and_wait("Press any key to begin..."); - time( &_dbginfo.start_time_test ); + time(&_dbginfo.start_time_test); // Put some info about the test on the console print_init_test_status(); try { - //setup streaming + // setup streaming _stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; - _stream_cmd.stream_now = true; + _stream_cmd.stream_now = true; _usrp->issue_stream_cmd(_stream_cmd); - if( !_opt.batch_mode ){ + if (!_opt.batch_mode) { float threshold = calibrate_usrp_for_test_run(); - if (_return_code != RETCODE_OK) - { + if (_return_code != RETCODE_OK) { return _return_code; } run_test(threshold); - } - else - { + } else { run_test(); } - } - catch (const std::runtime_error& e) - { - print_msg(e.what() ); + } catch (const std::runtime_error& e) { + print_msg(e.what()); _return_code = RETCODE_RUNTIME_ERROR; - } - catch (...) - { + } catch (...) { print_msg("Unhandled exception"); _return_code = RETCODE_UNKNOWN_EXCEPTION; } stop_usrp_stream(); - time( &_dbginfo.end_time_test ); + time(&_dbginfo.end_time_test); return (_return_code < 0 ? _return_code : _overruns); } @@ -1116,8 +1087,7 @@ Responder::run() */ // This method should print statistics after ncurses endwin. -void -Responder::print_final_statistics() +void Responder::print_final_statistics() { cout << boost::format("Received %ld samples during test run") % _num_total_samps; if (_overruns > 0) @@ -1126,29 +1096,30 @@ Responder::print_final_statistics() } // safe test results to a log file if enabled -void -Responder::write_log_file() +void Responder::write_log_file() { - try - { - if(_opt.log_file){ + try { + if (_opt.log_file) { std::map<std::string, std::string> hw_info = get_hw_info(); ofstream logs(_stats_log_filename.c_str()); logs << boost::format("title=%s") % _opt.test_title << endl; - logs << boost::format("device=%s") % _usrp->get_mboard_name() << endl; + logs << boost::format("device=%s") % _usrp->get_mboard_name() << endl; logs << boost::format("device_args=%s") % _opt.device_args << endl; - logs << boost::format("type=%s") % hw_info["type"] << endl; - if (hw_info.size() > 0) - { - logs << boost::format("usrp_addr=%s") % hw_info["usrp_addr"] << endl; - logs << boost::format("usrp_name=%s") % hw_info["name"] << endl; - logs << boost::format("serial=%s") % hw_info["serial"] << endl; - logs << boost::format("host_interface=%s") % hw_info["interface"] << endl; - logs << boost::format("host_addr=%s") % hw_info["host_addr"] << endl; - logs << boost::format("host_mac=%s") % hw_info["mac"] << endl; - logs << boost::format("host_vendor=%s (id=%s)") % hw_info["vendor"] % hw_info["vendor_id"] << endl; - logs << boost::format("host_device=%s (id=%s)") % hw_info["device"] % hw_info["device_id"] << endl; + logs << boost::format("type=%s") % hw_info["type"] << endl; + if (hw_info.size() > 0) { + logs << boost::format("usrp_addr=%s") % hw_info["usrp_addr"] << endl; + logs << boost::format("usrp_name=%s") % hw_info["name"] << endl; + logs << boost::format("serial=%s") % hw_info["serial"] << endl; + logs << boost::format("host_interface=%s") % hw_info["interface"] << endl; + logs << boost::format("host_addr=%s") % hw_info["host_addr"] << endl; + logs << boost::format("host_mac=%s") % hw_info["mac"] << endl; + logs << boost::format("host_vendor=%s (id=%s)") % hw_info["vendor"] + % hw_info["vendor_id"] + << endl; + logs << boost::format("host_device=%s (id=%s)") % hw_info["device"] + % hw_info["device_id"] + << endl; } logs << boost::format("sample_rate=%f") % _opt.sample_rate << endl; logs << boost::format("samps_per_buff=%i") % _opt.samps_per_buff << endl; @@ -1158,97 +1129,113 @@ Responder::write_log_file() logs << boost::format("delay_step=%f") % _delay_step << endl; logs << boost::format("delay=%f") % _delay << endl; logs << boost::format("init_delay=%f") % _opt.init_delay << endl; - logs << boost::format("response_duration=%f") % _opt.response_duration << endl; + logs << boost::format("response_duration=%f") % _opt.response_duration + << endl; logs << boost::format("response_length=%ld") % _response_length << endl; logs << boost::format("timeout=%f") % _opt.timeout << endl; - logs << boost::format("timeout_burst_count=%ld") % _timeout_burst_count << endl; + logs << boost::format("timeout_burst_count=%ld") % _timeout_burst_count + << endl; logs << boost::format("timeout_eob_count=%f") % _timeout_eob_count << endl; - logs << boost::format("allow_late_bursts=%s") % (_allow_late_bursts ? "yes" : "no") << endl; + logs << boost::format("allow_late_bursts=%s") + % (_allow_late_bursts ? "yes" : "no") + << endl; logs << boost::format("skip_eob=%s") % (_opt.skip_eob ? "yes" : "no") << endl; - logs << boost::format("combine_eob=%s") % (_opt.combine_eob ? "yes" : "no") << endl; - logs << boost::format("skip_send=%s") % (_opt.skip_send ? "yes" : "no") << endl; + logs << boost::format("combine_eob=%s") % (_opt.combine_eob ? "yes" : "no") + << endl; + logs << boost::format("skip_send=%s") % (_opt.skip_send ? "yes" : "no") + << endl; logs << boost::format("no_delay=%s") % (_no_delay ? "yes" : "no") << endl; logs << boost::format("simulate_frequency=%f") % _simulate_frequency << endl; logs << boost::format("simulate_duration=%ld") % _simulate_duration << endl; - logs << boost::format("original_simulate_duration=%ld") % _original_simulate_duration << endl; + logs << boost::format("original_simulate_duration=%ld") + % _original_simulate_duration + << endl; logs << boost::format("realtime=%s") % (_opt.realtime ? "yes" : "no") << endl; logs << boost::format("rt_priority=%f") % _opt.rt_priority << endl; logs << boost::format("test_iterations=%ld") % _opt.test_iterations << endl; - logs << boost::format("end_test_after_success_count=%i") % _opt.end_test_after_success_count << endl; + logs << boost::format("end_test_after_success_count=%i") + % _opt.end_test_after_success_count + << endl; logs << boost::format("skip_iterations=%i") % _opt.skip_iterations << endl; logs << boost::format("overruns=%i") % _overruns << endl; logs << boost::format("num_total_samps=%ld") % _num_total_samps << endl; - logs << boost::format("return_code=%i\t(%s)") % _return_code % enum2str(_return_code) << endl; + logs << boost::format("return_code=%i\t(%s)") % _return_code + % enum2str(_return_code) + << endl; logs << endl; write_debug_info(logs); - } - } - catch(...) - { + } catch (...) { cerr << "Failed to write log file to: " << _stats_log_filename << endl; } } // write debug info to log file -void -Responder::write_debug_info(ofstream& logs) +void Responder::write_debug_info(ofstream& logs) { logs << endl << "%% DEBUG INFO %%" << endl; - logs << boost::format("dbg_time_start=%s") % get_gmtime_string(_dbginfo.start_time) << endl; - logs << boost::format("dbg_time_end=%s") % get_gmtime_string(_dbginfo.end_time) << endl; - logs << boost::format("dbg_time_duration=%d") % difftime( _dbginfo.end_time, _dbginfo.start_time ) << endl; - logs << boost::format("dbg_time_start_test=%s") % get_gmtime_string(_dbginfo.start_time_test) << endl; - logs << boost::format("dbg_time_end_test=%s") % get_gmtime_string(_dbginfo.end_time_test) << endl; - logs << boost::format("dbg_time_duration_test=%d") % difftime( _dbginfo.end_time_test, _dbginfo.start_time_test ) << endl; - logs << boost::format("dbg_time_first_send_timeout=%s") % get_gmtime_string(_dbginfo.first_send_timeout) << endl; + logs << boost::format("dbg_time_start=%s") % get_gmtime_string(_dbginfo.start_time) + << endl; + logs << boost::format("dbg_time_end=%s") % get_gmtime_string(_dbginfo.end_time) + << endl; + logs << boost::format("dbg_time_duration=%d") + % difftime(_dbginfo.end_time, _dbginfo.start_time) + << endl; + logs << boost::format("dbg_time_start_test=%s") + % get_gmtime_string(_dbginfo.start_time_test) + << endl; + logs << boost::format("dbg_time_end_test=%s") + % get_gmtime_string(_dbginfo.end_time_test) + << endl; + logs << boost::format("dbg_time_duration_test=%d") + % difftime(_dbginfo.end_time_test, _dbginfo.start_time_test) + << endl; + logs << boost::format("dbg_time_first_send_timeout=%s") + % get_gmtime_string(_dbginfo.first_send_timeout) + << endl; } // convert a time string to desired format -std::string -Responder::get_gmtime_string(time_t time) +std::string Responder::get_gmtime_string(time_t time) { tm* ftm; - ftm = gmtime( &time ); + ftm = gmtime(&time); std::string strtime; - strtime.append( (boost::format("%i") % (ftm->tm_year+1900) ).str() ); - strtime.append( (boost::format("-%02i") % ftm->tm_mon).str() ); - strtime.append( (boost::format("-%02i") % ftm->tm_mday).str() ); - strtime.append( (boost::format("-%02i") % ((ftm->tm_hour)) ).str() ); - strtime.append( (boost::format(":%02i") % ftm->tm_min).str() ); - strtime.append( (boost::format(":%02i") % ftm->tm_sec).str() ); + strtime.append((boost::format("%i") % (ftm->tm_year + 1900)).str()); + strtime.append((boost::format("-%02i") % ftm->tm_mon).str()); + strtime.append((boost::format("-%02i") % ftm->tm_mday).str()); + strtime.append((boost::format("-%02i") % ((ftm->tm_hour))).str()); + strtime.append((boost::format(":%02i") % ftm->tm_min).str()); + strtime.append((boost::format(":%02i") % ftm->tm_sec).str()); return strtime; } // read hardware info from file if available to include it in log file -std::map<std::string, std::string> -Responder::get_hw_info() +std::map<std::string, std::string> Responder::get_hw_info() { std::map<std::string, std::string> result; - std::vector<std::map<std::string,std::string> > eths = read_eth_info(); - if(eths.empty()){ + std::vector<std::map<std::string, std::string>> eths = read_eth_info(); + if (eths.empty()) { return result; } uhd::device_addr_t usrp_info = get_usrp_info(); - std::string uaddr = get_ip_subnet_addr(usrp_info["addr"]); + std::string uaddr = get_ip_subnet_addr(usrp_info["addr"]); - for(unsigned int i = 0 ; i < eths.size() ; i++ ) - { - if(get_ip_subnet_addr(eths[i]["addr"]) == uaddr) - { - result["type"] = usrp_info["type"]; + for (unsigned int i = 0; i < eths.size(); i++) { + if (get_ip_subnet_addr(eths[i]["addr"]) == uaddr) { + result["type"] = usrp_info["type"]; result["usrp_addr"] = usrp_info["addr"]; - result["name"] = usrp_info["name"]; - result["serial"] = usrp_info["serial"]; + result["name"] = usrp_info["name"]; + result["serial"] = usrp_info["serial"]; result["interface"] = eths[i]["interface"]; result["host_addr"] = eths[i]["addr"]; - result["mac"] = eths[i]["mac"]; - result["vendor"] = eths[i]["vendor"]; + result["mac"] = eths[i]["mac"]; + result["vendor"] = eths[i]["vendor"]; result["vendor_id"] = eths[i]["vendor_id"]; - result["device"] = eths[i]["device"]; + result["device"] = eths[i]["device"]; result["device_id"] = eths[i]["device_id"]; break; // Use first item found. Imitate device discovery. } @@ -1258,138 +1245,124 @@ Responder::get_hw_info() } // subnet used to identify used network interface -std::string -Responder::get_ip_subnet_addr(std::string ip) +std::string Responder::get_ip_subnet_addr(std::string ip) { return ip.substr(0, ip.rfind(".") + 1); } // get network interface info from file (should include all available interfaces) -std::vector<std::map<std::string,std::string> > -Responder::read_eth_info() +std::vector<std::map<std::string, std::string>> Responder::read_eth_info() { const std::string eth_file(_eth_file); - std::vector<std::map<std::string,std::string> > eths; - try - { + std::vector<std::map<std::string, std::string>> eths; + try { ifstream eth_info(eth_file.c_str()); - if(!eth_info.is_open()){ + if (!eth_info.is_open()) { return eths; } const int len = 256; char cline[len]; - for(; !eth_info.eof() ;) - { + for (; !eth_info.eof();) { eth_info.getline(cline, len); std::string line(cline); - if(line.find("## ETH Interface") != std::string::npos) - { + if (line.find("## ETH Interface") != std::string::npos) { eth_info.getline(cline, len); std::string eth(cline); -// cout << "interface=" << eth << endl; - std::map<std::string,std::string> iface; + // cout << "interface=" << eth << endl; + std::map<std::string, std::string> iface; iface["interface"] = eth; eths.push_back(iface); } const std::string ipstr("\tip "); - if(line.find(ipstr) != std::string::npos) - { - std::string ip( line.replace(line.begin(), line.begin()+ipstr.length(), "") ); -// cout << "ip=" << ip << endl; + if (line.find(ipstr) != std::string::npos) { + std::string ip( + line.replace(line.begin(), line.begin() + ipstr.length(), "")); + // cout << "ip=" << ip << endl; eths.back()["addr"] = ip; } const std::string macstr("\tmac "); - if(line.find(macstr) != std::string::npos) - { - std::string mac( line.replace(line.begin(), line.begin()+macstr.length(), "") ); -// cout << "mac=" << mac << endl; + if (line.find(macstr) != std::string::npos) { + std::string mac( + line.replace(line.begin(), line.begin() + macstr.length(), "")); + // cout << "mac=" << mac << endl; eths.back()["mac"] = mac; } const std::string vstr("\t\tvendor "); - if(line.find(vstr) != std::string::npos) - { - std::string vendor( line.replace(line.begin(), line.begin()+vstr.length(), "") ); - std::string vid( vendor.substr(0,6) ); + if (line.find(vstr) != std::string::npos) { + std::string vendor( + line.replace(line.begin(), line.begin() + vstr.length(), "")); + std::string vid(vendor.substr(0, 6)); vendor.replace(0, 7, ""); -// cout << "id=" << vid << endl; -// cout << "vendor=" << vendor << endl; - eths.back()["vendor"] = vendor; + // cout << "id=" << vid << endl; + // cout << "vendor=" << vendor << endl; + eths.back()["vendor"] = vendor; eths.back()["vendor_id"] = vid; } const std::string dstr("\t\tdevice "); - if(line.find(dstr) != std::string::npos) - { - std::string device( line.replace(line.begin(), line.begin()+dstr.length(), "") ); - std::string did( device.substr(0,6) ); + if (line.find(dstr) != std::string::npos) { + std::string device( + line.replace(line.begin(), line.begin() + dstr.length(), "")); + std::string did(device.substr(0, 6)); device.replace(0, 7, ""); -// cout << "id=" << did << endl; -// cout << "device=" << device << endl; - eths.back()["device"] = device; + // cout << "id=" << did << endl; + // cout << "device=" << device << endl; + eths.back()["device"] = device; eths.back()["device_id"] = did; } } - } - catch(...) - { + } catch (...) { // nothing in yet } return eths; } // get info on used USRP -uhd::device_addr_t -Responder::get_usrp_info() +uhd::device_addr_t Responder::get_usrp_info() { uhd::device_addrs_t device_addrs = uhd::device::find(_opt.device_args); - uhd::device_addr_t device_addr = device_addrs[0]; + uhd::device_addr_t device_addr = device_addrs[0]; return device_addr; } // write statistics of test run to file -void -Responder::write_statistics_to_file(StatsMap mapStats) +void Responder::write_statistics_to_file(StatsMap mapStats) { - try - { + try { ofstream results(_stats_filename.c_str()); - for (StatsMap::iterator it = mapStats.begin(); it != mapStats.end(); ++it) - { + for (StatsMap::iterator it = mapStats.begin(); it != mapStats.end(); ++it) { STATS& stats = it->second; - double d = 0.0; + double d = 0.0; if (stats.detected > 0) d = 1.0 - ((double)stats.missed / (double)stats.detected); - cout << "\t" << setprecision(6) << stats.delay << "\t\t" << setprecision(6) << d << endl; + cout << "\t" << setprecision(6) << stats.delay << "\t\t" << setprecision(6) + << d << endl; - results << (stats.delay * _opt.time_mul) << " " << setprecision(6) << d << endl; + results << (stats.delay * _opt.time_mul) << " " << setprecision(6) << d + << endl; } cout << "Statistics written to: " << _stats_filename << endl; - } - catch (...) - { + } catch (...) { cout << "Failed to write statistics to: " << _stats_filename << endl; } } // make sure write files is intended -void -Responder::safe_write_statistics_to_file(StatsMap mapStats, uint64_t max_success, int return_code) +void Responder::safe_write_statistics_to_file( + StatsMap mapStats, uint64_t max_success, int return_code) { - if ((_opt.test_iterations > 0) && (_stats_filename.empty() == false) && (_opt.no_stats_file == false)) - { - if (mapStats.empty()) - { + if ((_opt.test_iterations > 0) && (_stats_filename.empty() == false) + && (_opt.no_stats_file == false)) { + if (mapStats.empty()) { cout << "No results to output (not writing statistics file)" << endl; - } - else if ((max_success == 0) && (return_code == RETCODE_MANUAL_ABORT)) - { - cout << "Aborted before a single successful timed burst (not writing statistics file)" << endl; - } - else - { + } else if ((max_success == 0) && (return_code == RETCODE_MANUAL_ABORT)) { + cout << "Aborted before a single successful timed burst (not writing " + "statistics file)" + << endl; + } else { write_statistics_to_file(mapStats); } write_log_file(); @@ -1400,10 +1373,10 @@ Responder::safe_write_statistics_to_file(StatsMap mapStats, uint64_t max_success Responder::~Responder() { endwin(); - if(_pResponse != NULL){ + if (_pResponse != NULL) { delete[] _pResponse; } - time( &_dbginfo.end_time ); + time(&_dbginfo.end_time); // Print final info about test run print_final_statistics(); // check conditions and write statistics to file @@ -1412,21 +1385,27 @@ Responder::~Responder() } // make test output more helpful -std::string -Responder::enum2str(int return_code) +std::string Responder::enum2str(int return_code) { - switch(return_code) - { - case RETCODE_OK: return "OK"; - case RETCODE_BAD_ARGS: return "BAD_ARGS"; - case RETCODE_RUNTIME_ERROR: return "RUNTIME_ERROR"; - case RETCODE_UNKNOWN_EXCEPTION: return "UNKNOWN_EXCEPTION"; - case RETCODE_RECEIVE_TIMEOUT: return "RECEIVE_TIMEOUT"; - case RETCODE_RECEIVE_FAILED: return "RECEIVE_FAILED"; - case RETCODE_MANUAL_ABORT: return "MANUAL_ABORT"; - case RETCODE_BAD_PACKET: return "BAD_PACKET"; - case RETCODE_OVERFLOW: return "OVERFLOW"; + switch (return_code) { + case RETCODE_OK: + return "OK"; + case RETCODE_BAD_ARGS: + return "BAD_ARGS"; + case RETCODE_RUNTIME_ERROR: + return "RUNTIME_ERROR"; + case RETCODE_UNKNOWN_EXCEPTION: + return "UNKNOWN_EXCEPTION"; + case RETCODE_RECEIVE_TIMEOUT: + return "RECEIVE_TIMEOUT"; + case RETCODE_RECEIVE_FAILED: + return "RECEIVE_FAILED"; + case RETCODE_MANUAL_ABORT: + return "MANUAL_ABORT"; + case RETCODE_BAD_PACKET: + return "BAD_PACKET"; + case RETCODE_OVERFLOW: + return "OVERFLOW"; } return "UNKNOWN"; } - |