Subversion Repositories dblclockfft

////////////////////////////////////////////////////////////////////////////////
//
// Filename: 	fftstage_tb.cpp
//
// Project:	A General Purpose Pipelined FFT Implementation
//
// Purpose:	A test-bench for a generic FFT stage which has been
//		instantiated by fftgen.  Without loss of (much) generality,
//	we'll examine the 2048 fftstage.v.  This file may be run autonomously.
//	If so, the last line output will either read "SUCCESS" on success, or
//	some other failure message otherwise.  Likewise the exit code will
//	also indicate success (exit(0)) or failure (anything else).
//
//	This file depends upon verilator to both compile, run, and therefore
//	test fftstage.v.  Also, you'll need to place a copy of the cmem_*2048
//	hex file into the directory where you run this test bench.
//
// 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 "Vfftstage.h"
#include "verilated.h"
#include "verilated_vcd_c.h"
#include "twoc.h"
#include "fftsize.h"
 
 
#ifdef	NEW_VERILATOR
#define	VVAR(A)	fftstage__DOT_ ## A
#else
#define	VVAR(A)	v__DOT_ ## A
#endif
 
#define	cmem	VVAR(_cmem)
#define	iaddr	VVAR(_iaddr)
#define	ib_sync	VVAR(_ib_sync)
#define	ib_a	VVAR(_ib_a)
#define	ib_b	VVAR(_ib_b)
#define	ib_c	VVAR(_ib_c)
 
#define	ob_sync	VVAR(_ob_sync)
#define	ob_a	VVAR(_ob_a)
#define	ob_b	VVAR(_ob_b)
 
#define	FFTBITS	(FFT_LGWIDTH)
#define	FFTLEN	(1<<FFTBITS)
#define	FFTSIZE	FFTLEN
#define	FFTMASK	(FFTLEN-1)
#define	IWIDTH	FFT_IWIDTH
#define	CWIDTH	20
#define	OWIDTH	(FFT_IWIDTH+1)
#define	BFLYSHIFT	0
#define	LGWIDTH	(FFT_LGWIDTH)
#ifdef	DBLCLKFFT
#define	LGSPAN	(LGWIDTH-2)
#else
#define	LGSPAN	(LGWIDTH-1)
#endif
#define	ROUND	true
 
#define	SPANLEN		(1<<LGSPAN)
#define	SPANMASK	(SPANLEN-1)
#define	DBLSPANLEN	(1<<(LGSPAN+4))
#define	DBLSPANMASK	(DBLSPANLEN-1)
 
const	bool	gbl_debug = false;
 
class	FFTSTAGE_TB {
public:
	Vfftstage	*m_ftstage;
	VerilatedVcdC	*m_trace;
	long		m_iaddr;
	long		m_vals[SPANLEN], m_out[DBLSPANLEN];
	bool		m_syncd, m_ib_syncd, m_ob_syncd, m_input_sync;
	int		m_offset, m_ib_offset, m_ob_offset;
	uint64_t	m_tickcount;
 
	FFTSTAGE_TB(void) {
		Verilated::traceEverOn(true);
		m_ftstage = new Vfftstage;
		m_syncd = false;
		m_input_sync = false;
		m_ib_syncd   = false;
		m_ob_syncd   = false;
		m_iaddr = 0;
		m_offset = 0;
		m_tickcount = 0;
assert(OWIDTH == IWIDTH+1);
	}
 
