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

Subversion Repositories dblclockfft

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

Go to most recent revision | Details | Compare with Previous | View Log


//
// Filename:    fft_tb.cpp
//
// Project:     A Doubletime Pipelined FFT
//
// 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 Tecnology, LLC
//
///////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015, 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 <math.h>
#include <fftw3.h>
 
#include "verilated.h"
#include "Vfftmain.h"
 
#define LGWIDTH 11
#define IWIDTH  16
#define OWIDTH  22
 
#define FFTLEN  (1<<LGWIDTH)
 
class   FFT_TB {
public:
        Vfftmain        *m_fft;
        long            m_data[FFTLEN], m_log[4*FFTLEN];
        int             m_iaddr, m_oaddr, m_ntest;
        FILE            *m_dumpfp;
        fftw_plan       m_plan;
        double          *m_fft_buf;
        bool            m_syncd;
 
        FFT_TB(void) {
                m_fft = new Vfftmain;
                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;
        }
 
        void    tick(void) {
                m_fft->i_clk = 0;
                m_fft->eval();
                m_fft->i_clk = 1;
                m_fft->eval();
        }
 
        void    reset(void) {
                m_fft->i_ce  = 0;
                m_fft->i_rst = 1;
                tick();
                m_fft->i_rst = 0;
                tick();
 
                m_iaddr = m_oaddr = 0;
                m_syncd = false;
        }
 
        long    twos_complement(const long val, const int bits) {
                long    r;
 
                r = val & ((1l<<bits)-1);
                if (r & (1l << (bits-1)))
                        r |= (-1l << bits);
                return r;
        }
 
