From d1735360bc7bfb04be56f2b255a0b84b4db31b84 Mon Sep 17 00:00:00 2001
From: Tom Rondeau <trondeau@vt.edu>
Date: Fri, 15 Feb 2013 16:24:39 -0500
Subject: core: adding variance calcs to perf. counters.
Using running mean/variance algorithm from Knuth's Art of Computer Programming.
---
gnuradio-core/src/lib/runtime/gr_block.cc | 85 ++++++++++++++
gnuradio-core/src/lib/runtime/gr_block.h | 41 ++++++-
gnuradio-core/src/lib/runtime/gr_block_detail.cc | 137 ++++++++++++++++++++---
gnuradio-core/src/lib/runtime/gr_block_detail.h | 15 +++
4 files changed, 260 insertions(+), 18 deletions(-)
(limited to 'gnuradio-core/src')
diff --git a/gnuradio-core/src/lib/runtime/gr_block.cc b/gnuradio-core/src/lib/runtime/gr_block.cc
index f52f7a6baa..54d2676203 100644
--- a/gnuradio-core/src/lib/runtime/gr_block.cc
+++ b/gnuradio-core/src/lib/runtime/gr_block.cc
@@ -281,6 +281,17 @@ gr_block::pc_noutput_items()
}
}
+float
+gr_block::pc_noutput_items_var()
+{
+ if(d_detail) {
+ return d_detail->pc_noutput_items_var();
+ }
+ else {
+ return 0;
+ }
+}
+
float
gr_block::pc_nproduced()
{
@@ -292,6 +303,17 @@ gr_block::pc_nproduced()
}
}
+float
+gr_block::pc_nproduced_var()
+{
+ if(d_detail) {
+ return d_detail->pc_nproduced_var();
+ }
+ else {
+ return 0;
+ }
+}
+
float
gr_block::pc_input_buffers_full(int which)
{
@@ -303,6 +325,17 @@ gr_block::pc_input_buffers_full(int which)
}
}
+float
+gr_block::pc_input_buffers_full_var(int which)
+{
+ if(d_detail) {
+ return d_detail->pc_input_buffers_full_var(static_cast<size_t>(which));
+ }
+ else {
+ return 0;
+ }
+}
+
std::vector<float>
gr_block::pc_input_buffers_full()
{
@@ -314,6 +347,17 @@ gr_block::pc_input_buffers_full()
}
}
+std::vector<float>
+gr_block::pc_input_buffers_full_var()
+{
+ if(d_detail) {
+ return d_detail->pc_input_buffers_full_var();
+ }
+ else {
+ return std::vector<float>(1,0);
+ }
+}
+
float
gr_block::pc_output_buffers_full(int which)
{
@@ -325,6 +369,17 @@ gr_block::pc_output_buffers_full(int which)
}
}
+float
+gr_block::pc_output_buffers_full_var(int which)
+{
+ if(d_detail) {
+ return d_detail->pc_output_buffers_full_var(static_cast<size_t>(which));
+ }
+ else {
+ return 0;
+ }
+}
+
std::vector<float>
gr_block::pc_output_buffers_full()
{
@@ -336,6 +391,17 @@ gr_block::pc_output_buffers_full()
}
}
+std::vector<float>
+gr_block::pc_output_buffers_full_var()
+{
+ if(d_detail) {
+ return d_detail->pc_output_buffers_full_var();
+ }
+ else {
+ return std::vector<float>(1,0);
+ }
+}
+
float
gr_block::pc_work_time()
{
@@ -347,6 +413,25 @@ gr_block::pc_work_time()
}
}
+float
+gr_block::pc_work_time_var()
+{
+ if(d_detail) {
+ return d_detail->pc_work_time_var();
+ }
+ else {
+ return 0;
+ }
+}
+
+void
+gr_block::reset_perf_counters()
+{
+ if(d_detail) {
+ d_detail->reset_perf_counters();
+ }
+}
+
std::ostream&
operator << (std::ostream& os, const gr_block *m)
{
diff --git a/gnuradio-core/src/lib/runtime/gr_block.h b/gnuradio-core/src/lib/runtime/gr_block.h
index bd9ff42dfd..6e21d5b975 100644
--- a/gnuradio-core/src/lib/runtime/gr_block.h
+++ b/gnuradio-core/src/lib/runtime/gr_block.h
@@ -382,36 +382,75 @@ class GR_CORE_API gr_block : public gr_basic_block {
*/
float pc_noutput_items();
+ /*!
+ * \brief Gets variance of noutput_items performance counter.
+ */
+ float pc_noutput_items_var();
+
/*!
* \brief Gets average num items produced performance counter.
*/
float pc_nproduced();
/*!
- * \brief Gets average average fullness of \p which input buffer.
+ * \brief Gets variance of num items produced performance counter.
+ */
+ float pc_nproduced_var();
+
+ /*!
+ * \brief Gets average fullness of \p which input buffer.
*/
float pc_input_buffers_full(int which);
+ /*!
+ * \brief Gets variance of fullness of \p which input buffer.
+ */
+ float pc_input_buffers_full_var(int which);
+
/*!
* \brief Gets average fullness of all input buffers.
*/
std::vector<float> pc_input_buffers_full();
+ /*!
+ * \brief Gets variance of fullness of all input buffers.
+ */
+ std::vector<float> pc_input_buffers_full_var();
+
/*!
* \brief Gets average fullness of \p which input buffer.
*/
float pc_output_buffers_full(int which);
+ /*!
+ * \brief Gets variance of fullness of \p which input buffer.
+ */
+ float pc_output_buffers_full_var(int which);
+
/*!
* \brief Gets average fullness of all output buffers.
*/
std::vector<float> pc_output_buffers_full();
+ /*!
+ * \brief Gets variance of fullness of all output buffers.
+ */
+ std::vector<float> pc_output_buffers_full_var();
/*!
* \brief Gets average clock cycles spent in work.
*/
float pc_work_time();
+ /*!
+ * \brief Gets average clock cycles spent in work.
+ */
+ float pc_work_time_var();
+
+ /*!
+ * \brief Resets the performance counters
+ */
+ void reset_perf_counters();
+
// ----------------------------------------------------------------------------
// Functions to handle thread affinity
diff --git a/gnuradio-core/src/lib/runtime/gr_block_detail.cc b/gnuradio-core/src/lib/runtime/gr_block_detail.cc
index ff20e0e85a..82081039ac 100644
--- a/gnuradio-core/src/lib/runtime/gr_block_detail.cc
+++ b/gnuradio-core/src/lib/runtime/gr_block_detail.cc
@@ -43,10 +43,17 @@ gr_block_detail::gr_block_detail (unsigned int ninputs, unsigned int noutputs)
d_ninputs (ninputs), d_noutputs (noutputs),
d_input (ninputs), d_output (noutputs),
d_done (false),
- d_avg_noutput_items(0), d_avg_nproduced(0),
+ d_avg_noutput_items(0),
+ d_var_noutput_items(0),
+ d_avg_nproduced(0),
+ d_var_nproduced(0),
d_avg_input_buffers_full(ninputs, 0),
+ d_var_input_buffers_full(ninputs, 0),
d_avg_output_buffers_full(noutputs, 0),
- d_avg_work_time(0)
+ d_var_output_buffers_full(noutputs, 0),
+ d_avg_work_time(0),
+ d_var_work_time(0),
+ d_pc_counter(0)
{
s_ncurrently_allocated++;
}
@@ -237,27 +244,68 @@ gr_block_detail::start_perf_counters()
void
gr_block_detail::stop_perf_counters(int noutput_items, int nproduced)
{
- float alpha = 0.05;
- float beta = 1.0-alpha;
-
d_end_of_work = gruel::high_res_timer_now();
gruel::high_res_timer_type diff = d_end_of_work - d_start_of_work;
- d_avg_work_time = beta*d_avg_work_time + alpha*diff;
-
- d_avg_nproduced = beta*d_avg_nproduced + alpha*nproduced;
- d_avg_noutput_items = beta*d_avg_noutput_items + alpha*noutput_items;
- for(size_t i=0; i < d_input.size(); i++) {
- float pfull = static_cast<float>(d_input[i]->items_available()) /
- static_cast<float>(d_input[i]->max_possible_items_available());
- d_avg_input_buffers_full[i] = beta*d_avg_input_buffers_full[i] + alpha*pfull;
+ if(d_pc_counter == 0) {
+ d_avg_work_time = diff;
+ d_var_work_time = 0;
+ d_avg_nproduced = nproduced;
+ d_var_nproduced = 0;
+ d_avg_noutput_items = noutput_items;
+ d_var_noutput_items = 0;
+ for(size_t i=0; i < d_input.size(); i++) {
+ float pfull = static_cast<float>(d_input[i]->items_available()) /
+ static_cast<float>(d_input[i]->max_possible_items_available());
+ d_avg_input_buffers_full[i] = pfull;
+ d_var_input_buffers_full[i] = 0;
+ }
+ for(size_t i=0; i < d_output.size(); i++) {
+ float pfull = 1.0f - static_cast<float>(d_output[i]->space_available()) /
+ static_cast<float>(d_output[i]->bufsize());
+ d_avg_output_buffers_full[i] = pfull;
+ d_var_output_buffers_full[i] = 0;
+ }
}
+ else {
+ float d = diff - d_avg_work_time;
+ d_avg_work_time = d_avg_work_time + d/d_pc_counter;
+ d_var_work_time = d_var_work_time + d*d;
+
+ d = nproduced - d_avg_nproduced;
+ d_avg_nproduced = d_avg_nproduced + d/d_pc_counter;
+ d_var_nproduced = d_var_nproduced + d*d;
+
+ d = noutput_items - d_avg_noutput_items;
+ d_avg_noutput_items = d_avg_noutput_items + d/d_pc_counter;
+ d_var_noutput_items = d_var_noutput_items + d*d;
+
+ for(size_t i=0; i < d_input.size(); i++) {
+ float pfull = static_cast<float>(d_input[i]->items_available()) /
+ static_cast<float>(d_input[i]->max_possible_items_available());
+
+ d = pfull - d_avg_input_buffers_full[i];
+ d_avg_input_buffers_full[i] = d_avg_input_buffers_full[i] + d/d_pc_counter;
+ d_var_input_buffers_full[i] = d_var_input_buffers_full[i] + d*d;
+ }
- for(size_t i=0; i < d_output.size(); i++) {
- float pfull = 1.0f - static_cast<float>(d_output[i]->space_available()) /
- static_cast<float>(d_output[i]->bufsize());
- d_avg_output_buffers_full[i] = beta*d_avg_output_buffers_full[i] + alpha*pfull;
+ for(size_t i=0; i < d_output.size(); i++) {
+ float pfull = 1.0f - static_cast<float>(d_output[i]->space_available()) /
+ static_cast<float>(d_output[i]->bufsize());
+
+ d = pfull - d_avg_output_buffers_full[i];
+ d_avg_output_buffers_full[i] = d_avg_output_buffers_full[i] + d/d_pc_counter;
+ d_var_output_buffers_full[i] = d_var_output_buffers_full[i] + d*d;
+ }
}
+
+ d_pc_counter++;
+}
+
+void
+gr_block_detail::reset_perf_counters()
+{
+ d_pc_counter = 0;
}
float
@@ -307,3 +355,58 @@ gr_block_detail::pc_work_time()
{
return d_avg_work_time;
}
+
+
+float
+gr_block_detail::pc_noutput_items_var()
+{
+ return d_var_noutput_items/(d_pc_counter-1);
+}
+
+float
+gr_block_detail::pc_nproduced_var()
+{
+ return d_var_nproduced/(d_pc_counter-1);
+}
+
+float
+gr_block_detail::pc_input_buffers_full_var(size_t which)
+{
+ if(which < d_avg_input_buffers_full.size())
+ return d_var_input_buffers_full[which]/(d_pc_counter-1);
+ else
+ return 0;
+}
+
+std::vector<float>
+gr_block_detail::pc_input_buffers_full_var()
+{
+ std::vector<float> var(d_avg_input_buffers_full.size(), 0);
+ for(size_t i = 0; i < d_avg_input_buffers_full.size(); i++)
+ var[i] = d_avg_input_buffers_full[i]/(d_pc_counter-1);
+ return var;
+}
+
+float
+gr_block_detail::pc_output_buffers_full_var(size_t which)
+{
+ if(which < d_avg_output_buffers_full.size())
+ return d_var_output_buffers_full[which]/(d_pc_counter-1);
+ else
+ return 0;
+}
+
+std::vector<float>
+gr_block_detail::pc_output_buffers_full_var()
+{
+ std::vector<float> var(d_avg_output_buffers_full.size(), 0);
+ for(size_t i = 0; i < d_avg_output_buffers_full.size(); i++)
+ var[i] = d_avg_output_buffers_full[i]/(d_pc_counter-1);
+ return var;
+}
+
+float
+gr_block_detail::pc_work_time_var()
+{
+ return d_var_work_time/(d_pc_counter-1);
+}
diff --git a/gnuradio-core/src/lib/runtime/gr_block_detail.h b/gnuradio-core/src/lib/runtime/gr_block_detail.h
index a8ed8da908..32a01e763a 100644
--- a/gnuradio-core/src/lib/runtime/gr_block_detail.h
+++ b/gnuradio-core/src/lib/runtime/gr_block_detail.h
@@ -173,6 +173,7 @@ class GR_CORE_API gr_block_detail {
void start_perf_counters();
void stop_perf_counters(int noutput_items, int nproduced);
+ void reset_perf_counters();
// Calls to get performance counter items
float pc_noutput_items();
@@ -182,6 +183,14 @@ class GR_CORE_API gr_block_detail {
float pc_output_buffers_full(size_t which);
std::vector<float> pc_output_buffers_full();
float pc_work_time();
+
+ float pc_noutput_items_var();
+ float pc_nproduced_var();
+ float pc_input_buffers_full_var(size_t which);
+ std::vector<float> pc_input_buffers_full_var();
+ float pc_output_buffers_full_var(size_t which);
+ std::vector<float> pc_output_buffers_full_var();
+ float pc_work_time_var();
gr_tpb_detail d_tpb; // used by thread-per-block scheduler
int d_produce_or;
@@ -197,11 +206,17 @@ class GR_CORE_API gr_block_detail {
// Performance counters
float d_avg_noutput_items;
+ float d_var_noutput_items;
float d_avg_nproduced;
+ float d_var_nproduced;
std::vector<float> d_avg_input_buffers_full;
+ std::vector<float> d_var_input_buffers_full;
std::vector<float> d_avg_output_buffers_full;
+ std::vector<float> d_var_output_buffers_full;
gruel::high_res_timer_type d_start_of_work, d_end_of_work;
float d_avg_work_time;
+ float d_var_work_time;
+ float d_pc_counter;
gr_block_detail (unsigned int ninputs, unsigned int noutputs);
--
cgit v1.2.3