2019-04-26 19:27:38 +00:00
|
|
|
/*
|
2020-03-13 11:12:52 +00:00
|
|
|
* Copyright 2013-2020 Software Radio Systems Limited
|
2017-05-30 13:38:04 +00:00
|
|
|
*
|
2019-04-26 19:27:38 +00:00
|
|
|
* This file is part of srsLTE.
|
2017-05-30 13:38:04 +00:00
|
|
|
*
|
2019-04-26 19:27:38 +00:00
|
|
|
* srsLTE is free software: you can redistribute it and/or modify
|
2017-05-30 13:38:04 +00:00
|
|
|
* it under the terms of the GNU Affero General Public License as
|
|
|
|
* published by the Free Software Foundation, either version 3 of
|
|
|
|
* the License, or (at your option) any later version.
|
|
|
|
*
|
2019-04-26 19:27:38 +00:00
|
|
|
* srsLTE is distributed in the hope that it will be useful,
|
2017-05-30 13:38:04 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU Affero General Public License for more details.
|
|
|
|
*
|
|
|
|
* A copy of the GNU Affero General Public License can be found in
|
|
|
|
* the LICENSE file in the top-level directory of this distribution
|
|
|
|
* and at http://www.gnu.org/licenses/.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2018-04-01 16:08:24 +00:00
|
|
|
#include "srsue/hdr/metrics_stdout.h"
|
2017-05-30 13:38:04 +00:00
|
|
|
|
|
|
|
#include <float.h>
|
|
|
|
#include <iomanip>
|
|
|
|
#include <iostream>
|
2019-12-16 15:04:22 +00:00
|
|
|
#include <math.h>
|
|
|
|
#include <sstream>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <unistd.h>
|
2017-05-30 13:38:04 +00:00
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
|
2019-12-16 15:04:22 +00:00
|
|
|
namespace srsue {
|
|
|
|
|
|
|
|
char const* const prefixes[2][9] = {
|
|
|
|
{
|
|
|
|
"",
|
|
|
|
"m",
|
|
|
|
"u",
|
|
|
|
"n",
|
|
|
|
"p",
|
|
|
|
"f",
|
|
|
|
"a",
|
|
|
|
"z",
|
|
|
|
"y",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"",
|
|
|
|
"k",
|
|
|
|
"M",
|
|
|
|
"G",
|
|
|
|
"T",
|
|
|
|
"P",
|
|
|
|
"E",
|
|
|
|
"Z",
|
|
|
|
"Y",
|
|
|
|
},
|
2017-05-30 13:38:04 +00:00
|
|
|
};
|
|
|
|
|
2019-12-16 15:04:22 +00:00
|
|
|
void metrics_stdout::set_ue_handle(ue_metrics_interface* ue_)
|
2017-09-22 13:00:07 +00:00
|
|
|
{
|
|
|
|
ue = ue_;
|
|
|
|
}
|
|
|
|
|
2017-05-30 13:38:04 +00:00
|
|
|
void metrics_stdout::toggle_print(bool b)
|
|
|
|
{
|
|
|
|
do_print = b;
|
|
|
|
}
|
|
|
|
|
2020-09-30 14:29:31 +00:00
|
|
|
void metrics_stdout::print_table(const bool display_neighbours)
|
|
|
|
{
|
|
|
|
if (display_neighbours) {
|
|
|
|
cout << "--------Signal-------------Neighbour--DL-------------------------------------UL----------------------"
|
|
|
|
<< endl;
|
|
|
|
cout << "cc pci rsrp pl cfo pci rsrp mcs snr turbo brate bler ta_us mcs buff brate bler"
|
|
|
|
<< endl;
|
|
|
|
} else {
|
|
|
|
cout << "--------Signal--------------DL-------------------------------------UL----------------------" << endl;
|
|
|
|
cout << "cc pci rsrp pl cfo mcs snr turbo brate bler ta_us mcs buff brate bler" << endl;
|
|
|
|
}
|
|
|
|
table_has_neighbours = display_neighbours;
|
2020-10-02 15:00:19 +00:00
|
|
|
n_reports = 0;
|
2020-09-30 14:29:31 +00:00
|
|
|
}
|
|
|
|
|
2020-01-13 12:14:46 +00:00
|
|
|
void metrics_stdout::set_metrics(const ue_metrics_t& metrics, const uint32_t period_usec)
|
2017-05-30 13:38:04 +00:00
|
|
|
{
|
2019-12-03 09:34:00 +00:00
|
|
|
if (ue == nullptr) {
|
2017-09-22 13:00:07 +00:00
|
|
|
return;
|
2019-09-24 12:49:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// always print RF error
|
|
|
|
if (metrics.rf.rf_error) {
|
|
|
|
printf("RF status: O=%d, U=%d, L=%d\n", metrics.rf.rf_o, metrics.rf.rf_u, metrics.rf.rf_l);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!do_print) {
|
|
|
|
return;
|
|
|
|
}
|
2017-09-22 13:00:07 +00:00
|
|
|
|
2019-07-12 02:08:24 +00:00
|
|
|
if (metrics.stack.rrc.state != RRC_STATE_CONNECTED) {
|
2017-09-22 13:00:07 +00:00
|
|
|
cout << "--- disconnected ---" << endl;
|
2017-05-30 13:38:04 +00:00
|
|
|
return;
|
2017-09-22 13:00:07 +00:00
|
|
|
}
|
2017-05-30 13:38:04 +00:00
|
|
|
|
2020-06-17 10:11:06 +00:00
|
|
|
bool display_neighbours = false;
|
|
|
|
if (metrics.phy.nof_active_cc > 1) {
|
|
|
|
display_neighbours = metrics.stack.rrc.neighbour_cells.size() > metrics.phy.nof_active_cc - 1;
|
|
|
|
} else {
|
|
|
|
display_neighbours = metrics.stack.rrc.neighbour_cells.size() > 0;
|
|
|
|
}
|
|
|
|
|
2020-09-30 14:29:31 +00:00
|
|
|
// print table header every 10 reports
|
2019-12-16 15:04:22 +00:00
|
|
|
if (++n_reports > 10) {
|
2020-09-30 14:29:31 +00:00
|
|
|
print_table(display_neighbours);
|
2017-05-30 13:38:04 +00:00
|
|
|
}
|
2020-09-30 14:29:31 +00:00
|
|
|
|
|
|
|
// also print table header if neighbours are added/removed in between
|
|
|
|
if (display_neighbours != table_has_neighbours) {
|
|
|
|
print_table(display_neighbours);
|
|
|
|
}
|
|
|
|
|
2019-04-23 08:53:11 +00:00
|
|
|
for (uint32_t r = 0; r < metrics.phy.nof_active_cc; r++) {
|
2019-12-03 09:34:00 +00:00
|
|
|
cout << std::setw(2) << r;
|
|
|
|
cout << std::setw(4) << metrics.phy.info[r].pci << std::setw(0);
|
2020-09-22 12:32:08 +00:00
|
|
|
cout << float_to_string(metrics.phy.ch[r].rsrp, 2);
|
|
|
|
cout << float_to_string(metrics.phy.ch[r].pathloss, 2);
|
2019-05-17 11:03:29 +00:00
|
|
|
cout << float_to_eng_string(metrics.phy.sync[r].cfo, 2);
|
2020-06-17 10:11:06 +00:00
|
|
|
|
|
|
|
// Find strongest neighbour for this EARFCN (cells are ordered)
|
|
|
|
if (display_neighbours) {
|
|
|
|
bool has_neighbour = false;
|
|
|
|
for (auto& c : metrics.stack.rrc.neighbour_cells) {
|
|
|
|
if (c.earfcn == metrics.phy.info[r].dl_earfcn && c.pci != metrics.phy.info[r].pci) {
|
|
|
|
cout << std::setw(4) << c.pci << std::setw(0);
|
|
|
|
cout << float_to_string(c.rsrp, 2);
|
|
|
|
has_neighbour = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!has_neighbour) {
|
|
|
|
cout << " n/a";
|
|
|
|
cout << " n/a";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-23 08:53:11 +00:00
|
|
|
cout << float_to_string(metrics.phy.dl[r].mcs, 2);
|
2020-09-22 12:32:08 +00:00
|
|
|
cout << float_to_string(metrics.phy.ch[r].sinr, 2);
|
2019-04-23 08:53:11 +00:00
|
|
|
cout << float_to_string(metrics.phy.dl[r].turbo_iters, 2);
|
|
|
|
|
2020-03-16 15:29:16 +00:00
|
|
|
cout << float_to_eng_string((float)metrics.stack.mac[r].rx_brate / (metrics.stack.mac[r].nof_tti * 1e-3), 2);
|
2019-05-07 08:11:57 +00:00
|
|
|
if (metrics.stack.mac[r].rx_pkts > 0) {
|
|
|
|
cout << float_to_string((float)100 * metrics.stack.mac[r].rx_errors / metrics.stack.mac[r].rx_pkts, 1) << "%";
|
2019-04-23 08:53:11 +00:00
|
|
|
} else {
|
|
|
|
cout << float_to_string(0, 1) << "%";
|
|
|
|
}
|
|
|
|
|
2019-05-17 11:03:29 +00:00
|
|
|
cout << float_to_string(metrics.phy.sync[r].ta_us, 2);
|
2019-04-23 08:53:11 +00:00
|
|
|
|
|
|
|
cout << float_to_string(metrics.phy.ul[r].mcs, 2);
|
2019-05-07 08:11:57 +00:00
|
|
|
cout << float_to_eng_string((float)metrics.stack.mac[r].ul_buffer, 2);
|
2020-03-16 15:29:16 +00:00
|
|
|
cout << float_to_eng_string((float)metrics.stack.mac[r].tx_brate / (metrics.stack.mac[r].nof_tti * 1e-3), 2);
|
2019-05-07 08:11:57 +00:00
|
|
|
if (metrics.stack.mac[r].tx_pkts > 0) {
|
|
|
|
cout << float_to_string((float)100 * metrics.stack.mac[r].tx_errors / metrics.stack.mac[r].tx_pkts, 1) << "%";
|
2019-04-23 08:53:11 +00:00
|
|
|
} else {
|
|
|
|
cout << float_to_string(0, 1) << "%";
|
|
|
|
}
|
|
|
|
cout << endl;
|
2017-05-30 13:38:04 +00:00
|
|
|
}
|
|
|
|
|
2019-04-23 08:53:11 +00:00
|
|
|
if (metrics.rf.rf_error) {
|
2017-05-30 13:38:04 +00:00
|
|
|
printf("RF status: O=%d, U=%d, L=%d\n", metrics.rf.rf_o, metrics.rf.rf_u, metrics.rf.rf_l);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string metrics_stdout::float_to_string(float f, int digits)
|
|
|
|
{
|
|
|
|
std::ostringstream os;
|
2020-10-05 09:08:04 +00:00
|
|
|
const int precision =
|
|
|
|
SRSLTE_MIN((int)((f == 0.0f || f == 100.0f) ? digits - 1 : digits - log10f(fabsf(f)) - 2 * FLT_EPSILON), 3);
|
2017-05-30 13:38:04 +00:00
|
|
|
os << std::setw(6) << std::fixed << std::setprecision(precision) << f;
|
|
|
|
return os.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string metrics_stdout::float_to_eng_string(float f, int digits)
|
|
|
|
{
|
2019-11-28 13:27:31 +00:00
|
|
|
const int degree = (f == 0.0) ? 0 : lrint(floor(log10f(fabs(f)) / 3));
|
2017-05-30 13:38:04 +00:00
|
|
|
|
|
|
|
std::string factor;
|
|
|
|
|
2019-02-21 15:27:53 +00:00
|
|
|
if (abs(degree) < 9) {
|
2019-12-16 15:04:22 +00:00
|
|
|
if (degree < 0)
|
|
|
|
factor = prefixes[0][abs(degree)];
|
2017-05-30 13:38:04 +00:00
|
|
|
else
|
2019-12-16 15:04:22 +00:00
|
|
|
factor = prefixes[1][abs(degree)];
|
2017-05-30 13:38:04 +00:00
|
|
|
} else {
|
|
|
|
return "failed";
|
|
|
|
}
|
|
|
|
|
2019-12-16 15:04:22 +00:00
|
|
|
const double scaled = f * pow(1000.0, -degree);
|
2017-05-30 13:38:04 +00:00
|
|
|
if (degree != 0) {
|
|
|
|
return float_to_string(scaled, digits) + factor;
|
|
|
|
} else {
|
|
|
|
return " " + float_to_string(scaled, digits) + factor;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace srsue
|