        void    checkresults(void) {
                double  *dp, *sp; // Complex array
                double  vout[FFTLEN*2];
                double  isq=0.0, osq = 0.0;
                long    *lp;
 
                // Fill up our test array from the log array
                // printf("%3d : CHECK: %8d %5x\n", m_ntest, m_iaddr, m_iaddr);
                dp = m_fft_buf; lp = &m_log[(m_iaddr-FFTLEN*3)&((4*FFTLEN-1)&(-FFTLEN))];
                for(int i=0; i<FFTLEN; i++) {
                        long    tv = *lp++;
 
                        dp[0] = twos_complement(tv >> IWIDTH, IWIDTH);
                        dp[1] = twos_complement(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; i++)
                        isq += (*dp) * (*dp);
 
                fftw_execute(m_plan);
 
                // Let's load up the output we received into vout
                dp = vout;
                for(int i=0; i<FFTLEN; i++) {
                        long    tv = m_data[i];
 
                        // printf("OUT[%4d = %4x] = ", i, i);
                        // printf("%12lx = ", tv);
                        *dp = twos_complement(tv >> OWIDTH, OWIDTH);
                        // printf("%10.1f + ", *dp);
                        osq += (*dp) * (*dp); dp++;
                        *dp = twos_complement(tv, OWIDTH);
                        // printf("%10.1f j", *dp);
                        osq += (*dp) * (*dp); dp++;
                        // printf(" <-> %12.1f %12.1f\n", m_fft_buf[2*i], m_fft_buf[2*i+1]);
                }
 
 
                // 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 (wt == 0.0) scale = 1.0;
 
                double xisq = 0.0;
                sp = m_fft_buf;  dp = vout;
                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\n", xisq);
                if (xisq > 1.2 * FFTLEN/2) {
                        printf("TEST FAIL!!  Result is out of bounds from ");
                        printf("expected result with FFTW3.\n");
                        exit(-2);
                }
                m_ntest++;
        }
 
        bool    test(int lft, int rht) {
                m_fft->i_ce    = 1;
                m_fft->i_rst   = 0;
                m_fft->i_left  = lft;
                m_fft->i_right = rht;
 
                m_log[(m_iaddr++)&(4*FFTLEN-1)] = (long)lft;
                m_log[(m_iaddr++)&(4*FFTLEN-1)] = (long)rht;
 
                tick();
 
                if (m_fft->o_sync) {
                        m_oaddr &= (-1<<LGWIDTH);
                        m_syncd = true;
                } else m_oaddr += 2;
 
                /*
                printf("%8x,%5d: %08x,%08x -> %011lx,%011lx"
                        // "\t%011lx,%011lx"
                        // "\t%011lx,%011lx"
                        // "\t%06x,%06x"
                        // "\t%06x,%06x"
                        "\t%011lx,%06x,%06x"
                        "\t%011lx,%06x,%06x"
                        " %s%s%s%s%s%s%s%s%s%s %s%s\n",
                        m_iaddr, m_oaddr,
                        lft, rht, m_fft->o_left, m_fft->o_right,
                        // m_fft->v__DOT__stage_e2048__DOT__ib_a,
                        // m_fft->v__DOT__stage_e2048__DOT__ib_b,
                        // m_fft->v__DOT__stage_e512__DOT__ib_a,
                        // m_fft->v__DOT__stage_e512__DOT__ib_b,
                        // m_fft->v__DOT__stage_e256__DOT__ib_a,
                        // m_fft->v__DOT__stage_e256__DOT__ib_b,
                        // m_fft->v__DOT__stage_e128__DOT__ib_a,
                        // m_fft->v__DOT__stage_e128__DOT__ib_b,
                        // m_fft->v__DOT__stage_e64__DOT__ib_a,
                        // m_fft->v__DOT__stage_e64__DOT__ib_b,
                        // m_fft->v__DOT__stage_e32__DOT__ib_a,
                        // m_fft->v__DOT__stage_e32__DOT__ib_b,
                        // m_fft->v__DOT__stage_e16__DOT__ib_a,
                        // m_fft->v__DOT__stage_e16__DOT__ib_b,
                        // m_fft->v__DOT__stage_e8__DOT__ib_a,
                        // m_fft->v__DOT__stage_e8__DOT__ib_b,
                        // m_fft->v__DOT__stage_o8__DOT__ib_a,
                        // m_fft->v__DOT__stage_o8__DOT__ib_b,
                        // m_fft->v__DOT__stage_e4__DOT__sum_r,
                        // m_fft->v__DOT__stage_e4__DOT__sum_i,
                        // m_fft->v__DOT__stage_o4__DOT__sum_r,
                        // m_fft->v__DOT__stage_o4__DOT__sum_i,
                        m_fft->v__DOT__stage_e4__DOT__ob_a,
                        m_fft->v__DOT__stage_e4__DOT__ob_b_r,
                        m_fft->v__DOT__stage_e4__DOT__ob_b_i,
                        m_fft->v__DOT__stage_o4__DOT__ob_a,
                        m_fft->v__DOT__stage_o4__DOT__ob_b_r,
                        m_fft->v__DOT__stage_o4__DOT__ob_b_i,
//                      m_fft->v__DOT__stage_2__DOT__out_0r,
//                      m_fft->v__DOT__stage_2__DOT__out_0i,
//                      m_fft->v__DOT__stage_2__DOT__out_1r,
//                      m_fft->v__DOT__stage_2__DOT__out_1i,
                        (m_fft->v__DOT__w_s2048)?"S":"-",
                        (m_fft->v__DOT__w_s1024)?"S":"-",
                        (m_fft->v__DOT__w_s512)?"S":"-",
                        (m_fft->v__DOT__w_s256)?"S":"-",
                        (m_fft->v__DOT__w_s128)?"S":"-",
                        (m_fft->v__DOT__w_s64)?"S":"-",
                        (m_fft->v__DOT__w_s32)?"S":"-",
                        (m_fft->v__DOT__w_s16)?"S":"-",
                        (m_fft->v__DOT__w_s8)?"S":"-",
                        (m_fft->v__DOT__w_s4)?"S":"-",
                //      (m_fft->v__DOT__w_s2)?"S":"-", // doesn't exist
                        (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);
        }
 
        bool    test(double lft_r, double lft_i, double rht_r, double rht_i) {
                int     ilft, irht, ilft_r, ilft_i, irht_r, irht_i;
 
                ilft_r = (int)(lft_r) & ((1<<IWIDTH)-1);
                ilft_i = (int)(lft_i) & ((1<<IWIDTH)-1);
                irht_r = (int)(rht_r) & ((1<<IWIDTH)-1);
                irht_i = (int)(rht_i) & ((1<<IWIDTH)-1);
 
                ilft = (ilft_r << IWIDTH) | ilft_i;
                irht = (irht_r << IWIDTH) | irht_i;
 
                return test(ilft, irht);
        }
 
        double  rdata(int addr) {
                long    ivl = m_data[addr & (FFTLEN-1)];
 
                ivl = twos_complement(ivl >> OWIDTH, OWIDTH);
                return (double)ivl;
        }
 
        double  idata(int addr) {
                long    ivl = m_data[addr & (FFTLEN-1)];
 
                ivl = twos_complement(ivl, OWIDTH);
                return (double)ivl;
        }
 
        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->reset();
        fft->dump(fpout);
 
        //     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
        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(32767.0,0.0,-32767.0,0.0);
        // 66.
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,-32767.0,0.0,32767.0);
        // 67.
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(-32768.0,-32768.0,-32768.0,-32768.0);
        // 68.
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,-32767.0,0.0,32767.0);
        // 69.
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(0.0,32767.0,0.0,-32767.0);
        // 70. 
        for(int k=0; k<FFTLEN/2; k++)
                fft->test(-32768.0,-32768.0,-32768.0,-32768.0);
 
        // 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);
 
        // 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);
        }
 
        // 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);
 
        printf("SUCCESS!!\n");
        exit(0);
}
 
 

Line No.	Rev	Author	Line
1	7	dgisselq	`//`
2	9	dgisselq	`// Filename: fft_tb.cpp`
3	7	dgisselq	`//`
4			`// Project: A Doubletime Pipelined FFT`
5			`//`
6	14	dgisselq	`// Purpose: A test-bench for the main program, fftmain.v, of the double`
7	9	dgisselq	`// clocked FFT. This file may be run autonomously (when`
8			`// fully functional). If so, the last line output will either`
9			`// read "SUCCESS" on success, or some other failure message`
10			`// otherwise.`
11	7	dgisselq	`//`
12			`// This file depends upon verilator to both compile, run, and`
13	9	dgisselq	`// therefore test fftmain.v`
14	7	dgisselq	`//`
15			`// Creator: Dan Gisselquist, Ph.D.`
16			`// Gisselquist Tecnology, LLC`
17			`//`
18			`///////////////////////////////////////////////////////////////////////////`
19			`//`
20			`// Copyright (C) 2015, Gisselquist Technology, LLC`
21			`//`
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			`// with this program. (It's in the $(ROOT)/doc directory, run make with no`
34			`// 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			`///////////////////////////////////////////////////////////////////////////`
42			`#include <stdio.h>`
43	9	dgisselq	`#include <math.h>`
44			`#include <fftw3.h>`
45	7	dgisselq
46			`#include "verilated.h"`
47			`#include "Vfftmain.h"`
48
49			`#define LGWIDTH 11`
50			`#define IWIDTH 16`
51			`#define OWIDTH 22`
52
53			`#define FFTLEN (1<<LGWIDTH)`
54
55			`class FFT_TB {`
56			`public:`
57			`Vfftmain *m_fft;`
58	9	dgisselq	`long m_data[FFTLEN], m_log[4*FFTLEN];`
59			`int m_iaddr, m_oaddr, m_ntest;`
60	7	dgisselq	`FILE *m_dumpfp;`
61	9	dgisselq	`fftw_plan m_plan;`
62			`double *m_fft_buf;`
63			`bool m_syncd;`
64	7	dgisselq
65			`FFT_TB(void) {`
66			`m_fft = new Vfftmain;`
67	9	dgisselq	`m_iaddr = m_oaddr = 0;`
68	7	dgisselq	`m_dumpfp = NULL;`
69	9	dgisselq
70			`m_fft_buf = (double )fftw_malloc(sizeof(fftw_complex)(FFTLEN));`
71			`m_plan = fftw_plan_dft_1d(FFTLEN, (fftw_complex *)m_fft_buf,`
72			`(fftw_complex *)m_fft_buf,`
73			`FFTW_FORWARD, FFTW_MEASURE);`
74			`m_syncd = false;`
75			`m_ntest = 0;`
76	7	dgisselq	`}`
77
78			`void tick(void) {`
79			`m_fft->i_clk = 0;`
80			`m_fft->eval();`
81			`m_fft->i_clk = 1;`
82			`m_fft->eval();`
83			`}`
84
85			`void reset(void) {`
86			`m_fft->i_ce = 0;`
87			`m_fft->i_rst = 1;`
88			`tick();`
89			`m_fft->i_rst = 0;`
90			`tick();`
91	9	dgisselq
92			`m_iaddr = m_oaddr = 0;`
93			`m_syncd = false;`
94	7	dgisselq	`}`
95
96	9	dgisselq	`long twos_complement(const long val, const int bits) {`
97			`long r;`
98
99			`r = val & ((1l<<bits)-1);`
100			`if (r & (1l << (bits-1)))`
101			`r \|= (-1l << bits);`
102			`return r;`
103			`}`
104
105			`void checkresults(void) {`
106			`double dp, sp; // Complex array`
107			`double vout[FFTLEN*2];`
108			`double isq=0.0, osq = 0.0;`
109			`long *lp;`
110
111			`// Fill up our test array from the log array`
112	16	dgisselq	`// printf("%3d : CHECK: %8d %5x\n", m_ntest, m_iaddr, m_iaddr);`
113	9	dgisselq	`dp = m_fft_buf; lp = &m_log[(m_iaddr-FFTLEN3)&((4FFTLEN-1)&(-FFTLEN))];`
114			`for(int i=0; i<FFTLEN; i++) {`
115			`long tv = *lp++;`
116
117			`dp[0] = twos_complement(tv >> IWIDTH, IWIDTH);`
118			`dp[1] = twos_complement(tv, IWIDTH);`
119
120	16	dgisselq	`// printf("IN[%4d = %4x] = %9.1f %9.1f\n",`
121			`// i+((m_iaddr-FFTLEN3)&((4FFTLEN-1)&(-FFTLEN))),`
122			`// i+((m_iaddr-FFTLEN3)&((4FFTLEN-1)&(-FFTLEN))),`
123			`// dp[0], dp[1]);`
124	9	dgisselq	`dp += 2;`
125			`}`
126
127			`// Let's measure ... are we the zero vector? If not, how close?`
128			`dp = m_fft_buf;`
129			`for(int i=0; i<FFTLEN; i++)`
130			`isq += (dp) (*dp);`
131
132			`fftw_execute(m_plan);`
133
134			`// Let's load up the output we received into vout`
135			`dp = vout;`
136			`for(int i=0; i<FFTLEN; i++) {`
137			`long tv = m_data[i];`
138
139	16	dgisselq	`// printf("OUT[%4d = %4x] = ", i, i);`
140			`// printf("%12lx = ", tv);`
141	9	dgisselq	`*dp = twos_complement(tv >> OWIDTH, OWIDTH);`
142	16	dgisselq	`// printf("%10.1f + ", *dp);`
143	9	dgisselq	`osq += (dp) (*dp); dp++;`
144			`*dp = twos_complement(tv, OWIDTH);`
145	16	dgisselq	`// printf("%10.1f j", *dp);`
146	9	dgisselq	`osq += (dp) (*dp); dp++;`
147	16	dgisselq	`// printf(" <-> %12.1f %12.1f\n", m_fft_buf[2i], m_fft_buf[2i+1]);`
148	9	dgisselq	`}`
149
150
151			`// Let's figure out if there's a scale factor difference ...`
152			`double scale = 0.0, wt = 0.0;`
153			`sp = m_fft_buf; dp = vout;`
154			`for(int i=0; i<FFTLEN*2; i++) {`
155			`scale += (sp) (*dp++);`
156			`wt += (sp) (*sp); sp++;`
157			`} scale = scale / wt;`
158
159			`if (wt == 0.0) scale = 1.0;`
160
161			`double xisq = 0.0;`
162			`sp = m_fft_buf; dp = vout;`
163			`for(int i=0; i<FFTLEN*2; i++) {`
164			`double vl = (sp++) scale - (*dp++);`
165			`xisq += vl * vl;`
166			`}`
167
168			`printf("%3d : SCALE = %12.6f, WT = %18.1f, ISQ = %15.1f, ",`
169			`m_ntest, scale, wt, isq);`
170			`printf("OSQ = %18.1f, ", osq);`
171			`printf("XISQ = %18.1f\n", xisq);`
172	16	dgisselq	`if (xisq > 1.2 * FFTLEN/2) {`
173			`printf("TEST FAIL!! Result is out of bounds from ");`
174			`printf("expected result with FFTW3.\n");`
175			`exit(-2);`
176			`}`
177	9	dgisselq	`m_ntest++;`
178			`}`
179
180	7	dgisselq	`bool test(int lft, int rht) {`
181			`m_fft->i_ce = 1;`
182			`m_fft->i_rst = 0;`
183			`m_fft->i_left = lft;`
184			`m_fft->i_right = rht;`
185
186	9	dgisselq	`m_log[(m_iaddr++)&(4*FFTLEN-1)] = (long)lft;`
187			`m_log[(m_iaddr++)&(4*FFTLEN-1)] = (long)rht;`
188
189	7	dgisselq	`tick();`
190
191			`if (m_fft->o_sync) {`
192	9	dgisselq	`m_oaddr &= (-1<<LGWIDTH);`
193			`m_syncd = true;`
194			`} else m_oaddr += 2;`
195	7	dgisselq
196	16	dgisselq	`/*`
197	9	dgisselq	`printf("%8x,%5d: %08x,%08x -> %011lx,%011lx"`
198			`// "\t%011lx,%011lx"`
199			`// "\t%011lx,%011lx"`
200			`// "\t%06x,%06x"`
201			`// "\t%06x,%06x"`
202			`"\t%011lx,%06x,%06x"`
203			`"\t%011lx,%06x,%06x"`
204			`" %s%s%s%s%s%s%s%s%s%s %s%s\n",`
205			`m_iaddr, m_oaddr,`
206	7	dgisselq	`lft, rht, m_fft->o_left, m_fft->o_right,`
207	9	dgisselq	`// m_fft->v__DOT__stage_e2048__DOT__ib_a,`
208			`// m_fft->v__DOT__stage_e2048__DOT__ib_b,`
209			`// m_fft->v__DOT__stage_e512__DOT__ib_a,`
210			`// m_fft->v__DOT__stage_e512__DOT__ib_b,`
211			`// m_fft->v__DOT__stage_e256__DOT__ib_a,`
212			`// m_fft->v__DOT__stage_e256__DOT__ib_b,`
213			`// m_fft->v__DOT__stage_e128__DOT__ib_a,`
214			`// m_fft->v__DOT__stage_e128__DOT__ib_b,`
215			`// m_fft->v__DOT__stage_e64__DOT__ib_a,`
216			`// m_fft->v__DOT__stage_e64__DOT__ib_b,`
217			`// m_fft->v__DOT__stage_e32__DOT__ib_a,`
218			`// m_fft->v__DOT__stage_e32__DOT__ib_b,`
219			`// m_fft->v__DOT__stage_e16__DOT__ib_a,`
220			`// m_fft->v__DOT__stage_e16__DOT__ib_b,`
221			`// m_fft->v__DOT__stage_e8__DOT__ib_a,`
222			`// m_fft->v__DOT__stage_e8__DOT__ib_b,`
223			`// m_fft->v__DOT__stage_o8__DOT__ib_a,`
224			`// m_fft->v__DOT__stage_o8__DOT__ib_b,`
225			`// m_fft->v__DOT__stage_e4__DOT__sum_r,`
226			`// m_fft->v__DOT__stage_e4__DOT__sum_i,`
227			`// m_fft->v__DOT__stage_o4__DOT__sum_r,`
228			`// m_fft->v__DOT__stage_o4__DOT__sum_i,`
229			`m_fft->v__DOT__stage_e4__DOT__ob_a,`
230			`m_fft->v__DOT__stage_e4__DOT__ob_b_r,`
231			`m_fft->v__DOT__stage_e4__DOT__ob_b_i,`
232			`m_fft->v__DOT__stage_o4__DOT__ob_a,`
233			`m_fft->v__DOT__stage_o4__DOT__ob_b_r,`
234			`m_fft->v__DOT__stage_o4__DOT__ob_b_i,`
235			`// m_fft->v__DOT__stage_2__DOT__out_0r,`
236			`// m_fft->v__DOT__stage_2__DOT__out_0i,`
237			`// m_fft->v__DOT__stage_2__DOT__out_1r,`
238			`// m_fft->v__DOT__stage_2__DOT__out_1i,`
239	7	dgisselq	`(m_fft->v__DOT__w_s2048)?"S":"-",`
240			`(m_fft->v__DOT__w_s1024)?"S":"-",`
241			`(m_fft->v__DOT__w_s512)?"S":"-",`
242			`(m_fft->v__DOT__w_s256)?"S":"-",`
243			`(m_fft->v__DOT__w_s128)?"S":"-",`
244			`(m_fft->v__DOT__w_s64)?"S":"-",`
245			`(m_fft->v__DOT__w_s32)?"S":"-",`
246	9	dgisselq	`(m_fft->v__DOT__w_s16)?"S":"-",`
247	7	dgisselq	`(m_fft->v__DOT__w_s8)?"S":"-",`
248	9	dgisselq	`(m_fft->v__DOT__w_s4)?"S":"-",`
249			`// (m_fft->v__DOT__w_s2)?"S":"-", // doesn't exist`
250			`(m_fft->o_sync)?"\t(SYNC!)":"",`
251			`(m_fft->o_left \| m_fft->o_right)?" (NZ)":"");`
252	16	dgisselq	`*/`
253	7	dgisselq
254	9	dgisselq	`m_data[(m_oaddr )&(FFTLEN-1)] = m_fft->o_left;`
255			`m_data[(m_oaddr+1)&(FFTLEN-1)] = m_fft->o_right;`
256	7	dgisselq
257	9	dgisselq	`if ((m_syncd)&&((m_oaddr&(FFTLEN-1)) == FFTLEN-2)) {`
258	7	dgisselq	`dumpwrite();`
259	9	dgisselq	`checkresults();`
260			`}`
261	7	dgisselq
262			`return (m_fft->o_sync);`
263			`}`
264
265			`bool test(double lft_r, double lft_i, double rht_r, double rht_i) {`
266			`int ilft, irht, ilft_r, ilft_i, irht_r, irht_i;`
267
268	9	dgisselq	`ilft_r = (int)(lft_r) & ((1<<IWIDTH)-1);`
269			`ilft_i = (int)(lft_i) & ((1<<IWIDTH)-1);`
270			`irht_r = (int)(rht_r) & ((1<<IWIDTH)-1);`
271			`irht_i = (int)(rht_i) & ((1<<IWIDTH)-1);`
272	7	dgisselq
273			`ilft = (ilft_r << IWIDTH) \| ilft_i;`
274			`irht = (irht_r << IWIDTH) \| irht_i;`
275
276			`return test(ilft, irht);`
277			`}`
278
279			`double rdata(int addr) {`
280			`long ivl = m_data[addr & (FFTLEN-1)];`
281
282	14	dgisselq	`ivl = twos_complement(ivl >> OWIDTH, OWIDTH);`
283	7	dgisselq	`return (double)ivl;`
284			`}`
285
286			`double idata(int addr) {`
287			`long ivl = m_data[addr & (FFTLEN-1)];`
288
289	14	dgisselq	`ivl = twos_complement(ivl, OWIDTH);`
290	7	dgisselq	`return (double)ivl;`
291			`}`
292
293			`void dump(FILE *fp) {`
294			`m_dumpfp = fp;`
295			`}`
296
297			`void dumpwrite(void) {`
298			`if (!m_dumpfp)`
299			`return;`
300
301			`double *buf;`
302
303			`buf = new double[FFTLEN * 2];`
304			`for(int i=0; i<FFTLEN; i++) {`
305			`buf[i*2] = rdata(i);`
306			`buf[i*2+1] = idata(i);`
307			`}`
308
309			`fwrite(buf, sizeof(double), FFTLEN*2, m_dumpfp);`
310			`delete[] buf;`
311			`}`
312			`};`
313
314	9	dgisselq
315	7	dgisselq	`int main(int argc, char argv, char envp) {`
316			`Verilated::commandArgs(argc, argv);`
317			`FFT_TB *fft = new FFT_TB;`
318			`FILE *fpout;`
319
320			`fpout = fopen("fft_tb.dbl", "w");`
321			`if (NULL == fpout) {`
322			`fprintf(stderr, "Cannot write output file, fft_tb.dbl\n");`
323			`exit(-1);`
324			`}`
325
326			`fft->reset();`
327			`fft->dump(fpout);`
328
329	9	dgisselq	`// 1 -> 0x0001`
330			`// 2 -> 0x0002`
331			`// 4 -> 0x0004`
332			`// 8 -> 0x0008`
333			`// 16 -> 0x0010`
334			`// 32 -> 0x0020`
335			`// 64 -> 0x0040`
336			`// 128 -> 0x0080`
337			`// 256 -> 0x0100`
338			`// 512 -> 0x0200`
339			`// 1024 -> 0x0400`
340			`// 2048 -> 0x0800`
341			`// 4096 -> 0x1000`
342			`// 8192 -> 0x2000`
343			`// 16384 -> 0x4000`
344			`for(int v=1; v<32768; v<<=1) for(int k=0; k<FFTLEN/2; k++)`
345			`fft->test((double)v,0.0,(double)v,0.0);`
346			`// 1 -> 0xffff`
347			`// 2 -> 0xfffe`
348			`// 4 -> 0xfffc`
349			`// 8 -> 0xfff8`
350			`// 16 -> 0xfff0`
351			`// 32 -> 0xffe0`
352			`// 64 -> 0xffc0`
353			`// 128 -> 0xff80`
354			`// 256 -> 0xff00`
355			`// 512 -> 0xfe00`
356			`// 1024 -> 0xfc00`
357			`// 2048 -> 0xf800`
358			`// 4096 -> 0xf000`
359			`// 8192 -> 0xe000`
360			`// 16384 -> 0xc000`
361			`// 32768 -> 0x8000`
362			`for(int v=1; v<=32768; v<<=1) for(int k=0; k<FFTLEN/2; k++)`
363			`fft->test(-(double)v,0.0,-(double)v,0.0);`
364			`// 1 -> 0x000040 CORRECT!!`
365			`// 2 -> 0x000080`
366			`// 4 -> 0x000100`
367			`// 8 -> 0x000200`
368			`// 16 -> 0x000400`
369			`// 32 -> 0x000800`
370			`// 64 -> 0x001000`
371			`// 128 -> 0x002000`
372			`// 256 -> 0x004000`
373			`// 512 -> 0x008000`
374			`// 1024 -> 0x010000`
375			`// 2048 -> 0x020000`
376			`// 4096 -> 0x040000`
377			`// 8192 -> 0x080000`
378			`// 16384 -> 0x100000`
379			`for(int v=1; v<32768; v<<=1) for(int k=0; k<FFTLEN/2; k++)`
380			`fft->test(0.0,(double)v,0.0,(double)v);`
381			`// 1 -> 0x3fffc0`
382			`// 2 -> 0x3fff80`
383			`// 4 -> 0x3fff00`
384			`// 8 -> 0x3ffe00`
385			`// 16 -> 0x3ffc00`
386			`// 32 -> 0x3ff800`
387			`// 64 -> 0x3ff000`
388			`// 128 -> 0x3fe000`
389			`// 256 -> 0x3fc000`
390			`// 512 -> 0x3f8000`
391			`// 1024 -> 0x3f0000`
392			`// 2048 -> 0x3e0000`
393			`// 4096 -> 0x3c0000`
394			`// 8192 -> 0x380000`
395			`// 16384 -> 0x300000`
396			`for(int v=1; v<32768; v<<=1) for(int k=0; k<FFTLEN/2; k++)`
397			`fft->test(0.0,-(double)v,0.0,-(double)v);`
398
399			`// 61. Now, how about the smallest alternating real signal`
400	7	dgisselq	`for(int k=0; k<FFTLEN/2; k++)`
401	9	dgisselq	`fft->test(2.0,0.0,0.0,0.0); // Don't forget to expect a bias!`
402			`// 62. Now, how about the smallest alternating imaginary signal`
403	7	dgisselq	`for(int k=0; k<FFTLEN/2; k++)`
404	9	dgisselq	`fft->test(0.0,2.0,0.0,0.0); // Don't forget to expect a bias!`
405			`// 63. Now, how about the smallest alternating real signal,2nd phase`
406	7	dgisselq	`for(int k=0; k<FFTLEN/2; k++)`
407	9	dgisselq	`fft->test(0.0,0.0,2.0,0.0); // Don't forget to expect a bias!`
408			`// 64.Now, how about the smallest alternating imaginary signal,2nd phase`
409	7	dgisselq	`for(int k=0; k<FFTLEN/2; k++)`
410	9	dgisselq	`fft->test(0.0,0.0,0.0,2.0); // Don't forget to expect a bias!`
411
412			`// 65.`
413	7	dgisselq	`for(int k=0; k<FFTLEN/2; k++)`
414	9	dgisselq	`fft->test(32767.0,0.0,-32767.0,0.0);`
415			`// 66.`
416	7	dgisselq	`for(int k=0; k<FFTLEN/2; k++)`
417	9	dgisselq	`fft->test(0.0,-32767.0,0.0,32767.0);`
418			`// 67.`
419	7	dgisselq	`for(int k=0; k<FFTLEN/2; k++)`
420	9	dgisselq	`fft->test(-32768.0,-32768.0,-32768.0,-32768.0);`
421			`// 68.`
422	7	dgisselq	`for(int k=0; k<FFTLEN/2; k++)`
423	9	dgisselq	`fft->test(0.0,-32767.0,0.0,32767.0);`
424			`// 69.`
425	7	dgisselq	`for(int k=0; k<FFTLEN/2; k++)`
426	9	dgisselq	`fft->test(0.0,32767.0,0.0,-32767.0);`
427			`// 70.`
428			`for(int k=0; k<FFTLEN/2; k++)`
429	7	dgisselq	`fft->test(-32768.0,-32768.0,-32768.0,-32768.0);`
430
431	9	dgisselq	`// 71. Now let's go for an impulse (SUCCESS)`
432			`fft->test(16384.0, 0.0, 0.0, 0.0);`
433			`for(int k=0; k<FFTLEN/2-1; k++)`
434	7	dgisselq	`fft->test(0.0,0.0,0.0,0.0);`
435
436	9	dgisselq	`// 72. And another one on the next clock (FAILS, ugly)`
437			`fft->test(0.0, 0.0, 16384.0, 0.0);`
438			`for(int k=0; k<FFTLEN/2-1; k++)`
439			`fft->test(0.0,0.0,0.0,0.0);`
440	7	dgisselq
441	9	dgisselq	`// 73. And an imaginary one on the second clock`
442			`fft->test(0.0, 0.0, 0.0, 16384.0);`
443			`for(int k=0; k<FFTLEN/2-1; k++)`
444			`fft->test(0.0,0.0,0.0,0.0);`
445	7	dgisselq
446	9	dgisselq	`// 74. Likewise the next clock`
447			`fft->test(0.0,0.0,0.0,0.0);`
448			`fft->test(16384.0, 0.0, 0.0, 0.0);`
449			`for(int k=0; k<FFTLEN/2-2; k++)`
450			`fft->test(0.0,0.0,0.0,0.0);`
451	7	dgisselq
452	9	dgisselq	`// 75. And it's imaginary counterpart`
453			`fft->test(0.0,0.0,0.0,0.0);`
454			`fft->test(0.0, 16384.0, 0.0, 0.0);`
455			`for(int k=0; k<FFTLEN/2-2; k++)`
456			`fft->test(0.0,0.0,0.0,0.0);`
457
458			`// 76. Likewise the next clock`
459			`fft->test(0.0,0.0,0.0,0.0);`
460			`fft->test(0.0, 0.0, 16384.0, 0.0);`
461			`for(int k=0; k<FFTLEN/2-2; k++)`
462			`fft->test(0.0,0.0,0.0,0.0);`
463
464			`// 77. And it's imaginary counterpart`
465			`fft->test(0.0,0.0,0.0,0.0);`
466			`fft->test(0.0, 0.0, 0.0, 16384.0);`
467			`for(int k=0; k<FFTLEN/2-2; k++)`
468			`fft->test(0.0,0.0,0.0,0.0);`
469
470
471			`// 78. Now let's try some exponentials`
472			`for(int k=0; k<FFTLEN/2; k++) {`
473			`double cl, cr, sl, sr, W;`
474			`W = - 2.0 * M_PI / FFTLEN;`
475			`cl = cos(W * (2k )) 16383.0;`
476			`sl = sin(W * (2k )) 16383.0;`
477			`cr = cos(W * (2k+1)) 16383.0;`
478			`sr = sin(W * (2k+1)) 16383.0;`
479			`fft->test(cl, sl, cr, sr);`
480			`}`
481
482			`// 72.`
483			`for(int k=0; k<FFTLEN/2; k++) {`
484			`double cl, cr, sl, sr, W;`
485			`W = - 2.0 * M_PI / FFTLEN * 5;`
486			`cl = cos(W * (2k )) 16383.0;`
487			`sl = sin(W * (2k )) 16383.0;`
488			`cr = cos(W * (2k+1)) 16383.0;`
489			`sr = sin(W * (2k+1)) 16383.0;`
490			`fft->test(cl, sl, cr, sr);`
491			`}`
492
493			`// 73.`
494			`for(int k=0; k<FFTLEN/2; k++) {`
495			`double cl, cr, sl, sr, W;`
496			`W = - 2.0 * M_PI / FFTLEN * 8;`
497			`cl = cos(W * (2k )) 8190.0;`
498			`sl = sin(W * (2k )) 8190.0;`
499			`cr = cos(W * (2k+1)) 8190.0;`
500			`sr = sin(W * (2k+1)) 8190.0;`

Browse

Tools

Subversion Repositories dblclockfft

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