Merge remote-tracking branch 'tom/set_max_noutput_items'

Author: jmcorgan

gnuradio-runtime/lib/flat_flowgraph.cc

@@ -177,6 +177,13 @@ namespace gr {
     catch(std::bad_alloc&) {
       b = make_buffer(nitems, item_size, grblock);
     }
+
+    // Set the max noutput items size here to make sure it's always
+    // set in the block and available in the start() method.
+    // But don't overwrite if the user has set this externally.
+    if(!grblock->is_set_max_noutput_items())
+      grblock->set_max_noutput_items(nitems);
+
     return b;
   }
 

gr-blocks/python/blocks/qa_block_behavior.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+#
+# Copyright 2016 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gr_unittest, blocks
+
+class test_block_behavior(gr_unittest.TestCase):
+
+    def setUp(self):
+        self.tb = gr.top_block()
+
+    def tearDown(self):
+        self.tb = None
+
+    def test_000(self):
+        '''
+        Tests the max noutput sizes set by the scheduler. When creating
+        the block, there is no block_detail and so the max buffer size
+        is 0. When the top_block is run, it builds the detail and
+        buffers and sets the max value. test_0001 tests when the
+        max_noutput_items is set by hand.
+
+        '''
+
+        src = blocks.null_source(gr.sizeof_float)
+        op  = blocks.head(gr.sizeof_float, 100)
+        snk = blocks.null_sink(gr.sizeof_float)
+
+        maxn_pre = op.max_noutput_items()
+
+        self.tb.connect(src, op, snk)
+        self.tb.run()
+
+        maxn_post = op.max_noutput_items()
+
+        self.assertEqual(maxn_pre, 0)
+        self.assertEqual(maxn_post, 16384)
+
+    def test_001(self):
+        '''
+        Tests the max noutput size when being explicitly set.
+        '''
+
+        src = blocks.null_source(gr.sizeof_float)
+        op  = blocks.head(gr.sizeof_float, 100)
+        snk = blocks.null_sink(gr.sizeof_float)
+
+        op.set_max_noutput_items(1024)
+
+        maxn_pre = op.max_noutput_items()
+
+        self.tb.connect(src, op, snk)
+        self.tb.run()
+
+        maxn_post = op.max_noutput_items()
+
+        self.assertEqual(maxn_pre, 1024)
+        self.assertEqual(maxn_post, 1024)
+
+if __name__ == '__main__':
+    gr_unittest.run(test_block_behavior, "test_block_behavior.xml")

gr-filter/lib/pfb_decimator_ccf_impl.cc

@@ -73,6 +73,26 @@ namespace gr {
       else {
         set_history(d_taps_per_filter);
       }
+
+      d_tmp = NULL;
+    }
+
+    bool pfb_decimator_ccf_impl::start()
+    {
+      if(d_use_fft_filters) {
+        d_tmp = fft::malloc_complex(max_noutput_items()*d_rate);
+      }
+
+      return block::start();
+    }
+
+    bool pfb_decimator_ccf_impl::stop()
+    {
+      if((d_use_fft_filters) && (d_tmp)) {
+        fft::free(d_tmp);
+      }
+
+      return block::stop();
     }
 
     pfb_decimator_ccf_impl::~pfb_decimator_ccf_impl()
@@ -198,14 +218,13 @@ namespace gr {
       gr_complex *out = (gr_complex *)output_items[0];
 
       int i;
-      gr_complex *tmp = fft::malloc_complex(noutput_items*d_rate);
 
       // Filter each input stream by the FFT filters; do all
       // noutput_items at once to avoid repeated calls to the FFT
       // setup and operation.
       for(unsigned int j = 0; j < d_rate; j++) {
         in = (gr_complex*)input_items[d_rate-j-1];
-        d_fft_filters[j]->filter(noutput_items, in, &(tmp[j*noutput_items]));
+        d_fft_filters[j]->filter(noutput_items, in, &(d_tmp[j*noutput_items]));
       }
 
       // Rotate and add filter outputs (k=channel number; M=number of
@@ -214,11 +233,10 @@ namespace gr {
       for(i = 0; i < noutput_items; i++) {
         out[i] = 0;
         for(unsigned int j = 0; j < d_rate; j++) {
-          out[i] += tmp[j*noutput_items+i]*d_rotator[j];
+          out[i] += d_tmp[j*noutput_items+i]*d_rotator[j];
         }
       }
 
-      fft::free(tmp);
       return noutput_items;
     }
 
@@ -231,18 +249,17 @@ namespace gr {
       gr_complex *out = (gr_complex *)output_items[0];
 
       int i;
-      gr_complex *tmp = fft::malloc_complex(noutput_items*d_rate);
 
       for(unsigned int j = 0; j < d_rate; j++) {
         in = (gr_complex*)input_items[d_rate-j-1];
-        d_fft_filters[j]->filter(noutput_items, in, &tmp[j*noutput_items]);
+        d_fft_filters[j]->filter(noutput_items, in, &d_tmp[j*noutput_items]);
       }
 
       // Performs the rotate and add operations by implementing it as
       // an FFT.
       for(i = 0; i < noutput_items; i++) {
         for(unsigned int j = 0; j < d_rate; j++) {
-          d_fft->get_inbuf()[j] = tmp[j*noutput_items + i];
+          d_fft->get_inbuf()[j] = d_tmp[j*noutput_items + i];
         }
 
         // Perform the FFT to do the complex multiply despinning for all channels
@@ -252,7 +269,6 @@ namespace gr {
         out[i] = d_fft->get_outbuf()[d_chan];
       }
 
-      fft::free(tmp);
       return noutput_items;
     }
 

gr-filter/lib/pfb_decimator_ccf_impl.h

@@ -40,6 +40,7 @@ namespace gr {
       bool         d_use_fft_rotator;
       bool         d_use_fft_filters;
       gr_complex  *d_rotator;
+      gr_complex  *d_tmp; // used for fft filters
       gr::thread::mutex d_mutex; // mutex to protect set/work access
 
       inline int work_fir_exp(int noutput_items,
@@ -55,7 +56,6 @@ namespace gr {
                               gr_vector_const_void_star &input_items,
                               gr_vector_void_star &output_items);
 
-
     public:
       pfb_decimator_ccf_impl(unsigned int decim,
 			     const std::vector<float> &taps,
@@ -70,6 +70,10 @@ namespace gr {
       std::vector<std::vector<float> > taps() const;
       void set_channel(const unsigned int channel);
 
+      // Overload to create/destroy d_tmp based on max_noutput_items.
+      bool start();
+      bool stop();
+
       int work(int noutput_items,
 	       gr_vector_const_void_star &input_items,
 	       gr_vector_void_star &output_items);