fir_filter_lfast.h

Go to the documentation of this file.

/*
 * fir_filter_lfast.h
 *
 *      Copyright 2019, Michael Piscopo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
 
#ifndef INCLUDE_LFAST_FIR_FILTER_LFAST_H_
#define INCLUDE_LFAST_FIR_FILTER_LFAST_H_
 
#include <gnuradio/gr_complex.h>
 
#include <boost/thread/thread.hpp>
#include <volk/volk.h>
using namespace std;
 
namespace gr {
  namespace lfast {
        /*
         * Base Filter
         */
    template<class io_type, class tap_type>
        class Filter {
        protected:
                tap_type *alignedTaps;
                io_type *singlePointBuffer;
                std::vector<tap_type> d_taps;
                long numTaps;
 
        public:
                Filter();
                Filter(const std::vector<tap_type>& newTaps);
                virtual ~Filter();
 
                virtual void setTaps(const std::vector<tap_type>& newTaps);
                // For compatibility
                inline virtual void set_taps(const std::vector<tap_type>& newTaps) { setTaps(newTaps); };
                virtual std::vector<tap_type> getTaps() const;
                inline virtual std::vector<tap_type> taps() const { return getTaps();};
                inline virtual long ntaps() { return numTaps;};
 
                // Returns number of samples consumed / produced
                virtual long filter(io_type *outputBuffer, const io_type *inputBuffer, long numSamples) {return 0;};
        }; // end base filter template
 
        /*
         * FIR Filter - Complex inputs, float taps
         */
    class FIRFilterCCF:public Filter<gr_complex,float> {
        public:
        FIRFilterCCF();
        FIRFilterCCF(const std::vector<float>& newTaps);
                virtual ~FIRFilterCCF();
 
                // NOTE: This routine is expecting numSamples to be an integer multiple of the number of taps
                virtual long filterN(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples);
 
                // OutputBuffer here should be at least numSamples/decimation in length
                virtual long filterNdec(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples, int decimation);
 
                virtual gr_complex filter(const gr_complex *inputBuffer);
 
                // This is for testing comparison.  This function does all calculations in 1 CPU-based thread.
                virtual long filterCPU(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples);
    };
 
        /*
         * FIR Filter - float inputs, float taps
         */
    class FIRFilterFFF:public Filter<float,float> {
        public:
        FIRFilterFFF();
        FIRFilterFFF(const std::vector<float>& newTaps);
                virtual ~FIRFilterFFF();
 
                // NOTE: This routine is expecting numSamples to be an integer multiple of the number of taps
                virtual long filterN(float *outputBuffer, const float *inputBuffer, long numSamples);
 
                // OutputBuffer here should be at least numSamples/decimation in length
                virtual long filterNdec(float *outputBuffer, const float *inputBuffer, long numSamples, int decimation);
 
                virtual gr_complex filter(const float *inputBuffer);
 
                // This is for testing comparison.  This function does all calculations in 1 CPU-based thread.
                virtual long filterCPU(float *outputBuffer, const float *inputBuffer, long numSamples);
    };
 
        /*
         * FIR Filter - complex inputs, complex taps
         */
    class FIRFilterCCC:public Filter<gr_complex,gr_complex> {
        public:
        FIRFilterCCC();
        FIRFilterCCC(const std::vector<gr_complex>& newTaps);
                virtual ~FIRFilterCCC();
 
                // NOTE: This routine is expecting numSamples to be an integer multiple of the number of taps
                virtual long filterN(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples);
 
                // OutputBuffer here should be at least numSamples/decimation in length
                virtual long filterNdec(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples, int decimation);
 
                virtual gr_complex filter(const gr_complex *inputBuffer);
 
                // This is for testing comparison.  This function does all calculations in 1 CPU-based thread.
                virtual long filterCPU(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples);
    };
 
 
    // -----------------------------------------------------------------
    // ------  Multi-threaded filters ----------------------------------
    // -----------------------------------------------------------------
 
        /*
         * Multi-threaded base template.
         * Provides threading and buffers
         *
         */
    template<class io_type>
        class MTBase {
        protected:
                const io_type *pInputBuffer;
                io_type *pOutputBuffer;
 
        // Supports up to 16 threads
        boost::thread *threads[16];
        bool threadRunning[16];
                bool threadReady;
        int d_nthreads;
                int decimation;
 
 
        public:
                MTBase(int nthreads=4);
                virtual ~MTBase();
 
                int numThreads() { return d_nthreads; };
 
                inline virtual void setDecimation(int newDecimation) { decimation = newDecimation; };
                inline virtual int getDecimation() { return decimation; };
                inline virtual bool decimating() { if (decimation > 1) return true; else return false; };
 
                virtual long calcDecimationBlockSize(long numSamples);
 
                // NOTE: calcDecimationIndex assumes the index is an even multiple of a decimation block size
                // In other words, calcDecimationBlockSize was called to get an appropriate block size,
                // then blockStartIndex is an integer multiple of that result.
                virtual long calcDecimationIndex(long blockStartIndex);
 
                // NOTE: This method IS NOT thread-safe.  Make sure to use a scoped_lock or be sure no threads are running
                // before changing the number of threads.
                virtual void setThreads(int nthreads);
 
                virtual bool anyThreadRunning();
    };
 
    // --------------------------------------------------
    // Multi-threaded filter, complex data, float taps
    // --------------------------------------------------
    class FIRFilterCCF_MT:public MTBase<gr_complex>, public FIRFilterCCF {
    protected:
                virtual void runThread1(long startIndex,long numSamples);
                virtual void runThread2(long startIndex,long numSamples);
                virtual void runThread3(long startIndex,long numSamples);
                virtual void runThread4(long startIndex,long numSamples);
                virtual void runThread5(long startIndex,long numSamples);
                virtual void runThread6(long startIndex,long numSamples);
                virtual void runThread7(long startIndex,long numSamples);
                virtual void runThread8(long startIndex,long numSamples);
                virtual void runThread9(long startIndex,long numSamples);
                virtual void runThread10(long startIndex,long numSamples);
                virtual void runThread11(long startIndex,long numSamples);
                virtual void runThread12(long startIndex,long numSamples);
                virtual void runThread13(long startIndex,long numSamples);
                virtual void runThread14(long startIndex,long numSamples);
                virtual void runThread15(long startIndex,long numSamples);
                virtual void runThread16(long startIndex,long numSamples);
 
    public:
        FIRFilterCCF_MT(int nthreads);
        FIRFilterCCF_MT(const std::vector<float>& newTaps, int nthreads);
                virtual ~FIRFilterCCF_MT();
 
                // NOTE: This routine is expecting numSamples to be an integer multiple of the number of taps
                virtual long filterN(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples);
 
                // OutputBuffer here should be at least numSamples/decimation in length
                virtual long filterNdec(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples, int decimation);
 
    };
 
    // --------------------------------------------------
    // Multi-threaded filter, complex data, float taps
    // --------------------------------------------------
    class FIRFilterFFF_MT:public MTBase<float>, public FIRFilterFFF {
    protected:
                virtual void runThread1(long startIndex,long numSamples);
                virtual void runThread2(long startIndex,long numSamples);
                virtual void runThread3(long startIndex,long numSamples);
                virtual void runThread4(long startIndex,long numSamples);
                virtual void runThread5(long startIndex,long numSamples);
                virtual void runThread6(long startIndex,long numSamples);
                virtual void runThread7(long startIndex,long numSamples);
                virtual void runThread8(long startIndex,long numSamples);
                virtual void runThread9(long startIndex,long numSamples);
                virtual void runThread10(long startIndex,long numSamples);
                virtual void runThread11(long startIndex,long numSamples);
                virtual void runThread12(long startIndex,long numSamples);
                virtual void runThread13(long startIndex,long numSamples);
                virtual void runThread14(long startIndex,long numSamples);
                virtual void runThread15(long startIndex,long numSamples);
                virtual void runThread16(long startIndex,long numSamples);
 
    public:
        FIRFilterFFF_MT(int nthreads);
        FIRFilterFFF_MT(const std::vector<float>& newTaps, int nthreads);
                virtual ~FIRFilterFFF_MT();
 
                // NOTE: This routine is expecting numSamples to be an integer multiple of the number of taps
                virtual long filterN(float *outputBuffer, const float *inputBuffer, long numSamples);
 
                // OutputBuffer here should be at least numSamples/decimation in length
                virtual long filterNdec(float *outputBuffer, const float *inputBuffer, long numSamples, int decimation);
    };
 
    // --------------------------------------------------
    // Multi-threaded filter, complex data, complex taps
    // --------------------------------------------------
    class FIRFilterCCC_MT:public MTBase<gr_complex>, public FIRFilterCCC {
    protected:
                virtual void runThread1(long startIndex,long numSamples);
                virtual void runThread2(long startIndex,long numSamples);
                virtual void runThread3(long startIndex,long numSamples);
                virtual void runThread4(long startIndex,long numSamples);
                virtual void runThread5(long startIndex,long numSamples);
                virtual void runThread6(long startIndex,long numSamples);
                virtual void runThread7(long startIndex,long numSamples);
                virtual void runThread8(long startIndex,long numSamples);
                virtual void runThread9(long startIndex,long numSamples);
                virtual void runThread10(long startIndex,long numSamples);
                virtual void runThread11(long startIndex,long numSamples);
                virtual void runThread12(long startIndex,long numSamples);
                virtual void runThread13(long startIndex,long numSamples);
                virtual void runThread14(long startIndex,long numSamples);
                virtual void runThread15(long startIndex,long numSamples);
                virtual void runThread16(long startIndex,long numSamples);
 
    public:
                FIRFilterCCC_MT(int nthreads);
                FIRFilterCCC_MT(const std::vector<gr_complex>& newTaps, int nthreads);
                virtual ~FIRFilterCCC_MT();
 
                // NOTE: This routine is expecting numSamples to be an integer multiple of the number of taps
                virtual long filterN(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples);
 
                // OutputBuffer here should be at least numSamples/decimation in length
                virtual long filterNdec(gr_complex *outputBuffer, const gr_complex *inputBuffer, long numSamples, int decimation);
    };
  } // end lfast
} // end gr
 
 
 
#endif /* INCLUDE_LFAST_FIR_FILTER_LFAST_H_ */