fir_filter_lfast.h

Go to the documentation of this file.

/*
 * fir_filter_lfast.h
 *
 *      Author: ghostop14
 */

#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_ */