URL https://opencores.org/ocsvn/dblclockfft/dblclockfft/trunk

Subversion Repositories dblclockfft

[/] [dblclockfft/] [trunk/] [bench/] [cpp/] [fft_tb.cpp] - Blame information for rev 41

Details | Compare with Previous | View Log


////////////////////////////////////////////////////////////////////////////////
//
// Filename:    fft_tb.cpp
//
// Project:     A General Purpose Pipelined FFT Implementation
//
// Purpose:     A test-bench for the main program, fftmain.v, of the double
//              clocked FFT.  This file may be run autonomously  (when
//      fully functional).  If so, the last line output will either read
//      "SUCCESS" on success, or some other failure message otherwise.
//
//      This file depends upon verilator to both compile, run, and therefore
//      test fftmain.v
//
// Creator:     Dan Gisselquist, Ph.D.
//              Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015,2018, Gisselquist Technology, LLC
//
// This program is free software (firmware): 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 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY 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 this program.  (It's in the $(ROOT)/doc directory.  Run make with no
// target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License:     GPL, v3, as defined and found on www.gnu.org,
//              http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <fftw3.h>
 
#include "verilated.h"
#include "verilated_vcd_c.h"
#include "Vfftmain.h"
#include "twoc.h"
 
#include "fftsize.h"
 
 
#ifdef  NEW_VERILATOR
#define VVAR(A) fftmain__DOT_ ## A
#else
#define VVAR(A) v__DOT_ ## A
#endif
 
#ifdef  DBLCLKFFT
#define revstage_iaddr  VVAR(_revstage__DOT__iaddr)
#else
#define revstage_iaddr  VVAR(_revstage__DOT__wraddr)
#endif
#define br_sync         VVAR(_br_sync)
#define br_started      VVAR(_r_br_started)
#define w_s2048         VVAR(_w_s2048)
#define w_s1024         VVAR(_w_s1024)
#define w_s512          VVAR(_w_s512)
#define w_s256          VVAR(_w_s256)
#define w_s128          VVAR(_w_s128)
#define w_s64           VVAR(_w_s64)
#define w_s32           VVAR(_w_s32)
#define w_s16           VVAR(_w_s16)
#define w_s8            VVAR(_w_s8)
#define w_s4            VVAR(_w_s4)
 
 
#define IWIDTH  FFT_IWIDTH
#define OWIDTH  FFT_OWIDTH
#define LGWIDTH FFT_LGWIDTH
 
#if (IWIDTH > 16)
typedef unsigned long   ITYP;
#else
typedef unsigned int    ITYP;
#endif
 
#if (OWIDTH > 16)
typedef unsigned long   OTYP;
#else
typedef unsigned int    OTYP;
#endif
 
#define NFTLOG  16
#define FFTLEN  (1<<LGWIDTH)
 
#ifdef  FFT_SKIPS_BIT_REVERSE
#define APPLY_BITREVERSE_LOCALLY
#endif
 
unsigned long bitrev(const int nbits, const unsigned long vl) {
        unsigned long   r = 0;
        unsigned long   val = vl;
 
        for(int k=0; k<nbits; k++) {
                r<<= 1;
                r |= (val & 1);
                val >>= 1;
        }
 
        return r;
}
 
class   FFT_TB {
public:
        Vfftmain        *m_fft;
        OTYP            m_data[FFTLEN];
        ITYP            m_log[NFTLOG*FFTLEN];
        int             m_iaddr, m_oaddr, m_ntest, m_logbase;
        FILE            *m_dumpfp;
        fftw_plan       m_plan;
        double          *m_fft_buf;
        bool            m_syncd;
        unsigned long   m_tickcount;
        VerilatedVcdC*  m_trace;
 
        FFT_TB(void) {
                m_fft = new Vfftmain;
                Verilated::traceEverOn(true);
                m_iaddr = m_oaddr = 0;
                m_dumpfp = NULL;
 
                m_fft_buf = (double *)fftw_malloc(sizeof(fftw_complex)*(FFTLEN));
                m_plan = fftw_plan_dft_1d(FFTLEN, (fftw_complex *)m_fft_buf,
                                (fftw_complex *)m_fft_buf,
                                FFTW_FORWARD, FFTW_MEASURE);
                m_syncd = false;
                m_ntest = 0;
        }
 
        ~FFT_TB(void) {
                closetrace();
                delete m_fft;
                m_fft = NULL;
        }
 
        virtual void opentrace(const char *vcdname) {
                if (!m_trace) {
                        m_trace = new VerilatedVcdC;
                        m_fft->trace(m_trace, 99);
                        m_trace->open(vcdname);
                }
        }
 
        virtual void closetrace(void) {
                if (m_trace) {
                        m_trace->close();
                        delete m_trace;
                        m_trace = NULL;
                }
        }
 
        void    tick(void) {
                m_tickcount++;
                if (m_fft->i_reset)
                        printf("TICK(%s,%s)\n",
                                (m_fft->i_reset)?"RST":"   ",
                                (m_fft->i_ce)?"CE":"  ");
 
                m_fft->i_clk = 0;
                m_fft->eval();
                if (m_trace)
                        m_trace->dump((vluint64_t)(10*m_tickcount-2));
                m_fft->i_clk = 1;
                m_fft->eval();
                if (m_trace)
                        m_trace->dump((vluint64_t)(10*m_tickcount));
                m_fft->i_clk = 0;
                m_fft->eval();
                if (m_trace) {
                        m_trace->dump((vluint64_t)(10*m_tickcount+5));
                        m_trace->flush();
                }
        }
 
        void    cetick(void) {
                int     ce = m_fft->i_ce, nkce;
                tick();
 
                nkce = (rand()&1);
#ifdef  FFT_CKPCE
                nkce += FFT_CKPCE;
#endif
                if ((ce)&&(nkce>0)) {
                        m_fft->i_ce = 0;
                        for(int kce=1; kce < nkce; kce++)
                                tick();
                }
 
                m_fft->i_ce = ce;
        }
 
        void    reset(void) {
                m_fft->i_ce  = 0;
                m_fft->i_reset = 1;
                tick();
                m_fft->i_reset = 0;
                tick();
 
                m_iaddr = m_oaddr = m_logbase = 0;
                m_syncd = false;
                m_tickcount = 0l;
        }
 
        long    twos_complement(const long val, const int bits) {
                return sbits(val, bits);
        }
 