	void	opentrace(const char *vcdname) {
		if (!m_trace) {
			m_trace = new VerilatedVcdC;
			m_ftstage->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_ftstage->i_clk = 0;
		m_ftstage->eval();
		if (m_trace)	m_trace->dump((vluint64_t)(10ul*m_tickcount-2));
		m_ftstage->i_clk = 1;
		m_ftstage->eval();
		if (m_trace)	m_trace->dump((vluint64_t)(10ul*m_tickcount));
		m_ftstage->i_clk = 0;
		m_ftstage->eval();
		if (m_trace) {
			m_trace->dump((vluint64_t)(10ul*m_tickcount+5));
			m_trace->flush();
		}
	}
 
	void	cetick(void) {
		int	ce = m_ftstage->i_ce, nkce;
 
		tick();
		nkce = 0; // (rand()&1);
#ifdef	FFT_CKPCE
		nkce += FFT_CKPCE;
#endif
		if ((ce)&&(nkce > 0)) {
			m_ftstage->i_ce = 0;
			for(int kce = 1; kce < nkce; kce++)
				tick();
		}
 
		m_ftstage->i_ce = ce;
	}
 
	void	reset(void) {
		m_ftstage->i_ce  = 0;
		m_ftstage->i_reset = 1;
		m_ftstage->i_sync  = 0;
		tick();
 
		// Let's give it several ticks with no sync
		m_ftstage->i_ce = 0;
		m_ftstage->i_reset = 0;
		m_ftstage->i_sync  = 0;
		/*
		for(int i=0; i<8192; i++) {
			m_ftstage->i_data = rand();
			m_ftstage->i_sync = 0;
			m_ftstage->i_ce = 1;
 
			cetick();
 
			assert(m_ftstage->o_sync == 0);
		}
		*/
 
		m_iaddr = 0;
		m_offset = 0;
		m_syncd = false;
		m_ib_syncd = false;
		m_ob_syncd = false;
	}
 
	void	butterfly(const long cv, const long lft, const long rht,
				long &o_lft, long &o_rht) {
		long	cv_r, cv_i;
		long	lft_r, lft_i, rht_r, rht_i;
		long	o_lft_r, o_lft_i, o_rht_r, o_rht_i;
 
		cv_r = sbits(cv>>CWIDTH, CWIDTH);
		cv_i = sbits(cv, CWIDTH);
 
		lft_r = sbits(lft>>IWIDTH, IWIDTH);
		lft_i = sbits(lft, IWIDTH);
 
		rht_r = sbits(rht>>IWIDTH, IWIDTH);
		rht_i = sbits(rht, IWIDTH);
 
		o_lft_r = lft_r + rht_r;
		o_lft_i = lft_i + rht_i;
		o_lft_r = ubits(o_lft_r, OWIDTH);
		o_lft_i = ubits(o_lft_i, OWIDTH);
 
		// o_lft_r >>= 1;
		// o_lft_i >>= 1;
		o_lft = (o_lft_r << OWIDTH) | (o_lft_i);
 
		o_rht_r = (cv_r * (lft_r-rht_r)) - (cv_i * (lft_i-rht_i));
		o_rht_i = (cv_r * (lft_i-rht_i)) + (cv_i * (lft_r-rht_r));
 
		if (ROUND) {
			/* Non-convergent rounding
			if (o_rht_r & (1<<(CWIDTH-3)))
				o_rht_r += (1<<(CWIDTH-3))-1;
			if (o_rht_i & (1<<(CWIDTH-3)))
				o_rht_i += (1<<(CWIDTH-3))-1;
			*/
 
			// Convergent rounding
			if (o_rht_r & (1<<(CWIDTH-2)))
				o_rht_r += (1<<(CWIDTH-3));
			else
				o_rht_r += (1<<(CWIDTH-3))-1;
 
			if (o_rht_i & (1<<(CWIDTH-2)))
				o_rht_i += (1<<(CWIDTH-3));
			else
				o_rht_i += (1<<(CWIDTH-3))-1;
		}
 
		o_rht_r >>= (CWIDTH-2);
		o_rht_i >>= (CWIDTH-2);
 
		o_rht_r = ubits(o_rht_r, OWIDTH);
		o_rht_i = ubits(o_rht_i, OWIDTH);
		o_rht = (o_rht_r << OWIDTH) | (o_rht_i);
 
		/*
		printf("BUTTERFLY: %10lx %10lx %10lx -> %10lx %10lx\n",
			ubits(cv, 2*CWIDTH),
			ubits(lft,   2*IWIDTH), ubits(rht,   2*IWIDTH),
			ubits(o_lft, 2*OWIDTH), ubits(o_rht, 2*OWIDTH));
		*/
	}
 
	void	test(bool i_sync, long i_data) {
		long	cv;
		bool	bc;
		int	raddr;
		bool	failed = false;
 
		m_ftstage->i_reset = 0;
		m_ftstage->i_ce   = 1;
		m_ftstage->i_sync = i_sync;
		i_data = ubits(i_data, 2*IWIDTH);
		m_ftstage->i_data = i_data;
 
		if (!m_input_sync) {
			if (i_sync)
				m_input_sync = true;
			m_iaddr = 0;
		}
 
		cv = m_ftstage->cmem[m_iaddr & SPANMASK];
		bc = m_iaddr & (1<<LGSPAN);
		if (!bc)
			m_vals[m_iaddr & (SPANMASK)] = i_data;
		else {
			int	waddr = m_iaddr ^ (1<<LGSPAN);
			waddr &= (DBLSPANMASK);
			if (m_iaddr & (1<<(LGSPAN+1)))
				waddr |= (1<<(LGSPAN));
			butterfly(cv,
				m_vals[m_iaddr & (SPANMASK)],
				i_data,
				m_out[(m_iaddr-SPANLEN) & (DBLSPANMASK)],
				m_out[m_iaddr & (DBLSPANMASK)]);
		}
 
		cetick();
 
		unsigned	ib_addr = (m_iaddr - m_ib_offset)
					& ((SPANMASK<<1)|1);
		if ((!m_ib_syncd)&&(m_ftstage->ib_sync)) {
			m_ib_syncd = true;
			m_ib_offset = m_iaddr;
 
			if (gbl_debug) printf("IB-SYNC!!!!  Offset = %d\n", m_ib_offset);
		} else if ((m_ib_syncd)&&(ib_addr <(1<<(LGSPAN)))) {
			unsigned long	ib_a, ib_b, ib_c;
			ib_a = m_vals[ib_addr&SPANMASK];
			ib_b = i_data; // m_vals[(m_iaddr-m_ib_offset+(1<<(LGSPAN-1)))&(SPANMASK)];
			ib_c = m_ftstage->cmem[(m_iaddr-m_ib_offset)&(SPANMASK)];
 
			assert(m_ftstage->ib_a == ib_a);
			assert(m_ftstage->ib_b == ib_b);
			// assert(m_ftstage->ib_a == ib_a);
		}
 
		if ((!m_ob_syncd)&&(m_ftstage->ob_sync)) {
			m_ob_syncd = true;
			m_ob_offset = m_iaddr;
 
			if (gbl_debug) printf("OB-SYNC!!!!  Offset = %d\n", m_ob_offset);
		}
 
		if ((!m_syncd)&&(m_ftstage->o_sync)) {
			m_syncd = true;
			m_offset = m_iaddr;
 
			if (gbl_debug) printf("SYNC!!!!\n");
		}
 
		raddr = (m_iaddr-m_offset) & DBLSPANMASK;
 
		if (gbl_debug)
			printf("%4ld, %4ld: %d %9lx -> %d %9lx ... "
				"%4x %15lx (%10lx)",
			(long)m_iaddr, (long)raddr,
			// Input values
			i_sync, ubits(i_data, 2*IWIDTH),
			// Output values
			m_ftstage->o_sync,
			(long)m_ftstage->o_data,
 
			m_ftstage->iaddr&FFTMASK,
			(long)(ubits(m_ftstage->cmem[
				m_ftstage->iaddr&(SPANMASK)],
				2*CWIDTH)),
			(long)m_out[raddr]);
 
		unsigned long	oba, obb;
 
		oba = ubits(
		m_ftstage->VVAR(_HWBFLY__DOT__bfly__DOT__rnd_left_r),OWIDTH)
				<<OWIDTH;
		oba |= ubits(
		m_ftstage->VVAR(_HWBFLY__DOT__bfly__DOT__rnd_left_i), OWIDTH);
 
		obb = ubits(
		m_ftstage->VVAR(_HWBFLY__DOT__bfly__DOT__rnd_right_r), OWIDTH)
				<<OWIDTH;
		obb |= ubits(
		m_ftstage->VVAR(_HWBFLY__DOT__bfly__DOT__rnd_right_i), OWIDTH);
 
		if ((gbl_debug)&&(m_ob_syncd))
			printf(" [%d %10lx %10lx]",
				m_ftstage->ob_sync,
				ubits(oba, 2*OWIDTH), ubits(obb, 2*OWIDTH));
 
		if ((m_syncd)&&(m_ftstage->o_sync != ((((m_iaddr-m_offset)&((1<<(LGSPAN+1))-1))==0)?1:0))) {
			fprintf(stderr, "Bad output sync (m_iaddr = %lx, m_offset = %x)\n",
				(m_iaddr-m_offset) & SPANMASK, m_offset);
			failed = true;
		} if (gbl_debug) printf("\n");
 
		if (m_syncd) {
			if (m_out[raddr] != m_ftstage->o_data) {
				printf("Bad output data, ([%lx - %x = %x (%d)] "
					"%lx(exp) != %lx(sut))\n",
					m_iaddr, m_offset, raddr, raddr,
					m_out[raddr], (long)m_ftstage->o_data);
				failed = true;
			} // printf("Checked #%d\n", raddr);
		} else if (m_iaddr > FFTSIZE/2+128) {
			printf("NO OUTPUT SYNC!\n");
			failed = true;
		}
		m_iaddr++;
 
		if (failed)
			exit(-1);
	}
};
 
 
 
int	main(int argc, char **argv, char **envp) {
	Verilated::commandArgs(argc, argv);
	FFTSTAGE_TB	*ftstage = new FFTSTAGE_TB;
#ifdef	DBLCLKFFT
#define	STEP	2
#else
#define	STEP	1
#endif
 
	// ftstage->opentrace("fftstage.vcd");
	ftstage->reset();
 
	// Medium real (constant) value ... just for starters
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x00200000l);
	// Medium imaginary (constant) value ... just for starters
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x00000020l);
	// Medium sine wave, real
	for(int k=0; k<FFTSIZE; k+=STEP) {
		long vl;
		vl= (long)(cos(2.0 * M_PI * 1.0 / FFTSIZE * k)*(1l<<30) + 0.5);
		vl &= (-1l << 16); // Turn off the imaginary bit portion
		vl = ubits(vl,2*IWIDTH); // Turn off unused high order bits
		ftstage->test((k==1), vl);
	}
	// Smallest real value
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x00080000l);
	// Smallest imaginary value
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x00000001l);
	// Largest real value
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x200000000l);
	// Largest negative imaginary value
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x000010000l);
	// Let's try an impulse
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), (k==0)?0x020000000l:0l);
	// Now, let's clear out the result
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x000000000l);
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x000000000l);
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x000000000l);
	for(int k=0; k<FFTSIZE; k+=STEP)
		ftstage->test((k==0), 0x000000000l);
 
	printf("SUCCESS! (Offset = %d)\n", ftstage->m_offset);
	delete	ftstage;
 
	exit(EXIT_SUCCESS);
}