sched: adding in perf counters to measure performance of blocks during exectution of flowgraph.

Conflicts:

	CMakeLists.txt
	gnuradio-core/src/lib/runtime/gr_block.cc
	gnuradio-core/src/lib/runtime/gr_block_detail.cc
	gnuradio-core/src/lib/runtime/gr_block_detail.h

5 files changed, 231 insertions, 1 deletions

diff --git a/gnuradio-core/src/lib/runtime/gr_block.cc b/gnuradio-core/src/lib/runtime/gr_block.cc
index dca1fcf83..fd82ab580 100644
--- a/gnuradio-core/src/lib/runtime/gr_block.cc
+++ b/gnuradio-core/src/lib/runtime/gr_block.cc
@@ -269,6 +269,83 @@ gr_block::unset_processor_affinity()
   }
 }
 
+float
+gr_block::pc_noutput_items()
+{
+  if(d_detail) {
+    return d_detail->pc_noutput_items();
+  }
+  else {
+    return 0;
+  }
+}
+
+float
+gr_block::pc_nproduced()
+{
+  if(d_detail) {
+    return d_detail->pc_nproduced();
+  }
+  else {
+    return 0;
+  }
+}
+
+float
+gr_block::pc_input_buffers_full(int which)
+{
+  if(d_detail) {
+    return d_detail->pc_input_buffers_full(static_cast<size_t>(which));
+  }
+  else {
+    return 0;
+  }
+}
+
+std::vector<float>
+gr_block::pc_input_buffers_full()
+{
+  if(d_detail) {
+    return d_detail->pc_input_buffers_full();
+  }
+  else {
+    return std::vector<float>(1,0);
+  }
+}
+
+float
+gr_block::pc_output_buffers_full(int which)
+{
+  if(d_detail) {
+    return d_detail->pc_output_buffers_full(static_cast<size_t>(which));
+  }
+  else {
+    return 0;
+  }
+}
+
+std::vector<float>
+gr_block::pc_output_buffers_full()
+{
+  if(d_detail) {
+    return d_detail->pc_output_buffers_full();
+  }
+  else {
+    return std::vector<float>(1,0);
+  }
+}
+
+float
+gr_block::pc_work_time()
+{
+  if(d_detail) {
+    return d_detail->pc_work_time();
+  }
+  else {
+    return 0;
+  }
+}
+
 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 9906d3632..c9d2d8f53 100644
--- a/gnuradio-core/src/lib/runtime/gr_block.h
+++ b/gnuradio-core/src/lib/runtime/gr_block.h
@@ -358,6 +358,44 @@ class GR_CORE_API gr_block : public gr_basic_block {
       d_min_output_buffer[port] = min_output_buffer; 
   }
 
+  // --------------- Performance counter functions -------------
+
+  /*!
+   * \brief Gets average noutput_items performance counter.
+   */
+  float pc_noutput_items();
+
+  /*!
+   * \brief Gets average num items produced performance counter.
+   */
+  float pc_nproduced();
+
+  /*!
+   * \brief Gets average average fullness of \p which input buffer.
+   */
+  float pc_input_buffers_full(int which);
+
+  /*!
+   * \brief Gets average fullness of all input buffers.
+   */
+  std::vector<float> pc_input_buffers_full();
+
+  /*!
+   * \brief Gets average fullness of \p which input buffer.
+   */
+  float pc_output_buffers_full(int which);
+
+  /*!
+   * \brief Gets average fullness of all output buffers.
+   */
+  std::vector<float> pc_output_buffers_full();
+
+  /*!
+   * \brief Gets average clock cycles spent in work.
+   */
+  float pc_work_time();
+
+
   // ----------------------------------------------------------------------------
   // 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 fdcde85a0..ff20e0e85 100644
--- a/gnuradio-core/src/lib/runtime/gr_block_detail.cc
+++ b/gnuradio-core/src/lib/runtime/gr_block_detail.cc
@@ -42,7 +42,11 @@ gr_block_detail::gr_block_detail (unsigned int ninputs, unsigned int noutputs)
   : d_produce_or(0),
     d_ninputs (ninputs), d_noutputs (noutputs),
     d_input (ninputs), d_output (noutputs),
-    d_done (false)
+    d_done (false),
+    d_avg_noutput_items(0), d_avg_nproduced(0),
+    d_avg_input_buffers_full(ninputs, 0),
+    d_avg_output_buffers_full(noutputs, 0),
+    d_avg_work_time(0)
 {
   s_ncurrently_allocated++;
 }