        void    checkresults(void) {
                double  *dp, *sp; // Complex array
                double  vout[FFTLEN*2];
                double  isq=0.0, osq = 0.0;
                ITYP    *lp;
 
                // Fill up our test array from the log array
                printf("%3d : CHECK: %8d %5x m_log[-%x=%x]\n", m_ntest, m_iaddr, m_iaddr,
                        m_logbase, (m_iaddr-m_logbase)&((NFTLOG*FFTLEN-1)&(-FFTLEN)));
 
                // Convert our logged data into doubles, in an FFT buffer
                dp = m_fft_buf; lp = &m_log[(m_iaddr-m_logbase)&((NFTLOG*FFTLEN-1)&(-FFTLEN))];
                for(int i=0; i<FFTLEN; i++) {
                        ITYP    tv = *lp++;
 
                        dp[0] = sbits((long)tv >> IWIDTH, IWIDTH);
                        dp[1] = sbits((long)tv, IWIDTH);
 
                        // printf("IN[%4d = %4x] = %9.1f %9.1f\n",
                                // i+((m_iaddr-FFTLEN*3)&((4*FFTLEN-1)&(-FFTLEN))),
                                // i+((m_iaddr-FFTLEN*3)&((4*FFTLEN-1)&(-FFTLEN))),
                                // dp[0], dp[1]);
                        dp += 2;
                }
 
                // Let's measure ... are we the zero vector?  If not, how close?
                dp = m_fft_buf;
                for(int i=0; i<FFTLEN*2; i++) {
                        isq += (*dp) * (*dp); dp++;
                }
 
                fftw_execute(m_plan);
 
                // Let's load up the output we received into double valued
                // array vout
                dp = vout;
                for(int i=0; i<FFTLEN; i++) {
                        *dp = rdata(i);
                        osq += (*dp) * (*dp); dp++;
                        *dp = idata(i);
                        osq += (*dp) * (*dp); dp++;
                }
 
 
                // Let's figure out if there's a scale factor difference ...
                double  scale = 0.0, wt = 0.0;
                sp = m_fft_buf;  dp = vout;
                for(int i=0; i<FFTLEN*2; i++) {
                        scale += (*sp) * (*dp++);
                        wt += (*sp) * (*sp); sp++;
                } scale = scale / wt;
 
                if (fabs(scale) <= 1./4./FFTLEN)
                        scale = 2./(FFTLEN);
                else if (wt == 0.0) scale = 1.0;
 
                double xisq = 0.0;
                sp = m_fft_buf;  dp = vout;
 
                if ((true)&&(m_dumpfp)) {
                        double  tmp[FFTLEN*2], nscl;
 
                        if (fabs(scale) < 1e-4)
                                nscl = 1.0;
                        else
                                nscl = scale;
                        for(int i=0; i<FFTLEN*2; i++)
                                tmp[i] = m_fft_buf[i] * nscl;
                        fwrite(tmp, sizeof(double), FFTLEN*2, m_dumpfp);
                }
 
                for(int i=0; i<FFTLEN*2; i++) {
                        double vl = (*sp++) * scale - (*dp++);
                        xisq += vl * vl;
                }
 
                printf("%3d : SCALE = %12.6f, WT = %18.1f, ISQ = %15.1f, ",
                        m_ntest, scale, wt, isq);
                printf("OSQ = %18.1f, ", osq);
                printf("XISQ = %18.1f, sqrt = %9.2f\n", xisq, sqrt(xisq));
                if (xisq > 1.4 * FFTLEN/2) {
                        printf("TEST FAIL!!  Result is out of bounds from ");
                        printf("expected result with FFTW3.\n");
                        // exit(EXIT_FAILURE);
                }
                m_ntest++;
        }
 
#ifdef  DBLCLKFFT
        bool    test(ITYP lft, ITYP rht) {
                m_fft->i_ce    = 1;
                m_fft->i_reset = 0;
                m_fft->i_left  = lft;
                m_fft->i_right = rht;
 
                m_log[(m_iaddr++)&(NFTLOG*FFTLEN-1)] = lft;
                m_log[(m_iaddr++)&(NFTLOG*FFTLEN-1)] = rht;
 
                cetick();
 
                if (m_fft->o_sync) {
                        if (!m_syncd) {
                                m_syncd = true;
                                printf("ORIGINAL SYNC AT 0x%lx, m_oaddr set to 0x%x\n", m_tickcount, m_oaddr);
                                m_logbase = m_iaddr;
                        } else printf("RESYNC AT %lx\n", m_tickcount);
                        m_oaddr &= (-1<<LGWIDTH);
                } else m_oaddr += 2;
 
                printf("%8x,%5d: %08x,%08x -> %011lx,%011lx\t",
                        m_iaddr, m_oaddr,
                        lft, rht, m_fft->o_left, m_fft->o_right);
 
#ifndef APPLY_BITREVERSE_LOCALLY
                printf(" [%3x]%s", m_fft->revstage_iaddr,
                        (m_fft->br_sync)?"S"
                                :((m_fft->br_started)?".":"x"));
#endif
 
                printf(" ");
#if (FFT_SIZE>=2048)
                printf("%s", (m_fft->w_s2048)?"S":"-");
#endif
#if (FFT_SIZE>1024)
                printf("%s", (m_fft->w_s1024)?"S":"-");
#endif
#if (FFT_SIZE>512)
                printf("%s", (m_fft->w_s512)?"S":"-");
#endif
#if (FFT_SIZE>256)
                printf("%s", (m_fft->w_s256)?"S":"-");
#endif
#if (FFT_SIZE>128)
                printf("%s", (m_fft->w_s128)?"S":"-");
#endif
#if (FFT_SIZE>64)
                printf("%s", (m_fft->w_s64)?"S":"-");
#endif
#if (FFT_SIZE>32)
                printf("%s", (m_fft->w_s32)?"S":"-");
#endif
#if (FFT_SIZE>16)
                printf("%s", (m_fft->w_s16)?"S":"-");
#endif
#if (FFT_SIZE>8)
                printf("%s", (m_fft->w_s8)?"S":"-");
#endif
#if (FFT_SIZE>4)
                printf("%s", (m_fft->w_s4)?"S":"-");
#endif
 
                printf(" %s%s\n",
                        (m_fft->o_sync)?"\t(SYNC!)":"",
                        (m_fft->o_left | m_fft->o_right)?"  (NZ)":"");
 
                m_data[(m_oaddr  )&(FFTLEN-1)] = m_fft->o_left;
                m_data[(m_oaddr+1)&(FFTLEN-1)] = m_fft->o_right;
 
                if ((m_syncd)&&((m_oaddr&(FFTLEN-1)) == FFTLEN-2)) {
                        dumpwrite();
                        checkresults();
                }
 
                return (m_fft->o_sync);
        }
#else
        bool    test(ITYP data) {
                m_fft->i_ce    = 1;
                m_fft->i_reset = 0;
                m_fft->i_sample  = data;
 
                m_log[(m_iaddr++)&(NFTLOG*FFTLEN-1)] = data;
 
                cetick();
 
                if (m_fft->o_sync) {
                        if (!m_syncd) {
                                m_syncd = true;
                                printf("ORIGINAL SYNC AT 0x%lx, m_oaddr set to 0x%x\n", m_tickcount, m_oaddr);
                                m_logbase = m_iaddr;
                        } else printf("RESYNC AT %lx\n", m_tickcount);
                        m_oaddr &= (-1<<LGWIDTH);
                } else m_oaddr += 1;
 
                printf("%8x,%5d: %08x -> %011lx\t",
                        m_iaddr, m_oaddr, data, m_fft->o_result);
 
#ifndef APPLY_BITREVERSE_LOCALLY
                printf(" [%3x]%s", m_fft->revstage_iaddr,
                        (m_fft->br_sync)?"S"
                                :((m_fft->br_started)?".":"x"));
#endif
 
                printf(" ");
#if (FFT_SIZE>=2048)
                printf("%s", (m_fft->w_s2048)?"S":"-");
#endif
#if (FFT_SIZE>1024)
                printf("%s", (m_fft->w_s1024)?"S":"-");
#endif
#if (FFT_SIZE>512)
                printf("%s", (m_fft->w_s512)?"S":"-");
#endif
#if (FFT_SIZE>256)
                printf("%s", (m_fft->w_s256)?"S":"-");
#endif
#if (FFT_SIZE>128)
                printf("%s", (m_fft->w_s128)?"S":"-");
#endif
#if (FFT_SIZE>64)
                printf("%s", (m_fft->w_s64)?"S":"-");
#endif
#if (FFT_SIZE>32)
                printf("%s", (m_fft->w_s32)?"S":"-");
#endif
#if (FFT_SIZE>16)
                printf("%s", (m_fft->w_s16)?"S":"-");
#endif
#if (FFT_SIZE>8)
                printf("%s", (m_fft->w_s8)?"S":"-");
#endif
#if (FFT_SIZE>4)
                printf("%s", (m_fft->w_s4)?"S":"-");
#endif
 
                printf(" %s%s\n",
                        (m_fft->o_sync)?"\t(SYNC!)":"",
                        (m_fft->o_result)?"  (NZ)":"");
 
                m_data[(m_oaddr  )&(FFTLEN-1)] = m_fft->o_result;
 
                if ((m_syncd)&&((m_oaddr&(FFTLEN-1)) == FFTLEN-1)) {
                        dumpwrite();
                        checkresults();
                }
 
                return (m_fft->o_sync);
        }
#endif
 
