Subversion Repositories dblclockfft

////////////////////////////////////////////////////////////////////////////

//

// Filename:    laststage_tb.cpp

//

// Project:     A Doubletime Pipelined FFT

//

// Purpose:     A test-bench for the laststage.v subfile of the general purpose

//              pipelined FFT.  This file may be run autonomously.  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 laststage.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 <stdint.h>

#include "verilated.h"

#include "verilated_vcd_c.h"

#include "Vlaststage.h"

#include "twoc.h"

#define IWIDTH  16

#define OWIDTH  (IWIDTH+1)

#define SHIFT   0

#define ROUND   1

#define ASIZ    32

#define AMSK    (ASIZ-1)

class   LASTSTAGE_TB {

public:

        Vlaststage      *m_last;

        VerilatedVcdC   *m_trace;

#ifdef  DBLCLKFFT

        unsigned long   m_left[ASIZ], m_right[ASIZ];

#else

        unsigned long   m_data[ASIZ];

#endif

        bool            m_syncd;

        int             m_addr, m_offset;

        unsigned long   m_tickcount;

        LASTSTAGE_TB(void) {

                Verilated::traceEverOn(true);

                m_last = new Vlaststage;

                m_tickcount = 0;

                m_syncd = false; m_addr = 0, m_offset = 0;

        }

        void    opentrace(const char *vcdname) {

                if (!m_trace) {

                        m_trace = new VerilatedVcdC;

                        m_last->trace(m_trace, 99);

                        m_trace->open(vcdname);

                }

        }

        void    closetrace(void) {

                if (m_trace) {

                        m_trace->close();

                        delete m_trace;

                        m_trace = NULL;

                }

        }

        void    tick(void) {

                m_tickcount++;

                m_last->i_clk = 0;

                m_last->eval();

                if (m_trace) m_trace->dump((uint64_t)(10ul * m_tickcount - 2));

                m_last->i_clk = 1;

                m_last->eval();

                if (m_trace) m_trace->dump((uint64_t)(10ul * m_tickcount));

                m_last->i_clk = 0;

                m_last->eval();

                if (m_trace) {

                        m_trace->dump((uint64_t)(10ul * m_tickcount + 5));

                        m_trace->flush();

                }

                m_last->i_reset  = 0;

                m_last->i_sync = 0;

        }

        void    cetick(void) {

                int     nkce;

                tick();

                nkce = (rand()&1);

#ifdef  FFT_CKPCE

                nkce += FFT_CKPCE;

#endif

                if ((m_last->i_ce)&&(nkce > 0)) {

                        m_last->i_ce = 0;

                        for(int kce = 1; kce < nkce; kce++)

                                tick();

                        m_last->i_ce = 1;

                }

        }

        void    reset(void) {

                m_last->i_reset = 1;

                tick();

                m_syncd = false; m_addr = 0, m_offset = 0;

        }

