From 967be2a4e82b1a125b26bb72a60318a4fb2b50c4 Mon Sep 17 00:00:00 2001 From: Brent Stapleton Date: Mon, 14 Jan 2019 10:35:25 -0800 Subject: uhd: mpm: apply clang-format to all files Applying formatting changes to all .cpp and .hpp files in the following directories: ``` find host/examples/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file find host/tests/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file find host/lib/usrp/dboard/neon/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file find host/lib/usrp/dboard/magnesium/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file find host/lib/usrp/device3/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file find host/lib/usrp/mpmd/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file find host/lib/usrp/x300/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file find host/utils/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file find mpm/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file ``` Also formatted host/include/, except Cpp03 was used as a the language standard instead of Cpp11. ``` sed -i 's/ Cpp11/ Cpp03/g' .clang-format find host/include/ -iname *.hpp -o -iname *.cpp | \ xargs clang-format -i -style=file ``` Formatting style was designated by the .clang-format file. --- host/examples/benchmark_rate.cpp | 571 +++++++++++++++++++-------------------- 1 file changed, 277 insertions(+), 294 deletions(-) (limited to 'host/examples/benchmark_rate.cpp') diff --git a/host/examples/benchmark_rate.cpp b/host/examples/benchmark_rate.cpp index 5e997f59a..b97de09ac 100644 --- a/host/examples/benchmark_rate.cpp +++ b/host/examples/benchmark_rate.cpp @@ -5,49 +5,50 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include #include -#include #include -#include -#include -#include +#include +#include #include #include -#include -#include -#include +#include +#include +#include #include #include +#include +#include +#include #include namespace po = boost::program_options; namespace { - constexpr int64_t CLOCK_TIMEOUT = 1000; // 1000mS timeout for external clock locking - constexpr float INIT_DELAY = 0.05; // 50mS initial delay before transmit -} +constexpr int64_t CLOCK_TIMEOUT = 1000; // 1000mS timeout for external clock locking +constexpr float INIT_DELAY = 0.05; // 50mS initial delay before transmit +} // namespace /*********************************************************************** * Test result variables **********************************************************************/ -unsigned long long num_overruns = 0; -unsigned long long num_underruns = 0; -unsigned long long num_rx_samps = 0; -unsigned long long num_tx_samps = 0; +unsigned long long num_overruns = 0; +unsigned long long num_underruns = 0; +unsigned long long num_rx_samps = 0; +unsigned long long num_tx_samps = 0; unsigned long long num_dropped_samps = 0; -unsigned long long num_seq_errors = 0; -unsigned long long num_seqrx_errors = 0; // "D"s +unsigned long long num_seq_errors = 0; +unsigned long long num_seqrx_errors = 0; // "D"s unsigned long long num_late_commands = 0; -unsigned long long num_timeouts_rx = 0; -unsigned long long num_timeouts_tx = 0; +unsigned long long num_timeouts_rx = 0; +unsigned long long num_timeouts_tx = 0; -inline boost::posix_time::time_duration time_delta(const boost::posix_time::ptime &ref_time) +inline boost::posix_time::time_duration time_delta( + const boost::posix_time::ptime& ref_time) { return boost::posix_time::microsec_clock::local_time() - ref_time; } -inline std::string time_delta_str(const boost::posix_time::ptime &ref_time) +inline std::string time_delta_str(const boost::posix_time::ptime& ref_time) { return boost::posix_time::to_simple_string(time_delta(ref_time)); } @@ -57,44 +58,45 @@ inline std::string time_delta_str(const boost::posix_time::ptime &ref_time) /*********************************************************************** * Benchmark RX Rate **********************************************************************/ -void benchmark_rx_rate( - uhd::usrp::multi_usrp::sptr usrp, - const std::string &rx_cpu, - uhd::rx_streamer::sptr rx_stream, - bool random_nsamps, - const boost::posix_time::ptime &start_time, - std::atomic& burst_timer_elapsed -) { +void benchmark_rx_rate(uhd::usrp::multi_usrp::sptr usrp, + const std::string& rx_cpu, + uhd::rx_streamer::sptr rx_stream, + bool random_nsamps, + const boost::posix_time::ptime& start_time, + std::atomic& burst_timer_elapsed) +{ uhd::set_thread_priority_safe(); - //print pre-test summary - std::cout << boost::format( - "[%s] Testing receive rate %f Msps on %u channels" - ) % NOW() % (usrp->get_rx_rate()/1e6) % rx_stream->get_num_channels() << std::endl; + // print pre-test summary + std::cout << boost::format("[%s] Testing receive rate %f Msps on %u channels") % NOW() + % (usrp->get_rx_rate() / 1e6) % rx_stream->get_num_channels() + << std::endl; - //setup variables and allocate buffer + // setup variables and allocate buffer uhd::rx_metadata_t md; const size_t max_samps_per_packet = rx_stream->get_max_num_samps(); - std::vector buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(rx_cpu)); - std::vector buffs; + std::vector buff( + max_samps_per_packet * uhd::convert::get_bytes_per_item(rx_cpu)); + std::vector buffs; for (size_t ch = 0; ch < rx_stream->get_num_channels(); ch++) - buffs.push_back(&buff.front()); //same buffer for each channel + buffs.push_back(&buff.front()); // same buffer for each channel bool had_an_overflow = false; uhd::time_spec_t last_time; const double rate = usrp->get_rx_rate(); uhd::stream_cmd_t cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS); - cmd.time_spec = usrp->get_time_now() + uhd::time_spec_t(INIT_DELAY); + cmd.time_spec = usrp->get_time_now() + uhd::time_spec_t(INIT_DELAY); cmd.stream_now = (buffs.size() == 1); rx_stream->issue_stream_cmd(cmd); const float burst_pkt_time = - std::max(0.100f, (2 * max_samps_per_packet/rate)); + std::max(0.100f, (2 * max_samps_per_packet / rate)); float recv_timeout = burst_pkt_time + INIT_DELAY; bool stop_called = false; while (true) { - //if (burst_timer_elapsed.load(boost::memory_order_relaxed) and not stop_called) { + // if (burst_timer_elapsed.load(boost::memory_order_relaxed) and not stop_called) + // { if (burst_timer_elapsed and not stop_called) { rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS); stop_called = true; @@ -104,71 +106,78 @@ void benchmark_rx_rate( rx_stream->issue_stream_cmd(cmd); } try { - num_rx_samps += rx_stream->recv(buffs, max_samps_per_packet, md, recv_timeout)*rx_stream->get_num_channels(); + num_rx_samps += rx_stream->recv(buffs, max_samps_per_packet, md, recv_timeout) + * rx_stream->get_num_channels(); recv_timeout = burst_pkt_time; - } - catch (uhd::io_error &e) { + } catch (uhd::io_error& e) { std::cerr << "[" << NOW() << "] Caught an IO exception. " << std::endl; std::cerr << e.what() << std::endl; return; } - //handle the error codes - switch(md.error_code){ - case uhd::rx_metadata_t::ERROR_CODE_NONE: - if (had_an_overflow) { - had_an_overflow = false; - const long dropped_samps = - (md.time_spec - last_time).to_ticks(rate); - if (dropped_samps < 0) { - std::cerr - << "[" << NOW() << "] Timestamp after overrun recovery " - "ahead of error timestamp! Unable to calculate " - "number of dropped samples." - "(Delta: " << dropped_samps << " ticks)\n"; + // handle the error codes + switch (md.error_code) { + case uhd::rx_metadata_t::ERROR_CODE_NONE: + if (had_an_overflow) { + had_an_overflow = false; + const long dropped_samps = (md.time_spec - last_time).to_ticks(rate); + if (dropped_samps < 0) { + std::cerr << "[" << NOW() + << "] Timestamp after overrun recovery " + "ahead of error timestamp! Unable to calculate " + "number of dropped samples." + "(Delta: " + << dropped_samps << " ticks)\n"; + } + num_dropped_samps += std::max(1, dropped_samps); } - num_dropped_samps += std::max(1, dropped_samps); - } - if ((burst_timer_elapsed or stop_called) and md.end_of_burst) { - return; - } - break; - - // ERROR_CODE_OVERFLOW can indicate overflow or sequence error - case uhd::rx_metadata_t::ERROR_CODE_OVERFLOW: - last_time = md.time_spec; - had_an_overflow = true; - // check out_of_sequence flag to see if it was a sequence error or overflow - if (!md.out_of_sequence) { - num_overruns++; - } else { - num_seqrx_errors++; - std::cerr << "[" << NOW() << "] Detected Rx sequence error." << std::endl; - } - break; - - case uhd::rx_metadata_t::ERROR_CODE_LATE_COMMAND: - std::cerr << "[" << NOW() << "] Receiver error: " << md.strerror() << ", restart streaming..."<< std::endl; - num_late_commands++; - // Radio core will be in the idle state. Issue stream command to restart streaming. - cmd.time_spec = usrp->get_time_now() + uhd::time_spec_t(0.05); - cmd.stream_now = (buffs.size() == 1); - rx_stream->issue_stream_cmd(cmd); - break; - - case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT: - if (burst_timer_elapsed) { - return; - } - std::cerr << "[" << NOW() << "] Receiver error: " << md.strerror() << ", continuing..." << std::endl; - num_timeouts_rx++; - break; - - // Otherwise, it's an error - default: - std::cerr << "[" << NOW() << "] Receiver error: " << md.strerror() << std::endl; - std::cerr << "[" << NOW() << "] Unexpected error on recv, continuing..." << std::endl; - break; + if ((burst_timer_elapsed or stop_called) and md.end_of_burst) { + return; + } + break; + + // ERROR_CODE_OVERFLOW can indicate overflow or sequence error + case uhd::rx_metadata_t::ERROR_CODE_OVERFLOW: + last_time = md.time_spec; + had_an_overflow = true; + // check out_of_sequence flag to see if it was a sequence error or + // overflow + if (!md.out_of_sequence) { + num_overruns++; + } else { + num_seqrx_errors++; + std::cerr << "[" << NOW() << "] Detected Rx sequence error." + << std::endl; + } + break; + + case uhd::rx_metadata_t::ERROR_CODE_LATE_COMMAND: + std::cerr << "[" << NOW() << "] Receiver error: " << md.strerror() + << ", restart streaming..." << std::endl; + num_late_commands++; + // Radio core will be in the idle state. Issue stream command to restart + // streaming. + cmd.time_spec = usrp->get_time_now() + uhd::time_spec_t(0.05); + cmd.stream_now = (buffs.size() == 1); + rx_stream->issue_stream_cmd(cmd); + break; + + case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT: + if (burst_timer_elapsed) { + return; + } + std::cerr << "[" << NOW() << "] Receiver error: " << md.strerror() + << ", continuing..." << std::endl; + num_timeouts_rx++; + break; + + // Otherwise, it's an error + default: + std::cerr << "[" << NOW() << "] Receiver error: " << md.strerror() + << std::endl; + std::cerr << "[" << NOW() << "] Unexpected error on recv, continuing..." + << std::endl; + break; } } } @@ -176,71 +185,75 @@ void benchmark_rx_rate( /*********************************************************************** * Benchmark TX Rate **********************************************************************/ -void benchmark_tx_rate( - uhd::usrp::multi_usrp::sptr usrp, - const std::string &tx_cpu, - uhd::tx_streamer::sptr tx_stream, - std::atomic& burst_timer_elapsed, - const boost::posix_time::ptime &start_time, - bool random_nsamps=false -) { +void benchmark_tx_rate(uhd::usrp::multi_usrp::sptr usrp, + const std::string& tx_cpu, + uhd::tx_streamer::sptr tx_stream, + std::atomic& burst_timer_elapsed, + const boost::posix_time::ptime& start_time, + bool random_nsamps = false) +{ uhd::set_thread_priority_safe(); - //print pre-test summary - std::cout << boost::format( - "[%s] Testing transmit rate %f Msps on %u channels" - ) % NOW() % (usrp->get_tx_rate()/1e6) % tx_stream->get_num_channels() << std::endl; + // print pre-test summary + std::cout << boost::format("[%s] Testing transmit rate %f Msps on %u channels") + % NOW() % (usrp->get_tx_rate() / 1e6) % tx_stream->get_num_channels() + << std::endl; - //setup variables and allocate buffer + // setup variables and allocate buffer const size_t max_samps_per_packet = tx_stream->get_max_num_samps(); - std::vector buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(tx_cpu)); - std::vector buffs; + std::vector buff( + max_samps_per_packet * uhd::convert::get_bytes_per_item(tx_cpu)); + std::vector buffs; for (size_t ch = 0; ch < tx_stream->get_num_channels(); ch++) - buffs.push_back(&buff.front()); //same buffer for each channel + buffs.push_back(&buff.front()); // same buffer for each channel // Create the metadata, and populate the time spec at the latest possible moment uhd::tx_metadata_t md; md.has_time_spec = (buffs.size() != 1); - md.time_spec = usrp->get_time_now() + uhd::time_spec_t(INIT_DELAY); + md.time_spec = usrp->get_time_now() + uhd::time_spec_t(INIT_DELAY); if (random_nsamps) { std::srand((unsigned int)time(NULL)); while (not burst_timer_elapsed) { size_t total_num_samps = rand() % max_samps_per_packet; - size_t num_acc_samps = 0; - const float timeout = 1; + size_t num_acc_samps = 0; + const float timeout = 1; usrp->set_time_now(uhd::time_spec_t(0.0)); - while(num_acc_samps < total_num_samps){ - //send a single packet - num_tx_samps += tx_stream->send(buffs, max_samps_per_packet, md, timeout)*tx_stream->get_num_channels(); - num_acc_samps += std::min(total_num_samps-num_acc_samps, tx_stream->get_max_num_samps()); + while (num_acc_samps < total_num_samps) { + // send a single packet + num_tx_samps += tx_stream->send(buffs, max_samps_per_packet, md, timeout) + * tx_stream->get_num_channels(); + num_acc_samps += std::min( + total_num_samps - num_acc_samps, tx_stream->get_max_num_samps()); } } } else { while (not burst_timer_elapsed) { - const size_t num_tx_samps_sent_now = tx_stream->send(buffs, max_samps_per_packet, md)*tx_stream->get_num_channels(); + const size_t num_tx_samps_sent_now = + tx_stream->send(buffs, max_samps_per_packet, md) + * tx_stream->get_num_channels(); num_tx_samps += num_tx_samps_sent_now; if (num_tx_samps_sent_now == 0) { num_timeouts_tx++; if ((num_timeouts_tx % 10000) == 1) { - std::cerr << "[" << NOW() << "] Tx timeouts: " << num_timeouts_tx << std::endl; + std::cerr << "[" << NOW() << "] Tx timeouts: " << num_timeouts_tx + << std::endl; } } md.has_time_spec = false; } } - //send a mini EOB packet + // send a mini EOB packet md.end_of_burst = true; tx_stream->send(buffs, 0, md); } -void benchmark_tx_rate_async_helper( - uhd::tx_streamer::sptr tx_stream, - const boost::posix_time::ptime &start_time, - std::atomic& burst_timer_elapsed -) { - //setup variables and allocate buffer +void benchmark_tx_rate_async_helper(uhd::tx_streamer::sptr tx_stream, + const boost::posix_time::ptime& start_time, + std::atomic& burst_timer_elapsed) +{ + // setup variables and allocate buffer uhd::async_metadata_t async_md; bool exit_flag = false; @@ -255,25 +268,26 @@ void benchmark_tx_rate_async_helper( continue; } - //handle the error codes - switch(async_md.event_code){ - case uhd::async_metadata_t::EVENT_CODE_BURST_ACK: - return; - - case uhd::async_metadata_t::EVENT_CODE_UNDERFLOW: - case uhd::async_metadata_t::EVENT_CODE_UNDERFLOW_IN_PACKET: - num_underruns++; - break; - - case uhd::async_metadata_t::EVENT_CODE_SEQ_ERROR: - case uhd::async_metadata_t::EVENT_CODE_SEQ_ERROR_IN_BURST: - num_seq_errors++; - break; + // handle the error codes + switch (async_md.event_code) { + case uhd::async_metadata_t::EVENT_CODE_BURST_ACK: + return; - default: - std::cerr << "[" << NOW() << "] Event code: " << async_md.event_code << std::endl; - std::cerr << "Unexpected event on async recv, continuing..." << std::endl; - break; + case uhd::async_metadata_t::EVENT_CODE_UNDERFLOW: + case uhd::async_metadata_t::EVENT_CODE_UNDERFLOW_IN_PACKET: + num_underruns++; + break; + + case uhd::async_metadata_t::EVENT_CODE_SEQ_ERROR: + case uhd::async_metadata_t::EVENT_CODE_SEQ_ERROR_IN_BURST: + num_seq_errors++; + break; + + default: + std::cerr << "[" << NOW() << "] Event code: " << async_md.event_code + << std::endl; + std::cerr << "Unexpected event on async recv, continuing..." << std::endl; + break; } } } @@ -281,10 +295,11 @@ void benchmark_tx_rate_async_helper( /*********************************************************************** * Main code + dispatcher **********************************************************************/ -int UHD_SAFE_MAIN(int argc, char *argv[]){ +int UHD_SAFE_MAIN(int argc, char* argv[]) +{ uhd::set_thread_priority_safe(); - //variables to be set by po + // variables to be set by po std::string args; std::string rx_subdev, tx_subdev; double duration; @@ -297,7 +312,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){ std::atomic burst_timer_elapsed(false); size_t overrun_threshold, underrun_threshold, drop_threshold, seq_threshold; - //setup the program options + // setup the program options po::options_description desc("Allowed options"); // clang-format off desc.add_options() @@ -333,45 +348,52 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){ po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); - //print the help message - if (vm.count("help") or (vm.count("rx_rate") + vm.count("tx_rate")) == 0){ + // print the help message + if (vm.count("help") or (vm.count("rx_rate") + vm.count("tx_rate")) == 0) { std::cout << boost::format("UHD Benchmark Rate %s") % desc << std::endl; - std::cout << - " Specify --rx_rate for a receive-only test.\n" - " Specify --tx_rate for a transmit-only test.\n" - " Specify both options for a full-duplex test.\n" - << std::endl; + std::cout << " Specify --rx_rate for a receive-only test.\n" + " Specify --tx_rate for a transmit-only test.\n" + " Specify both options for a full-duplex test.\n" + << std::endl; return ~0; } // Random number of samples? if (vm.count("random")) { - std::cout << "Using random number of samples in send() and recv() calls." << std::endl; + std::cout << "Using random number of samples in send() and recv() calls." + << std::endl; random_nsamps = true; } if (vm.count("mode")) { if (vm.count("pps") or vm.count("ref")) { - std::cout << "ERROR: The \"mode\" parameter cannot be used with the \"ref\" and \"pps\" parameters.\n" << std::endl; + std::cout << "ERROR: The \"mode\" parameter cannot be used with the \"ref\" " + "and \"pps\" parameters.\n" + << std::endl; return -1; } else if (mode == "mimo") { ref = pps = "mimo"; - std::cout << "The use of the \"mode\" parameter is deprecated. Please use \"ref\" and \"pps\" parameters instead\n" << std::endl; + std::cout << "The use of the \"mode\" parameter is deprecated. Please use " + "\"ref\" and \"pps\" parameters instead\n" + << std::endl; } } - //create a usrp device + // create a usrp device std::cout << std::endl; uhd::device_addrs_t device_addrs = uhd::device::find(args, uhd::device::USRP); - if (not device_addrs.empty() and device_addrs.at(0).get("type", "") == "usrp1"){ + if (not device_addrs.empty() and device_addrs.at(0).get("type", "") == "usrp1") { std::cerr << "*** Warning! ***" << std::endl; - std::cerr << "Benchmark results will be inaccurate on USRP1 due to insufficient features.\n" << std::endl; + std::cerr << "Benchmark results will be inaccurate on USRP1 due to insufficient " + "features.\n" + << std::endl; } boost::posix_time::ptime start_time(boost::posix_time::microsec_clock::local_time()); - std::cout << boost::format("[%s] Creating the usrp device with: %s...") % NOW() % args << std::endl; + std::cout << boost::format("[%s] Creating the usrp device with: %s...") % NOW() % args + << std::endl; uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args); - //always select the subdevice first, the channel mapping affects the other settings + // always select the subdevice first, the channel mapping affects the other settings if (vm.count("rx_subdev")) { usrp->set_rx_subdev_spec(rx_subdev); } @@ -384,34 +406,35 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){ boost::thread_group thread_group; - if(vm.count("ref")) - { - if (ref == "mimo") - { + if (vm.count("ref")) { + if (ref == "mimo") { if (num_mboards != 2) { - std::cerr << "ERROR: ref = \"mimo\" implies 2 motherboards; your system has " << num_mboards << " boards" << std::endl; + std::cerr + << "ERROR: ref = \"mimo\" implies 2 motherboards; your system has " + << num_mboards << " boards" << std::endl; return -1; } - usrp->set_clock_source("mimo",1); + usrp->set_clock_source("mimo", 1); } else { usrp->set_clock_source(ref); } - if(ref != "internal") { + if (ref != "internal") { std::cout << "Now confirming lock on clock signals..." << std::endl; bool is_locked = false; auto end_time = - boost::get_system_time() + - boost::posix_time::milliseconds(CLOCK_TIMEOUT); + boost::get_system_time() + boost::posix_time::milliseconds(CLOCK_TIMEOUT); for (int i = 0; i < num_mboards; i++) { - if (ref == "mimo" and i == 0) continue; - while((is_locked = usrp->get_mboard_sensor("ref_locked",i).to_bool()) == false and - boost::get_system_time() < end_time ) - { + if (ref == "mimo" and i == 0) + continue; + while ((is_locked = usrp->get_mboard_sensor("ref_locked", i).to_bool()) + == false + and boost::get_system_time() < end_time) { std::this_thread::sleep_for(std::chrono::milliseconds(1)); } if (is_locked == false) { - std::cerr << "ERROR: Unable to confirm clock signal locked on board:" << i << std::endl; + std::cerr << "ERROR: Unable to confirm clock signal locked on board:" + << i << std::endl; return -1; } is_locked = false; @@ -419,22 +442,22 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){ } } - if(vm.count("pps")) - { - if(pps == "mimo") - { - if (num_mboards != 2) { - std::cerr << "ERROR: ref = \"mimo\" implies 2 motherboards; your system has " << num_mboards << " boards" << std::endl; - return -1; - } - //make mboard 1 a slave over the MIMO Cable - usrp->set_time_source("mimo", 1); - } else { - usrp->set_time_source(pps); - } + if (vm.count("pps")) { + if (pps == "mimo") { + if (num_mboards != 2) { + std::cerr + << "ERROR: ref = \"mimo\" implies 2 motherboards; your system has " + << num_mboards << " boards" << std::endl; + return -1; + } + // make mboard 1 a slave over the MIMO Cable + usrp->set_time_source("mimo", 1); + } else { + usrp->set_time_source(pps); + } } - //check that the device has sufficient RX and TX channels available + // check that the device has sufficient RX and TX channels available std::vector channel_strings; std::vector rx_channel_nums; if (vm.count("rx_rate")) { @@ -470,7 +493,8 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){ } } - std::cout << boost::format("[%s] Setting device timestamp to 0...") % NOW() << std::endl; + std::cout << boost::format("[%s] Setting device timestamp to 0...") % NOW() + << std::endl; if (pps == "mimo" or ref == "mimo") { // only set the master's time, the slave's is automatically sync'd usrp->set_time_now(uhd::time_spec_t(0.0), 0); @@ -484,144 +508,103 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){ usrp->set_time_now(0.0); } - //spawn the receive test thread - if (vm.count("rx_rate")){ + // spawn the receive test thread + if (vm.count("rx_rate")) { usrp->set_rx_rate(rx_rate); - //create a receive streamer + // create a receive streamer uhd::stream_args_t stream_args(rx_cpu, rx_otw); - stream_args.channels = rx_channel_nums; + stream_args.channels = rx_channel_nums; uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); - auto rx_thread = thread_group.create_thread([=, &burst_timer_elapsed](){ + auto rx_thread = thread_group.create_thread([=, &burst_timer_elapsed]() { benchmark_rx_rate( - usrp, - rx_cpu, - rx_stream, - random_nsamps, - start_time, - burst_timer_elapsed - ); + usrp, rx_cpu, rx_stream, random_nsamps, start_time, burst_timer_elapsed); }); uhd::set_thread_name(rx_thread, "bmark_rx_stream"); } - //spawn the transmit test thread - if (vm.count("tx_rate")){ + // spawn the transmit test thread + if (vm.count("tx_rate")) { usrp->set_tx_rate(tx_rate); - //create a transmit streamer + // create a transmit streamer uhd::stream_args_t stream_args(tx_cpu, tx_otw); - stream_args.channels = tx_channel_nums; + stream_args.channels = tx_channel_nums; uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args); - auto tx_thread = thread_group.create_thread([=, &burst_timer_elapsed](){ + auto tx_thread = thread_group.create_thread([=, &burst_timer_elapsed]() { benchmark_tx_rate( - usrp, - tx_cpu, - tx_stream, - burst_timer_elapsed, - start_time, - random_nsamps - ); + usrp, tx_cpu, tx_stream, burst_timer_elapsed, start_time, random_nsamps); }); uhd::set_thread_name(tx_thread, "bmark_tx_stream"); - auto tx_async_thread = thread_group.create_thread([=, &burst_timer_elapsed](){ - benchmark_tx_rate_async_helper( - tx_stream, - start_time, - burst_timer_elapsed - ); + auto tx_async_thread = thread_group.create_thread([=, &burst_timer_elapsed]() { + benchmark_tx_rate_async_helper(tx_stream, start_time, burst_timer_elapsed); }); uhd::set_thread_name(tx_async_thread, "bmark_tx_helper"); } - //sleep for the required duration + // sleep for the required duration const bool wait_for_multichan = (rx_channel_nums.size() <= 1 and tx_channel_nums.size() <= 1); - const int64_t secs = - int64_t(duration + (wait_for_multichan ? 0 : INIT_DELAY * 1000)); - const int64_t usecs = int64_t((duration - secs)*1e6); + const int64_t secs = int64_t(duration + (wait_for_multichan ? 0 : INIT_DELAY * 1000)); + const int64_t usecs = int64_t((duration - secs) * 1e6); std::this_thread::sleep_for( - std::chrono::seconds(secs) + - std::chrono::microseconds(usecs) - ); + std::chrono::seconds(secs) + std::chrono::microseconds(usecs)); - //interrupt and join the threads + // interrupt and join the threads burst_timer_elapsed = true; thread_group.join_all(); std::cout << "[" << NOW() << "] Benchmark complete." << std::endl << std::endl; - //print summary + // print summary const std::string threshold_err(" ERROR: Exceeds threshold!"); - const bool overrun_threshold_err = - vm.count("overrun-threshold") and - num_overruns > overrun_threshold; - const bool underrun_threshold_err = - vm.count("underrun-threshold") and - num_underruns > underrun_threshold; - const bool drop_threshold_err = - vm.count("drop-threshold") and - num_seqrx_errors > drop_threshold; - const bool seq_threshold_err = - vm.count("seq-threshold") and - num_seq_errors > seq_threshold; + const bool overrun_threshold_err = vm.count("overrun-threshold") + and num_overruns > overrun_threshold; + const bool underrun_threshold_err = vm.count("underrun-threshold") + and num_underruns > underrun_threshold; + const bool drop_threshold_err = vm.count("drop-threshold") + and num_seqrx_errors > drop_threshold; + const bool seq_threshold_err = vm.count("seq-threshold") + and num_seq_errors > seq_threshold; std::cout << std::endl - << boost::format( - "Benchmark rate summary:\n" - " Num received samples: %u\n" - " Num dropped samples: %u\n" - " Num overruns detected: %u\n" - " Num transmitted samples: %u\n" - " Num sequence errors (Tx): %u\n" - " Num sequence errors (Rx): %u\n" - " Num underruns detected: %u\n" - " Num late commands: %u\n" - " Num timeouts (Tx): %u\n" - " Num timeouts (Rx): %u\n" - ) % num_rx_samps - % num_dropped_samps - % num_overruns - % num_tx_samps - % num_seq_errors - % num_seqrx_errors - % num_underruns - % num_late_commands - % num_timeouts_tx - % num_timeouts_rx - << std::endl; - //finished + << boost::format("Benchmark rate summary:\n" + " Num received samples: %u\n" + " Num dropped samples: %u\n" + " Num overruns detected: %u\n" + " Num transmitted samples: %u\n" + " Num sequence errors (Tx): %u\n" + " Num sequence errors (Rx): %u\n" + " Num underruns detected: %u\n" + " Num late commands: %u\n" + " Num timeouts (Tx): %u\n" + " Num timeouts (Rx): %u\n") + % num_rx_samps % num_dropped_samps % num_overruns % num_tx_samps + % num_seq_errors % num_seqrx_errors % num_underruns + % num_late_commands % num_timeouts_tx % num_timeouts_rx + << std::endl; + // finished std::cout << std::endl << "Done!" << std::endl << std::endl; - if (overrun_threshold_err - || underrun_threshold_err - || drop_threshold_err - || seq_threshold_err) { + if (overrun_threshold_err || underrun_threshold_err || drop_threshold_err + || seq_threshold_err) { std::cout << "The following error thresholds were exceeded:\n"; if (overrun_threshold_err) { - std::cout - << boost::format(" * Overruns (%d/%d)") - % num_overruns - % overrun_threshold - << std::endl; + std::cout << boost::format(" * Overruns (%d/%d)") % num_overruns + % overrun_threshold + << std::endl; } if (underrun_threshold_err) { - std::cout - << boost::format(" * Underruns (%d/%d)") - % num_underruns - % underrun_threshold - << std::endl; + std::cout << boost::format(" * Underruns (%d/%d)") % num_underruns + % underrun_threshold + << std::endl; } if (drop_threshold_err) { - std::cout - << boost::format(" * Dropped packets (RX) (%d/%d)") - % num_seqrx_errors - % drop_threshold - << std::endl; + std::cout << boost::format(" * Dropped packets (RX) (%d/%d)") + % num_seqrx_errors % drop_threshold + << std::endl; } if (seq_threshold_err) { - std::cout - << boost::format(" * Dropped packets (TX) (%d/%d)") - % num_seq_errors - % seq_threshold - << std::endl; + std::cout << boost::format(" * Dropped packets (TX) (%d/%d)") + % num_seq_errors % seq_threshold + << std::endl; } return EXIT_FAILURE; } -- cgit v1.2.3