        bool    test(double lft_r, double lft_i, double rht_r, double rht_i) {
                ITYP    ilft, irht, ilft_r, ilft_i, irht_r, irht_i;
 
                ilft_r = (ITYP)(lft_r) & ((1<<IWIDTH)-1);
                ilft_i = (ITYP)(lft_i) & ((1<<IWIDTH)-1);
                irht_r = (ITYP)(rht_r) & ((1<<IWIDTH)-1);
                irht_i = (ITYP)(rht_i) & ((1<<IWIDTH)-1);
 
                ilft = (ilft_r << IWIDTH) | ilft_i;
                irht = (irht_r << IWIDTH) | irht_i;
 
#ifdef  DBLCLKFFT
                return test(ilft, irht);
#else
                test(ilft);
                return test(irht);
#endif
        }
 
        double  rdata(int addr) {
                int     index = addr & (FFTLEN-1);
 
#ifdef  APPLY_BITREVERSE_LOCALLY
                index = bitrev(LGWIDTH, index);
#endif
                return (double)sbits(m_data[index]>>OWIDTH, OWIDTH);
        }
 
        double  idata(int addr) {
                int     index = addr & (FFTLEN-1);
 
#ifdef  APPLY_BITREVERSE_LOCALLY
                index = bitrev(LGWIDTH, index);
#endif
                return (double)sbits(m_data[index], OWIDTH);
        }
 
        void    dump(FILE *fp) {
                m_dumpfp = fp;
        }
 