@@ -223,3 +227,83 @@ gr_block_detail::unset_processor_affinity()
     gruel::thread_unbind(thread);
   }
 }
+
+void
+gr_block_detail::start_perf_counters()
+{
+  d_start_of_work = gruel::high_res_timer_now();
+}
+
+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;
+  }
+
+  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;
+  }
+}
+
+float
+gr_block_detail::pc_noutput_items()
+{
+  return d_avg_noutput_items;
+}
+
+float
+gr_block_detail::pc_nproduced()
+{
+  return d_avg_nproduced;
+}
+
+float
+gr_block_detail::pc_input_buffers_full(size_t which)
+{
+  if(which < d_avg_input_buffers_full.size())
+    return d_avg_input_buffers_full[which];
+  else
+    return 0;
+}
+
+std::vector<float>
+gr_block_detail::pc_input_buffers_full()
+{
+  return d_avg_input_buffers_full;
+}
+
+float
+gr_block_detail::pc_output_buffers_full(size_t which)
+{
+  if(which < d_avg_output_buffers_full.size())
+    return d_avg_output_buffers_full[which];
+  else
+    return 0;
+}
+
+std::vector<float>
+gr_block_detail::pc_output_buffers_full()
+{
+  return d_avg_output_buffers_full;
+}
+
+float
+gr_block_detail::pc_work_time()
+{
+  return d_avg_work_time;
+}
diff --git a/gnuradio-core/src/lib/runtime/gr_block_detail.h b/gnuradio-core/src/lib/runtime/gr_block_detail.h
index bcc42c7a0..a8ed8da90 100644
--- a/gnuradio-core/src/lib/runtime/gr_block_detail.h
+++ b/gnuradio-core/src/lib/runtime/gr_block_detail.h
@@ -27,6 +27,7 @@
 #include <gr_runtime_types.h>
 #include <gr_tpb_detail.h>
 #include <gr_tags.h>
+#include <gruel/high_res_timer.h>
 #include <stdexcept>
 
 /*!
@@ -169,6 +170,19 @@ class GR_CORE_API gr_block_detail {
 
   bool                               threaded;  // set if thread is currently running.
   gruel::gr_thread_t                 thread;    // portable thread handle
+
+  void start_perf_counters();
+  void stop_perf_counters(int noutput_items, int nproduced);
+
+  // Calls to get performance counter items
+  float pc_noutput_items();
+  float pc_nproduced();
+  float pc_input_buffers_full(size_t which);
+  std::vector<float> pc_input_buffers_full();
+  float pc_output_buffers_full(size_t which);
+  std::vector<float> pc_output_buffers_full();
+  float pc_work_time();
+ 
   gr_tpb_detail			     d_tpb;	// used by thread-per-block scheduler
   int				     d_produce_or;
 
@@ -181,6 +195,14 @@ class GR_CORE_API gr_block_detail {
   std::vector<gr_buffer_sptr>	     d_output;
   bool                               d_done;
 
+  // Performance counters
+  float d_avg_noutput_items;
+  float d_avg_nproduced;
+  std::vector<float> d_avg_input_buffers_full;
+  std::vector<float> d_avg_output_buffers_full;
+  gruel::high_res_timer_type d_start_of_work, d_end_of_work;
+  float d_avg_work_time;
+  
   gr_block_detail (unsigned int ninputs, unsigned int noutputs);
 
   friend struct gr_tpb_detail;
diff --git a/gnuradio-core/src/lib/runtime/gr_block_executor.cc b/gnuradio-core/src/lib/runtime/gr_block_executor.cc
index 375b58f56..ee0ab9e37 100644
--- a/gnuradio-core/src/lib/runtime/gr_block_executor.cc
+++ b/gnuradio-core/src/lib/runtime/gr_block_executor.cc
@@ -420,9 +420,18 @@ gr_block_executor::run_one_iteration()
     for (int i = 0; i < d->ninputs(); i++)
       d_start_nitems_read[i] = d->nitems_read(i);
 
+#ifdef GR_PERFORMANCE_COUNTERS
+    d->start_perf_counters();
+#endif /* GR_PERFORMANCE_COUNTERS */
+    
     // Do the actual work of the block
     int n = m->general_work (noutput_items, d_ninput_items,
 			     d_input_items, d_output_items);
+
+#ifdef GR_PERFORMANCE_COUNTERS
+    d->stop_perf_counters(noutput_items, n);
+#endif /* GR_PERFORMANCE_COUNTERS */
+
     LOG(*d_log << "  general_work: noutput_items = " << noutput_items
 	<< " result = " << n << std::endl);