        void    check_results(void) {

                bool    failed = false;

                if ((!m_syncd)&&(m_last->o_sync)) {

                        m_syncd = true;

                        m_offset = m_addr;

                        printf("SYNCD at %d\n", m_addr);

                }

#ifdef  DBLCLKFFT

                int     ir0, ir1, ii0, ii1, or0, oi0, or1, oi1;

                ir0 = sbits(m_left[ (m_addr-m_offset)&AMSK]>>IWIDTH, IWIDTH);

                ir1 = sbits(m_right[(m_addr-m_offset)&AMSK]>>IWIDTH, IWIDTH);

                ii0 = sbits(m_left[ (m_addr-m_offset)&AMSK], IWIDTH);

                ii1 = sbits(m_right[(m_addr-m_offset)&AMSK], IWIDTH);

                or0 = sbits(m_last->o_left  >> OWIDTH, OWIDTH);

                oi0 = sbits(m_last->o_left           , OWIDTH);

                or1 = sbits(m_last->o_right >> OWIDTH, OWIDTH);

                oi1 = sbits(m_last->o_right          , OWIDTH);

                // Sign extensions

                printf("k=%3d: IN = %08x:%08x, OUT =%09lx:%09lx, S=%d\n",

                        m_addr, m_last->i_left, m_last->i_right,

                        m_last->o_left, m_last->o_right,

                        m_last->o_sync);

                /*

                printf("\tI0 = { %x : %x }, I1 = { %x : %x }, O0 = { %x : %x }, O1 = { %x : %x }\n",

                        ir0, ii0, ir1, ii1, or0, oi0, or1, oi1);

                */

                if (m_syncd) {

                        if (or0 != (ir0 + ir1)) {

                                printf("FAIL 1: or0 != (ir0+ir1), or %x(exp) != %x(sut)\n", (ir0+ir1), or0);

                                failed=true;}

                        if (oi0 != (ii0 + ii1)) {printf("FAIL 2\n"); failed=true;}

                        if (or1 != (ir0 - ir1)) {printf("FAIL 3\n"); failed=true;}

                        if (oi1 != (ii0 - ii1)) {printf("FAIL 4\n"); failed=true;}

                } else if (m_addr > 20) {

                        printf("NO SYNC!\n");

                        failed = true;

                }

#else

                int     or0, oi0;

                int     sumr, sumi, difr, difi;

                int     ir0, ii0, ir1, ii1, ir2, ii2, ir3, ii3, irn, iin;

                irn = sbits(m_data[(m_addr-m_offset+2)&AMSK]>>IWIDTH, IWIDTH);

                iin = sbits(m_data[(m_addr-m_offset+2)&AMSK], IWIDTH);

                ir0 = sbits(m_data[(m_addr-m_offset+1)&AMSK]>>IWIDTH, IWIDTH);

                ii0 = sbits(m_data[(m_addr-m_offset+1)&AMSK], IWIDTH);

                ir1 = sbits(m_data[(m_addr-m_offset  )&AMSK]>>IWIDTH, IWIDTH);

                ii1 = sbits(m_data[(m_addr-m_offset  )&AMSK], IWIDTH);

                ir2 = sbits(m_data[(m_addr-m_offset-1)&AMSK]>>IWIDTH, IWIDTH);

                ii2 = sbits(m_data[(m_addr-m_offset-1)&AMSK], IWIDTH);

                ir3 = sbits(m_data[(m_addr-m_offset-2)&AMSK]>>IWIDTH, IWIDTH);

                ii3 = sbits(m_data[(m_addr-m_offset-2)&AMSK], IWIDTH);

                sumr = ir1 + ir0;

                sumi = ii1 + ii0;

                difr = ir2 - ir1;

                difi = ii2 - ii1;

                or0 = sbits(m_last->o_val  >> OWIDTH, OWIDTH);

                oi0 = sbits(m_last->o_val           , OWIDTH);

                printf("IR0 = %08x, IR1 = %08x, IR2 = %08x, ",

                                ir0, ir1, ir2);

                printf("II0 = %08x, II1 = %08x, II2 = %08x, ",

                                ii0, ii1, ii2);

                // Sign extensions

                printf("k=%3d: IN = %08x, %c, OUT =%09lx, S=%d\n",

                        m_addr, m_last->i_val,

                        m_last->i_sync ? 'S':' ',

                        m_last->o_val, m_last->o_sync);

                if ((m_syncd)&&(0 == ((m_addr-m_offset)&1))) {

                        if (or0 != sumr)        {

                                printf("FAIL 1: or0 != (ir0+ir1), or %x(exp) != %x(sut)\n", sumr, or0);

                                failed=true;

                        } if (oi0 != sumi)      {

                                printf("FAIL 2\n");

                                failed=true;

                        }

                } else if ((m_syncd)&&(1 == ((m_addr-m_offset)&1))) {

                        if (or0 != difr) {

                                printf("FAIL 3: or0 != (ir1-ir0), or %x(exp) != %x(sut)\n", difr, or0);

                                failed=true;

                        } if (oi0 != difi) {

                                printf("FAIL 4: oi0 != (ii1-ii0), or %x(exp) != %x(sut)\n", difi, oi0);

                                failed=true;

                        }

                } else if (m_addr > 20) {

                        printf("NO SYNC!\n");

                        failed = true;

                }

#endif

                if (failed)

                        exit(-2);

        }

        void    sync(void) {

                m_last->i_sync = 1;

        }

        void    test(unsigned long left, unsigned long right) {

                m_last->i_ce    = 1;

                if (m_last->i_sync)

                        m_addr = 0;

#ifdef  DBLCLKFFT

                m_last->i_left  = left;

                m_last->i_right = right;

                m_left[ m_addr&AMSK] = m_last->i_left;

                m_right[m_addr&AMSK] = m_last->i_right;

                m_addr++;

                cetick();

#else

                m_last->i_val = left;

                m_data[ m_addr&AMSK] = m_last->i_val;

                m_addr = (m_addr+1);

                cetick();

                check_results();

                m_last->i_val = right;

                m_data[m_addr&AMSK] = m_last->i_val;

                m_addr = (m_addr+1)&AMSK;

                cetick();

#endif

                check_results();

        }

        void    test(int ir0, int ii0, int ir1, int ii1) {

                unsigned long   left, right, mask = (1<<IWIDTH)-1;

                left  = ((ir0&mask) << IWIDTH) | (ii0 & mask);

                right = ((ir1&mask) << IWIDTH) | (ii1 & mask);

                test(left, right);

        }

};

int     main(int argc, char **argv, char **envp) {

        Verilated::commandArgs(argc, argv);

        LASTSTAGE_TB    *tb = new LASTSTAGE_TB;

        tb->opentrace("laststage.vcd");

        tb->reset();

        tb->sync();

        tb->test( 1, 0,0,0);

        tb->test( 0, 2,0,0);

        tb->test( 0, 0,4,0);

        tb->test( 0, 0,0,8);

        tb->test( 0, 0,0,0);

        tb->test(16,16,0,0);

        tb->test(0,0,16,16);

        tb->test(16,-16,0,0);

        tb->test(0,0,16,-16);

        tb->test(16,16,0,0);

        tb->test(0,0,16,16);

        for(int k=0; k<64; k++) {

                int16_t ir0, ii0, ir1, ii1;

                // Let's pick some random values, ...

                ir0 = rand(); if (ir0&4) ir0 = -ir0;

                ii0 = rand(); if (ii0&2) ii0 = -ii0;

                ir1 = rand(); if (ir1&1) ir1 = -ir1;

                ii1 = rand(); if (ii1&8) ii1 = -ii1;

                tb->test(ir0, ii0, ir1, ii1);

        }

        delete  tb;

        printf("SUCCESS!\n");

        exit(0);

}