        void    dumpwrite(void) {
                if (!m_dumpfp)
                        return;
 
                double  *buf;
 
                buf = new double[FFTLEN * 2];
                for(int i=0; i<FFTLEN; i++) {
                        buf[i*2] = rdata(i);
                        buf[i*2+1] = idata(i);
                }
 
                fwrite(buf, sizeof(double), FFTLEN*2, m_dumpfp);
                delete[] buf;
        }
};
 
 
int     main(int argc, char **argv, char **envp) {
        Verilated::commandArgs(argc, argv);
        FFT_TB *fft = new FFT_TB;
        FILE    *fpout;
 
        fpout = fopen("fft_tb.dbl", "w");
        if (NULL == fpout) {
                fprintf(stderr, "Cannot write output file, fft_tb.dbl\n");
                exit(-1);
        }
 
        fft->opentrace("fft.vcd");
        fft->reset();
 
        {
                int     ftlen = FFTLEN;
                fwrite(&ftlen, 1, sizeof(int), fpout);
        }
        fft->dump(fpout);
 
        // 1.
        double  maxv = ((1l<<(IWIDTH-1))-1l);
        fft->test(0.0, 0.0, maxv, 0.0);
        for(int k=0; k<FFTLEN/2-1; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 2. Try placing a pulse at the very end location
        for(int k=0; k<FFTLEN/2; k++) {
                double cl, cr, sl, sr, W;
                W = - 2.0 * M_PI / FFTLEN * (1);
                cl = cos(W * (2*k  )) * (double)((1l<<(IWIDTH-2))-1l);
                sl = sin(W * (2*k  )) * (double)((1l<<(IWIDTH-2))-1l);
                cr = cos(W * (2*k+1)) * (double)((1l<<(IWIDTH-2))-1l);
                sr = sin(W * (2*k+1)) * (double)((1l<<(IWIDTH-2))-1l);
                fft->test(cl, sl, cr, sr);
        }
 
        // 2. 
        fft->test(maxv, 0.0, maxv, 0.0);
        for(int k=0; k<FFTLEN/2-1; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 3. 
        fft->test(0.0,0.0,0.0,0.0);
        fft->test(maxv, 0.0, 0.0, 0.0);
        for(int k=0; k<FFTLEN/2-1; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 4.
        for(int k=0; k<8; k++)
                fft->test(maxv, 0.0, maxv, 0.0);
        for(int k=8; k<FFTLEN/2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 5.
        if (FFTLEN/2 >= 16) {
                for(int k=0; k<16; k++)
                        fft->test(maxv, 0.0, maxv, 0.0);
                for(int k=16; k<FFTLEN/2; k++)
                        fft->test(0.0,0.0,0.0,0.0);
        }
 
        // 6.
        if (FFTLEN/2 >= 32) {
                for(int k=0; k<32; k++)
                        fft->test(maxv, 0.0, maxv, 0.0);
                for(int k=32; k<FFTLEN/2; k++)
                        fft->test(0.0,0.0,0.0,0.0);
        }
 
        // 7.
        if (FFTLEN/2 >= 64) {
                for(int k=0; k<64; k++)
                        fft->test(maxv, 0.0, maxv, 0.0);
                for(int k=64; k<FFTLEN/2; k++)
                        fft->test(0.0,0.0,0.0,0.0);
        }
 
        if (FFTLEN/2 >= 128) {
                for(int k=0; k<128; k++)
                        fft->test(maxv, 0.0, maxv, 0.0);
                for(int k=128; k<FFTLEN/2; k++)
                        fft->test(0.0,0.0,0.0,0.0);
        }
 
        if (FFTLEN/2 >= 256) {
                for(int k=0; k<256; k++)
                        fft->test(maxv, 0.0, maxv, 0.0);
                for(int k=256; k<FFTLEN/2; k++)
                        fft->test(0.0,0.0,0.0,0.0);
        }
 
        if (FFTLEN/2 >= 512) {
                for(int k=0; k<256+128; k++)
                        fft->test(maxv, 0.0, maxv, 0.0);
                for(int k=256+128; k<FFTLEN/2; k++)
                        fft->test(0.0,0.0,0.0,0.0);
        }
 
        /*
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,0.0,0.0,0.0);
        */
 
#ifndef NO_JUNK
        // 7.
 
        //     1 -> 0x0001 
        //     2 -> 0x0002 
        //     4 -> 0x0004 
        //     8 -> 0x0008 
        //    16 -> 0x0010 
        //    32 -> 0x0020 
        //    64 -> 0x0040 
        //   128 -> 0x0080 
        //   256 -> 0x0100 
        //   512 -> 0x0200 
        //  1024 -> 0x0400 
        //  2048 -> 0x0800
        //  4096 -> 0x1000
        //  8192 -> 0x2000
        // 16384 -> 0x4000
        for(int v=1; v<32768; v<<=1) for(int k=0; k<FFTLEN/2; k++)
                fft->test((double)v,0.0,(double)v,0.0);
        //     1 -> 0xffff      
        //     2 -> 0xfffe
        //     4 -> 0xfffc
        //     8 -> 0xfff8
        //    16 -> 0xfff0
        //    32 -> 0xffe0
        //    64 -> 0xffc0
        //   128 -> 0xff80
        //   256 -> 0xff00
        //   512 -> 0xfe00
        //  1024 -> 0xfc00
        //  2048 -> 0xf800
        //  4096 -> 0xf000
        //  8192 -> 0xe000
        // 16384 -> 0xc000
        // 32768 -> 0x8000
        fft->test(0.0,0.0,16384.0,0.0);
        for(int k=0; k<FFTLEN/2-1; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        for(int v=1; v<=32768; v<<=1) for(int k=0; k<FFTLEN/2; k++)
                fft->test(-(double)v,0.0,-(double)v,0.0);
        //     1 -> 0x000040    CORRECT!!
        //     2 -> 0x000080 
        //     4 -> 0x000100 
        //     8 -> 0x000200
        //    16 -> 0x000400
        //    32 -> 0x000800
        //    64 -> 0x001000
        //   128 -> 0x002000
        //   256 -> 0x004000
        //   512 -> 0x008000
        //  1024 -> 0x010000
        //  2048 -> 0x020000
        //  4096 -> 0x040000
        //  8192 -> 0x080000
        // 16384 -> 0x100000
        for(int v=1; v<32768; v<<=1) for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,(double)v,0.0,(double)v);
        //     1 -> 0x3fffc0
        //     2 -> 0x3fff80
        //     4 -> 0x3fff00
        //     8 -> 0x3ffe00
        //    16 -> 0x3ffc00
        //    32 -> 0x3ff800
        //    64 -> 0x3ff000
        //   128 -> 0x3fe000
        //   256 -> 0x3fc000
        //   512 -> 0x3f8000
        //  1024 -> 0x3f0000
        //  2048 -> 0x3e0000
        //  4096 -> 0x3c0000
        //  8192 -> 0x380000
        // 16384 -> 0x300000
        for(int v=1; v<32768; v<<=1) for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,-(double)v,0.0,-(double)v);
 
        // 61. Now, how about the smallest alternating real signal
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(2.0,0.0,0.0,0.0); // Don't forget to expect a bias!
        // 62. Now, how about the smallest alternating imaginary signal
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,2.0,0.0,0.0); // Don't forget to expect a bias!
        // 63. Now, how about the smallest alternating real signal,2nd phase
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,0.0,2.0,0.0); // Don't forget to expect a bias!
        // 64.Now, how about the smallest alternating imaginary signal,2nd phase
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,0.0,0.0,2.0); // Don't forget to expect a bias!
 
        // 65.
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(maxv,0.0,-maxv,0.0);
        // 66.
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,-maxv,0.0,maxv);
        // 67.
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(-maxv,-maxv,-maxv,-maxv);
        // 68.
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,-maxv,0.0,maxv);
        // 69.
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,maxv,0.0,-maxv);
        // 70. 
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(-maxv,-maxv,-maxv,-maxv);
 
        // 71. Now let's go for an impulse (SUCCESS)
        fft->test(16384.0, 0.0, 0.0, 0.0);
        for(int k=0; k<FFTLEN/2-1; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 72. And another one on the next clock (FAILS, ugly)
        fft->test(0.0, 0.0, 16384.0, 0.0);
        for(int k=0; k<FFTLEN/2-1; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 72. And another one on the next clock (FAILS, ugly)
        fft->test(0.0, 0.0,  8192.0, 0.0);
        for(int k=0; k<FFTLEN/2-1; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 72. And another one on the next clock (FAILS, ugly)
        fft->test(0.0, 0.0,   512.0, 0.0);
        for(int k=0; k<FFTLEN/2-1; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 73. And an imaginary one on the second clock
        fft->test(0.0, 0.0, 0.0, 16384.0);
        for(int k=0; k<FFTLEN/2-1; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 74. Likewise the next clock
        fft->test(0.0,0.0,0.0,0.0);
        fft->test(16384.0, 0.0, 0.0, 0.0);
        for(int k=0; k<FFTLEN/2-2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 75. And it's imaginary counterpart
        fft->test(0.0,0.0,0.0,0.0);
        fft->test(0.0, 16384.0, 0.0, 0.0);
        for(int k=0; k<FFTLEN/2-2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 76. Likewise the next clock
        fft->test(0.0,0.0,0.0,0.0);
        fft->test(0.0, 0.0, 16384.0, 0.0);
        for(int k=0; k<FFTLEN/2-2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
        // 77. And it's imaginary counterpart
        fft->test(0.0,0.0,0.0,0.0);
        fft->test(0.0, 0.0, 0.0, 16384.0);
        for(int k=0; k<FFTLEN/2-2; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
 
        // 78. Now let's try some exponentials
        for(int k=0; k<FFTLEN/2; k++) {
                double cl, cr, sl, sr, W;
                W = - 2.0 * M_PI / FFTLEN;
                cl = cos(W * (2*k  )) * 16383.0;
                sl = sin(W * (2*k  )) * 16383.0;
                cr = cos(W * (2*k+1)) * 16383.0;
                sr = sin(W * (2*k+1)) * 16383.0;
                fft->test(cl, sl, cr, sr);
        }
 
        // 72.
        for(int k=0; k<FFTLEN/2; k++) {
                double cl, cr, sl, sr, W;
                W = - 2.0 * M_PI / FFTLEN * 5;
                cl = cos(W * (2*k  )) * 16383.0;
                sl = sin(W * (2*k  )) * 16383.0;
                cr = cos(W * (2*k+1)) * 16383.0;
                sr = sin(W * (2*k+1)) * 16383.0;
                fft->test(cl, sl, cr, sr);
        }
 
        // 73.
        for(int k=0; k<FFTLEN/2; k++) {
                double cl, cr, sl, sr, W;
                W = - 2.0 * M_PI / FFTLEN * 8;
                cl = cos(W * (2*k  )) * 8190.0;
                sl = sin(W * (2*k  )) * 8190.0;
                cr = cos(W * (2*k+1)) * 8190.0;
                sr = sin(W * (2*k+1)) * 8190.0;
                fft->test(cl, sl, cr, sr);
        }
 
        // 74.
        for(int k=0; k<FFTLEN/2; k++) {
                double cl, cr, sl, sr, W;
                W = - 2.0 * M_PI / FFTLEN * 25;
                cl = cos(W * (2*k  )) * 4.0;
                sl = sin(W * (2*k  )) * 4.0;
                cr = cos(W * (2*k+1)) * 4.0;
                sr = sin(W * (2*k+1)) * 4.0;
                fft->test(cl, sl, cr, sr);
        }
#endif
        // 19.--24. And finally, let's clear out our results / buffer
        for(int k=0; k<(FFTLEN/2) * 5; k++)
                fft->test(0.0,0.0,0.0,0.0);
 
 
 
        fclose(fpout);
 
        if (!fft->m_syncd) {
                printf("FAIL -- NO SYNC\n");
                goto test_failure;
        }
 
        printf("SUCCESS!!\n");
        exit(0);
test_failure:
        printf("TEST FAILED!!\n");
        exit(0);
}
 
 

Line No.	Rev	Author	Line
1	41	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
2	7	dgisselq	`//`
3	9	dgisselq	`// Filename: fft_tb.cpp`
4	7	dgisselq	`//`
5	41	dgisselq	`// Project: A General Purpose Pipelined FFT Implementation`
6	7	dgisselq	`//`
7	14	dgisselq	`// Purpose: A test-bench for the main program, fftmain.v, of the double`
8	9	dgisselq	`// clocked FFT. This file may be run autonomously (when`
9	36	dgisselq	`// fully functional). If so, the last line output will either read`
10			`// "SUCCESS" on success, or some other failure message otherwise.`
11	7	dgisselq	`//`
12	36	dgisselq	`// This file depends upon verilator to both compile, run, and therefore`
13			`// test fftmain.v`
14	7	dgisselq	`//`
15			`// Creator: Dan Gisselquist, Ph.D.`
16	30	dgisselq	`// Gisselquist Technology, LLC`
17	7	dgisselq	`//`
18	41	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
19	7	dgisselq	`//`
20	36	dgisselq	`// Copyright (C) 2015,2018, Gisselquist Technology, LLC`
21	7	dgisselq	`//`
22			`// This program is free software (firmware): you can redistribute it and/or`
23			`// modify it under the terms of the GNU General Public License as published`
24			`// by the Free Software Foundation, either version 3 of the License, or (at`
25			`// your option) any later version.`
26			`//`
27			`// This program is distributed in the hope that it will be useful, but WITHOUT`
28			`// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or`
29			`// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
30			`// for more details.`
31			`//`
32			`// You should have received a copy of the GNU General Public License along`
33	41	dgisselq	`// with this program. (It's in the $(ROOT)/doc directory. Run make with no`
34	7	dgisselq	`// target there if the PDF file isn't present.) If not, see`
35			`// <http://www.gnu.org/licenses/> for a copy.`
36			`//`
37			`// License: GPL, v3, as defined and found on www.gnu.org,`
38			`// http://www.gnu.org/licenses/gpl.html`
39			`//`
40			`//`
41	41	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
42	7	dgisselq	`#include <stdio.h>`
43	36	dgisselq	`#include <stdlib.h>`
44	9	dgisselq	`#include <math.h>`
45			`#include <fftw3.h>`
46	7	dgisselq
47			`#include "verilated.h"`
48	36	dgisselq	`#include "verilated_vcd_c.h"`
49	7	dgisselq	`#include "Vfftmain.h"`
50	23	dgisselq	`#include "twoc.h"`
51	7	dgisselq
52	28	dgisselq	`#include "fftsize.h"`
53	7	dgisselq
54	35	dgisselq
55			`#ifdef NEW_VERILATOR`
56			`#define VVAR(A) fftmain__DOT_ ## A`
57			`#else`
58			`#define VVAR(A) v__DOT_ ## A`
59			`#endif`
60
61	36	dgisselq	`#ifdef DBLCLKFFT`
62	35	dgisselq	`#define revstage_iaddr VVAR(_revstage__DOT__iaddr)`
63	36	dgisselq	`#else`
64			`#define revstage_iaddr VVAR(_revstage__DOT__wraddr)`
65			`#endif`
66	35	dgisselq	`#define br_sync VVAR(_br_sync)`
67			`#define br_started VVAR(_r_br_started)`
68			`#define w_s2048 VVAR(_w_s2048)`
69			`#define w_s1024 VVAR(_w_s1024)`
70			`#define w_s512 VVAR(_w_s512)`
71			`#define w_s256 VVAR(_w_s256)`
72			`#define w_s128 VVAR(_w_s128)`
73			`#define w_s64 VVAR(_w_s64)`
74			`#define w_s32 VVAR(_w_s32)`
75			`#define w_s16 VVAR(_w_s16)`
76			`#define w_s8 VVAR(_w_s8)`
77			`#define w_s4 VVAR(_w_s4)`
78
79
80	28	dgisselq	`#define IWIDTH FFT_IWIDTH`
81			`#define OWIDTH FFT_OWIDTH`
82			`#define LGWIDTH FFT_LGWIDTH`
83
84			`#if (IWIDTH > 16)`
85			`typedef unsigned long ITYP;`
86			`#else`
87			`typedef unsigned int ITYP;`
88			`#endif`
89
90			`#if (OWIDTH > 16)`
91			`typedef unsigned long OTYP;`
92			`#else`
93			`typedef unsigned int OTYP;`
94			`#endif`
95
96			`#define NFTLOG 16`
97	7	dgisselq	`#define FFTLEN (1<<LGWIDTH)`
98
99	28	dgisselq	`#ifdef FFT_SKIPS_BIT_REVERSE`
100			`#define APPLY_BITREVERSE_LOCALLY`
101			`#endif`
102
103	26	dgisselq	`unsigned long bitrev(const int nbits, const unsigned long vl) {`
104			`unsigned long r = 0;`
105			`unsigned long val = vl;`
106
107			`for(int k=0; k<nbits; k++) {`
108			`r<<= 1;`
109			`r \|= (val & 1);`
110			`val >>= 1;`
111			`}`
112
113			`return r;`
114			`}`
115
116	7	dgisselq	`class FFT_TB {`
117			`public:`
118			`Vfftmain *m_fft;`
119	28	dgisselq	`OTYP m_data[FFTLEN];`
120			`ITYP m_log[NFTLOG*FFTLEN];`
121	26	dgisselq	`int m_iaddr, m_oaddr, m_ntest, m_logbase;`
122	7	dgisselq	`FILE *m_dumpfp;`
123	9	dgisselq	`fftw_plan m_plan;`
124			`double *m_fft_buf;`
125			`bool m_syncd;`
126	28	dgisselq	`unsigned long m_tickcount;`
127	36	dgisselq	`VerilatedVcdC* m_trace;`
128	7	dgisselq
129			`FFT_TB(void) {`
130			`m_fft = new Vfftmain;`
131	36	dgisselq	`Verilated::traceEverOn(true);`
132	9	dgisselq	`m_iaddr = m_oaddr = 0;`
133	7	dgisselq	`m_dumpfp = NULL;`
134	9	dgisselq
135			`m_fft_buf = (double )fftw_malloc(sizeof(fftw_complex)(FFTLEN));`
136			`m_plan = fftw_plan_dft_1d(FFTLEN, (fftw_complex *)m_fft_buf,`
137			`(fftw_complex *)m_fft_buf,`
138			`FFTW_FORWARD, FFTW_MEASURE);`
139			`m_syncd = false;`
140			`m_ntest = 0;`
141	36	dgisselq	`}`
142	28	dgisselq
143	36	dgisselq	`~FFT_TB(void) {`
144			`closetrace();`
145			`delete m_fft;`
146			`m_fft = NULL;`
147	7	dgisselq	`}`
148
149	36	dgisselq	`virtual void opentrace(const char *vcdname) {`
150			`if (!m_trace) {`
151			`m_trace = new VerilatedVcdC;`
152			`m_fft->trace(m_trace, 99);`
153			`m_trace->open(vcdname);`
154			`}`
155			`}`
156
157			`virtual void closetrace(void) {`
158			`if (m_trace) {`
159			`m_trace->close();`
160			`delete m_trace;`
161			`m_trace = NULL;`
162			`}`
163			`}`
164
165	7	dgisselq	`void tick(void) {`
166	36	dgisselq	`m_tickcount++;`
167			`if (m_fft->i_reset)`
168	28	dgisselq	`printf("TICK(%s,%s)\n",`
169	36	dgisselq	`(m_fft->i_reset)?"RST":" ",`
170	28	dgisselq	`(m_fft->i_ce)?"CE":" ");`
171	36	dgisselq
172	7	dgisselq	`m_fft->i_clk = 0;`
173			`m_fft->eval();`
174	36	dgisselq	`if (m_trace)`
175			`m_trace->dump((vluint64_t)(10*m_tickcount-2));`
176	7	dgisselq	`m_fft->i_clk = 1;`
177			`m_fft->eval();`
178	36	dgisselq	`if (m_trace)`
179			`m_trace->dump((vluint64_t)(10*m_tickcount));`
180			`m_fft->i_clk = 0;`
181			`m_fft->eval();`
182			`if (m_trace) {`
183			`m_trace->dump((vluint64_t)(10*m_tickcount+5));`
184			`m_trace->flush();`
185			`}`
186			`}`
187	26	dgisselq
188	36	dgisselq	`void cetick(void) {`
189			`int ce = m_fft->i_ce, nkce;`
190			`tick();`
191	28	dgisselq
192	36	dgisselq	`nkce = (rand()&1);`
193			`#ifdef FFT_CKPCE`
194			`nkce += FFT_CKPCE;`
195			`#endif`
196			`if ((ce)&&(nkce>0)) {`
197			`m_fft->i_ce = 0;`
198			`for(int kce=1; kce < nkce; kce++)`
199			`tick();`
200	26	dgisselq	`}`
201	36	dgisselq
202			`m_fft->i_ce = ce;`
203	7	dgisselq	`}`
204
205			`void reset(void) {`
206			`m_fft->i_ce = 0;`
207	36	dgisselq	`m_fft->i_reset = 1;`
208	7	dgisselq	`tick();`
209	36	dgisselq	`m_fft->i_reset = 0;`
210	7	dgisselq	`tick();`
211	9	dgisselq
212	26	dgisselq	`m_iaddr = m_oaddr = m_logbase = 0;`
213	9	dgisselq	`m_syncd = false;`
214	28	dgisselq	`m_tickcount = 0l;`
215	7	dgisselq	`}`
216
217	9	dgisselq	`long twos_complement(const long val, const int bits) {`
218	23	dgisselq	`return sbits(val, bits);`
219	9	dgisselq	`}`
220
221			`void checkresults(void) {`
222			`double dp, sp; // Complex array`
223			`double vout[FFTLEN*2];`
224			`double isq=0.0, osq = 0.0;`
225	28	dgisselq	`ITYP *lp;`
226	9	dgisselq
227			`// Fill up our test array from the log array`
228	26	dgisselq	`printf("%3d : CHECK: %8d %5x m_log[-%x=%x]\n", m_ntest, m_iaddr, m_iaddr,`
229			`m_logbase, (m_iaddr-m_logbase)&((NFTLOG*FFTLEN-1)&(-FFTLEN)));`
230	28	dgisselq
231			`// Convert our logged data into doubles, in an FFT buffer`
232	26	dgisselq	`dp = m_fft_buf; lp = &m_log[(m_iaddr-m_logbase)&((NFTLOG*FFTLEN-1)&(-FFTLEN))];`
233	9	dgisselq	`for(int i=0; i<FFTLEN; i++) {`
234	28	dgisselq	`ITYP tv = *lp++;`
235	9	dgisselq
236	28	dgisselq	`dp[0] = sbits((long)tv >> IWIDTH, IWIDTH);`
237			`dp[1] = sbits((long)tv, IWIDTH);`
238	9	dgisselq
239	16	dgisselq	`// printf("IN[%4d = %4x] = %9.1f %9.1f\n",`
240			`// i+((m_iaddr-FFTLEN3)&((4FFTLEN-1)&(-FFTLEN))),`
241			`// i+((m_iaddr-FFTLEN3)&((4FFTLEN-1)&(-FFTLEN))),`
242			`// dp[0], dp[1]);`
243	9	dgisselq	`dp += 2;`
244			`}`
245
246			`// Let's measure ... are we the zero vector? If not, how close?`
247			`dp = m_fft_buf;`
248	26	dgisselq	`for(int i=0; i<FFTLEN*2; i++) {`
249			`isq += (dp) (*dp); dp++;`
250			`}`
251	9	dgisselq
252			`fftw_execute(m_plan);`
253
254	28	dgisselq	`// Let's load up the output we received into double valued`
255			`// array vout`
256	9	dgisselq	`dp = vout;`
257			`for(int i=0; i<FFTLEN; i++) {`
258	26	dgisselq	`*dp = rdata(i);`
259	9	dgisselq	`osq += (dp) (*dp); dp++;`
260	26	dgisselq	`*dp = idata(i);`
261	9	dgisselq	`osq += (dp) (*dp); dp++;`
262			`}`
263
264
265			`// Let's figure out if there's a scale factor difference ...`
266			`double scale = 0.0, wt = 0.0;`
267			`sp = m_fft_buf; dp = vout;`
268			`for(int i=0; i<FFTLEN*2; i++) {`
269			`scale += (sp) (*dp++);`
270			`wt += (sp) (*sp); sp++;`
271			`} scale = scale / wt;`
272
273	28	dgisselq	`if (fabs(scale) <= 1./4./FFTLEN)`
274			`scale = 2./(FFTLEN);`
275			`else if (wt == 0.0) scale = 1.0;`
276	9	dgisselq
277			`double xisq = 0.0;`
278			`sp = m_fft_buf; dp = vout;`
279	26	dgisselq
280			`if ((true)&&(m_dumpfp)) {`
281			`double tmp[FFTLEN*2], nscl;`
282
283			`if (fabs(scale) < 1e-4)`
284			`nscl = 1.0;`
285			`else`
286			`nscl = scale;`
287			`for(int i=0; i<FFTLEN*2; i++)`
288			`tmp[i] = m_fft_buf[i] * nscl;`
289			`fwrite(tmp, sizeof(double), FFTLEN*2, m_dumpfp);`
290			`}`
291
292	9	dgisselq	`for(int i=0; i<FFTLEN*2; i++) {`
293			`double vl = (sp++) scale - (*dp++);`
294			`xisq += vl * vl;`
295			`}`
296
297			`printf("%3d : SCALE = %12.6f, WT = %18.1f, ISQ = %15.1f, ",`
298			`m_ntest, scale, wt, isq);`
299			`printf("OSQ = %18.1f, ", osq);`
300	36	dgisselq	`printf("XISQ = %18.1f, sqrt = %9.2f\n", xisq, sqrt(xisq));`
301	19	dgisselq	`if (xisq > 1.4 * FFTLEN/2) {`
302	16	dgisselq	`printf("TEST FAIL!! Result is out of bounds from ");`
303			`printf("expected result with FFTW3.\n");`
304	36	dgisselq	`// exit(EXIT_FAILURE);`
305	16	dgisselq	`}`
306	9	dgisselq	`m_ntest++;`
307			`}`
308
309	36	dgisselq	`#ifdef DBLCLKFFT`
310	28	dgisselq	`bool test(ITYP lft, ITYP rht) {`
311	7	dgisselq	`m_fft->i_ce = 1;`
312	36	dgisselq	`m_fft->i_reset = 0;`
313	7	dgisselq	`m_fft->i_left = lft;`
314			`m_fft->i_right = rht;`
315
316	28	dgisselq	`m_log[(m_iaddr++)&(NFTLOG*FFTLEN-1)] = lft;`
317			`m_log[(m_iaddr++)&(NFTLOG*FFTLEN-1)] = rht;`
318	9	dgisselq
319	36	dgisselq	`cetick();`
320	7	dgisselq
321			`if (m_fft->o_sync) {`
322	26	dgisselq	`if (!m_syncd) {`
323	28	dgisselq	`m_syncd = true;`
324			`printf("ORIGINAL SYNC AT 0x%lx, m_oaddr set to 0x%x\n", m_tickcount, m_oaddr);`
325	26	dgisselq	`m_logbase = m_iaddr;`
326	28	dgisselq	`} else printf("RESYNC AT %lx\n", m_tickcount);`
327	9	dgisselq	`m_oaddr &= (-1<<LGWIDTH);`
328			`} else m_oaddr += 2;`
329	7	dgisselq
330	28	dgisselq	`printf("%8x,%5d: %08x,%08x -> %011lx,%011lx\t",`
331	26	dgisselq	`m_iaddr, m_oaddr,`
332			`lft, rht, m_fft->o_left, m_fft->o_right);`
333	28	dgisselq
334			`#ifndef APPLY_BITREVERSE_LOCALLY`
335	35	dgisselq	`printf(" [%3x]%s", m_fft->revstage_iaddr,`
336			`(m_fft->br_sync)?"S"`
337			`:((m_fft->br_started)?".":"x"));`
338	28	dgisselq	`#endif`
339
340			`printf(" ");`
341			`#if (FFT_SIZE>=2048)`
342	35	dgisselq	`printf("%s", (m_fft->w_s2048)?"S":"-");`
343	28	dgisselq	`#endif`
344			`#if (FFT_SIZE>1024)`
345	35	dgisselq	`printf("%s", (m_fft->w_s1024)?"S":"-");`
346	28	dgisselq	`#endif`
347			`#if (FFT_SIZE>512)`
348	35	dgisselq	`printf("%s", (m_fft->w_s512)?"S":"-");`
349	28	dgisselq	`#endif`
350			`#if (FFT_SIZE>256)`
351	35	dgisselq	`printf("%s", (m_fft->w_s256)?"S":"-");`
352	28	dgisselq	`#endif`
353			`#if (FFT_SIZE>128)`
354	35	dgisselq	`printf("%s", (m_fft->w_s128)?"S":"-");`
355	28	dgisselq	`#endif`
356			`#if (FFT_SIZE>64)`
357	35	dgisselq	`printf("%s", (m_fft->w_s64)?"S":"-");`
358	28	dgisselq	`#endif`
359			`#if (FFT_SIZE>32)`
360	35	dgisselq	`printf("%s", (m_fft->w_s32)?"S":"-");`
361	28	dgisselq	`#endif`
362			`#if (FFT_SIZE>16)`
363	35	dgisselq	`printf("%s", (m_fft->w_s16)?"S":"-");`
364	28	dgisselq	`#endif`
365			`#if (FFT_SIZE>8)`
366	35	dgisselq	`printf("%s", (m_fft->w_s8)?"S":"-");`
367	28	dgisselq	`#endif`
368			`#if (FFT_SIZE>4)`
369	35	dgisselq	`printf("%s", (m_fft->w_s4)?"S":"-");`
370	28	dgisselq	`#endif`
371
372			`printf(" %s%s\n",`
373	9	dgisselq	`(m_fft->o_sync)?"\t(SYNC!)":"",`
374			`(m_fft->o_left \| m_fft->o_right)?" (NZ)":"");`
375	7	dgisselq
376	9	dgisselq	`m_data[(m_oaddr )&(FFTLEN-1)] = m_fft->o_left;`
377			`m_data[(m_oaddr+1)&(FFTLEN-1)] = m_fft->o_right;`
378	7	dgisselq
379	9	dgisselq	`if ((m_syncd)&&((m_oaddr&(FFTLEN-1)) == FFTLEN-2)) {`
380	7	dgisselq	`dumpwrite();`
381	9	dgisselq	`checkresults();`
382			`}`
383	7	dgisselq
384			`return (m_fft->o_sync);`
385			`}`
386	36	dgisselq	`#else`
387			`bool test(ITYP data) {`
388			`m_fft->i_ce = 1;`
389			`m_fft->i_reset = 0;`
390			`m_fft->i_sample = data;`
391	7	dgisselq
392	36	dgisselq	`m_log[(m_iaddr++)&(NFTLOG*FFTLEN-1)] = data;`
393
394			`cetick();`
395
396			`if (m_fft->o_sync) {`
397			`if (!m_syncd) {`
398			`m_syncd = true;`
399			`printf("ORIGINAL SYNC AT 0x%lx, m_oaddr set to 0x%x\n", m_tickcount, m_oaddr);`
400			`m_logbase = m_iaddr;`
401			`} else printf("RESYNC AT %lx\n", m_tickcount);`
402			`m_oaddr &= (-1<<LGWIDTH);`
403			`} else m_oaddr += 1;`
404
405			`printf("%8x,%5d: %08x -> %011lx\t",`
406			`m_iaddr, m_oaddr, data, m_fft->o_result);`
407
408			`#ifndef APPLY_BITREVERSE_LOCALLY`
409			`printf(" [%3x]%s", m_fft->revstage_iaddr,`
410			`(m_fft->br_sync)?"S"`
411			`:((m_fft->br_started)?".":"x"));`
412			`#endif`
413
414			`printf(" ");`
415			`#if (FFT_SIZE>=2048)`
416			`printf("%s", (m_fft->w_s2048)?"S":"-");`
417			`#endif`
418			`#if (FFT_SIZE>1024)`
419			`printf("%s", (m_fft->w_s1024)?"S":"-");`
420			`#endif`
421			`#if (FFT_SIZE>512)`
422			`printf("%s", (m_fft->w_s512)?"S":"-");`
423			`#endif`
424			`#if (FFT_SIZE>256)`
425			`printf("%s", (m_fft->w_s256)?"S":"-");`
426			`#endif`
427			`#if (FFT_SIZE>128)`
428			`printf("%s", (m_fft->w_s128)?"S":"-");`
429			`#endif`
430			`#if (FFT_SIZE>64)`
431			`printf("%s", (m_fft->w_s64)?"S":"-");`
432			`#endif`
433			`#if (FFT_SIZE>32)`
434			`printf("%s", (m_fft->w_s32)?"S":"-");`
435			`#endif`
436			`#if (FFT_SIZE>16)`
437			`printf("%s", (m_fft->w_s16)?"S":"-");`
438			`#endif`
439			`#if (FFT_SIZE>8)`
440			`printf("%s", (m_fft->w_s8)?"S":"-");`
441			`#endif`
442			`#if (FFT_SIZE>4)`
443			`printf("%s", (m_fft->w_s4)?"S":"-");`
444			`#endif`
445
446			`printf(" %s%s\n",`
447			`(m_fft->o_sync)?"\t(SYNC!)":"",`
448			`(m_fft->o_result)?" (NZ)":"");`
449
450			`m_data[(m_oaddr )&(FFTLEN-1)] = m_fft->o_result;`
451
452			`if ((m_syncd)&&((m_oaddr&(FFTLEN-1)) == FFTLEN-1)) {`
453			`dumpwrite();`
454			`checkresults();`
455			`}`
456
457			`return (m_fft->o_sync);`
458			`}`
459			`#endif`
460
461	7	dgisselq	`bool test(double lft_r, double lft_i, double rht_r, double rht_i) {`
462	28	dgisselq	`ITYP ilft, irht, ilft_r, ilft_i, irht_r, irht_i;`
463	7	dgisselq
464	28	dgisselq	`ilft_r = (ITYP)(lft_r) & ((1<<IWIDTH)-1);`
465			`ilft_i = (ITYP)(lft_i) & ((1<<IWIDTH)-1);`
466			`irht_r = (ITYP)(rht_r) & ((1<<IWIDTH)-1);`
467			`irht_i = (ITYP)(rht_i) & ((1<<IWIDTH)-1);`
468	7	dgisselq
469			`ilft = (ilft_r << IWIDTH) \| ilft_i;`
470			`irht = (irht_r << IWIDTH) \| irht_i;`
471
472	36	dgisselq	`#ifdef DBLCLKFFT`
473	7	dgisselq	`return test(ilft, irht);`
474	36	dgisselq	`#else`
475			`test(ilft);`
476			`return test(irht);`
477			`#endif`
478	7	dgisselq	`}`
479
480			`double rdata(int addr) {`
481	26	dgisselq	`int index = addr & (FFTLEN-1);`
482
483	28	dgisselq	`#ifdef APPLY_BITREVERSE_LOCALLY`
484			`index = bitrev(LGWIDTH, index);`
485			`#endif`
486	26	dgisselq	`return (double)sbits(m_data[index]>>OWIDTH, OWIDTH);`
487	7	dgisselq	`}`
488
489			`double idata(int addr) {`
490	26	dgisselq	`int index = addr & (FFTLEN-1);`
491
492	28	dgisselq	`#ifdef APPLY_BITREVERSE_LOCALLY`
493			`index = bitrev(LGWIDTH, index);`
494			`#endif`
495	26	dgisselq	`return (double)sbits(m_data[index], OWIDTH);`
496	7	dgisselq	`}`
497
498			`void dump(FILE *fp) {`
499			`m_dumpfp = fp;`
500			`}`

Browse

Tools

Subversion Repositories dblclockfft

[/] [dblclockfft/] [trunk/] [bench/] [cpp/] [fft_tb.cpp] - Blame information for rev 41