Subversion Repositories dblclockfft

////////////////////////////////////////////////////////////////////////////
//
// Filename: 	butterfly_tb.cpp
//
// Project:	A Doubletime Pipelined FFT
//
// Purpose:	A test-bench for the butterfly.v subfile of the generic
//		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 butterfly.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 "Vbutterfly.h"
#include "twoc.h"
#include "fftsize.h"
 
#ifdef	NEW_VERILATOR
#define	VVAR(A)	butterfly__DOT__ ## A
#else
#define	VVAR(A)	v__DOT_ ## A
#endif
 
#define	IWIDTH	TST_BUTTERFLY_IWIDTH
#define	CWIDTH	TST_BUTTERFLY_CWIDTH
#define	OWIDTH	TST_BUTTERFLY_OWIDTH
#define	BFLYDELAY	TST_BUTTERFLY_MPYDELAY
 
class	BFLY_TB {
public:
	Vbutterfly	*m_bfly;
	VerilatedVcdC	*m_trace;
	unsigned long	m_left[64], m_right[64];
	bool		m_aux[64];
	int		m_addr, m_lastaux, m_offset;
	bool		m_syncd, m_waiting_for_sync_input;
	uint64_t	m_tickcount;
 
	BFLY_TB(void) {
		Verilated::traceEverOn(true);
		m_trace = NULL;
		m_bfly = new Vbutterfly;
		m_addr = 0;
		m_syncd = 0;
		m_tickcount = 0;
		m_waiting_for_sync_input = true;
	}
 
	void	opentrace(const char *vcdname) {
		if (!m_trace) {
			m_trace = new VerilatedVcdC;
			m_bfly->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_lastaux = m_bfly->o_aux;
		m_bfly->i_clk = 0;
		m_bfly->eval();
		if (m_trace) m_trace->dump((uint64_t)(10ul*m_tickcount-2));
		m_bfly->i_clk = 1;
		m_bfly->eval();
		if (m_trace) m_trace->dump((uint64_t)(10ul*m_tickcount));
		m_bfly->i_clk = 0;
		m_bfly->eval();
		if (m_trace) {
			m_trace->dump((uint64_t)(10ul*m_tickcount+5));
			m_trace->flush();
		}
 
		if ((!m_syncd)&&(m_bfly->o_aux))
			m_offset = m_addr;
		m_syncd = (m_syncd) || (m_bfly->o_aux);
	}
 
	void	cetick(void) {
		int	ce = m_bfly->i_ce, nkce;
 
		tick();
 
		nkce = (rand()&1);
#ifdef	FFT_CKPCE
		nkce += FFT_CKPCE;
#endif
 
		if ((ce)&&(nkce > 0)) {
			m_bfly->i_ce = 0;
			for(int kce=0; kce<nkce-1; kce++)
				tick();
		}
 
		m_bfly->i_ce = ce;
	}
 
	void	reset(void) {
		m_bfly->i_ce    = 0;
		m_bfly->i_reset = 1;
		m_bfly->i_coef  = 0l;
		m_bfly->i_left  = 0;
		m_bfly->i_right = 0;
		tick();
		m_bfly->i_reset = 0;
		m_bfly->i_ce  = 1;
		//
		// Let's run a RESET test here, forcing the whole butterfly
		// to be filled with aux=1.  If the reset works right,
		// we'll never get an aux=1 output.
		//
		m_bfly->i_reset = 1;
		m_bfly->i_aux = 1;
		m_bfly->i_ce  = 1;
		for(int i=0; i<200; i++)
			cetick();
 
		// Now here's the RESET line, so let's see what the test does
		m_bfly->i_reset = 1;
		m_bfly->i_ce  = 1;
		m_bfly->i_aux = 1;
		cetick();
		m_bfly->i_reset = 0;
		m_syncd = 0;
 
		m_waiting_for_sync_input = true;
	}
 
	void	test(const int n, const int k, const unsigned long cof,
			const unsigned lft, const unsigned rht, const int aux) {
 
		m_bfly->i_coef  = ubits(cof, 2*TST_BUTTERFLY_CWIDTH);
		m_bfly->i_left  = ubits(lft, 2*TST_BUTTERFLY_IWIDTH);
		m_bfly->i_right = ubits(rht, 2*TST_BUTTERFLY_IWIDTH);
		m_bfly->i_aux   = aux & 1;
		if ((m_waiting_for_sync_input)&&(aux&1)) {
			m_waiting_for_sync_input = false;
			m_addr = 0;
		}
 
		m_bfly->i_ce = 1;
		cetick();
 
		if ((m_bfly->o_aux)&&(!m_lastaux))
			printf("\n");
		printf("n,k=%d,%3d: COEF=%0*lx, LFT=%0*x, RHT=%0*x, A=%d, OLFT =%0*lx, ORHT=%0*lx, AUX=%d\n",
			n,k,
			(2*CWIDTH+3)/4, ubits(m_bfly->i_coef, 2*CWIDTH),
			(2*IWIDTH+3)/4, m_bfly->i_left,
			(2*IWIDTH+3)/4, m_bfly->i_right,
			m_bfly->i_aux,
			(2*OWIDTH+3)/4, (long)m_bfly->o_left,
			(2*OWIDTH+3)/4, (long)m_bfly->o_right,
			m_bfly->o_aux);
 
		if ((m_syncd)&&(m_left[(m_addr-m_offset)&(64-1)] != m_bfly->o_left)) {
			printf("WRONG O_LEFT! (%lx(exp) != %lx(sut)\n",
				m_left[(m_addr-m_offset)&(64-1)],
				(long)m_bfly->o_left);
			exit(EXIT_FAILURE);
		}
 
		if ((m_syncd)&&(m_right[(m_addr-m_offset)&(64-1)] != m_bfly->o_right)) {
			printf("WRONG O_RIGHT! (%lx(exp) != %lx(sut))\n",
				m_right[(m_addr-m_offset)&(64-1)],
				(long)m_bfly->o_right);
			exit(EXIT_FAILURE);
		}
 
		if ((m_syncd)&&(m_aux[(m_addr-m_offset)&(64-1)] != m_bfly->o_aux)) {
			printf("FAILED AUX CHANNEL TEST (i.e. the SYNC)\n");
			exit(EXIT_FAILURE);
		}
 
		if ((m_addr > TST_BUTTERFLY_MPYDELAY+6)&&(!m_syncd)) {
			printf("NO SYNC PULSE!\n");
			exit(EXIT_FAILURE);
		}
 
		// Now, let's calculate an "expected" result ...
		long	rlft, ilft;
 
		// Extract left and right values ...
		rlft = sbits(m_bfly->i_left >> IWIDTH, IWIDTH);
		ilft = sbits(m_bfly->i_left          , IWIDTH);
 
		// Now repeat for the right hand value ...
		long	rrht, irht;
		// Extract left and right values ...
		rrht = sbits(m_bfly->i_right >> IWIDTH, IWIDTH);
		irht = sbits(m_bfly->i_right          , IWIDTH);
 
		// and again for the coefficients
		long	rcof, icof;
		// Extract left and right values ...
		rcof = sbits(m_bfly->i_coef >> CWIDTH, CWIDTH);
		icof = sbits(m_bfly->i_coef          , CWIDTH);
 
		// Now, let's do the butterfly ourselves ...
		long sumi, sumr, difi, difr;
		sumr = rlft + rrht;
		sumi = ilft + irht;
		difr = rlft - rrht;
		difi = ilft - irht;
 
	/*
		printf("L=%5lx+%5lx,R=%5lx+%5lx,S=%5lx+%5lx,D=%5lx+%5lx, ",
			rlft & 0x02ffffl,
			ilft & 0x02ffffl,
			rrht & 0x02ffffl,
			irht & 0x02ffffl,
			sumr & 0x02ffffl,
			sumi & 0x02ffffl,
			difr & 0x02ffffl,
			difi & 0x02ffffl);
	*/
		long p1, p2, p3, mpyr, mpyi;
		p1 = difr * rcof;
		p2 = difi * icof;
		p3 = (difr + difi) * (rcof + icof);
 
		mpyr = p1-p2;
		mpyi = p3-p1-p2;
 
		mpyr = rndbits(mpyr, (IWIDTH+2)+(CWIDTH+1), OWIDTH+4);
		mpyi = rndbits(mpyi, (IWIDTH+2)+(CWIDTH+1), OWIDTH+4);
 
	/*
		printf("RC=%lx, IC=%lx, ", rcof, icof);
		printf("P1=%lx,P2=%lx,P3=%lx, ", p1,p2,p3);
		printf("MPYr = %lx, ", mpyr);
		printf("MPYi = %lx, ", mpyi);
	*/
 
		long	o_left_r, o_left_i, o_right_r, o_right_i;
		unsigned long	o_left, o_right;
 
		o_left_r = rndbits(sumr<<(CWIDTH-2), CWIDTH+IWIDTH+3, OWIDTH+4);
			o_left_r = ubits(o_left_r, OWIDTH);
		o_left_i = rndbits(sumi<<(CWIDTH-2), CWIDTH+IWIDTH+3, OWIDTH+4);
			o_left_i = ubits(o_left_i, OWIDTH);
		o_left = (o_left_r << OWIDTH) | (o_left_i);
 
		o_right_r = ubits(mpyr, OWIDTH);
		o_right_i = ubits(mpyi, OWIDTH);
		o_right = (o_right_r << OWIDTH) | (o_right_i);
	/*
		printf("oR_r = %lx, ", o_right_r);
		printf("oR_i = %lx\n", o_right_i);
	*/
 
		m_left[ m_addr&(64-1)] = o_left;
		m_right[m_addr&(64-1)] = o_right;
		m_aux[  m_addr&(64-1)] = aux;
 
		m_addr++;
	}
};
 
long gentestword(int w, int al, int ar) {
	unsigned long	lo, hi, r;
	hi  = ((unsigned long)(al&0x0c))<<(w-4);
	hi += (al&3)-2ul;
 
	lo  = ((unsigned long)(ar&0x0c))<<(w-4);
	lo += (ar&3)-2ul;
 
	r = (ubits(hi, w) << w) | (ubits(lo, w));
	return r;
}
 
int	main(int argc, char **argv, char **envp) {
	Verilated::commandArgs(argc, argv);
	BFLY_TB	*bfly = new BFLY_TB;
	int16_t		ir0, ii0, lstr, lsti;
	int32_t		sumr, sumi, difr, difi;
	int32_t		smr, smi, dfr, dfi;
	int		rnd = 0;
 
	const int	TESTSZ = 256;
 
	bfly->opentrace("butterfly.vcd");
 
	bfly->reset();
 
// #define	ZEROTEST
#define	ZEROTEST bfly->test(9,0,0x0000000000l,0x00000000,0x00000000, 0)
	// Test whether or not the aux channel starts clear, like its supposed to
 
	bfly->test(9,0,0x4000000000l,0x000f0000,0x00000000, 1);
	ZEROTEST;
	ZEROTEST;
	bfly->test(9,0,0x4000000000l,0x00000000,0x000f0000, 0);
	ZEROTEST;
	ZEROTEST;
	bfly->test(9,0,0x4000000000l,0x000f0000,0x000f0000, 0);
	ZEROTEST;
	ZEROTEST;
	bfly->test(9,1,0x4000000000l,0x000f0000,0xfff10000, 0);
	ZEROTEST;
	ZEROTEST;
	bfly->test(9,2,0x4000000000l,0x0000000f,0x0000fff1, 0);
	ZEROTEST;
	ZEROTEST;
	bfly->test(9,3,0x4000000000l,0x0000000f,0x0000000f, 0);
	ZEROTEST;
	ZEROTEST;
 
	bfly->test(9,0,0x4000000000l,0x7fff0000,0x7fff0000, 1);
	bfly->test(9,1,0x4000000000l,0x7fff0000,0x80010000, 0);
	bfly->test(9,2,0x4000000000l,0x00007fff,0x00008001, 0);
	bfly->test(9,3,0x4000000000l,0x00007fff,0x00007fff, 0);
 
	bfly->test(8,0,0x4000000000l,0x80010000,0x80010000, 1);
	bfly->test(8,1,0x4000000000l,0x00008001,0x00008001, 0);
 
	bfly->test(9,0,0x4000000000l,0x40000000,0xc0000000, 1);
	bfly->test(9,1,0x4000000000l,0x40000000,0x40000000, 0);
	bfly->test(9,2,0x4000000000l,0x00004000,0x0000c000, 0);
	bfly->test(9,3,0x4000000000l,0x00004000,0x00004000, 0);
 
	bfly->test(9,0,0x4000000000l,0x20000000,0xe0000000, 1);
	bfly->test(9,1,0x4000000000l,0x20000000,0x20000000, 0);
	bfly->test(9,2,0x4000000000l,0x00002000,0x0000e000, 0);
	bfly->test(9,3,0x4000000000l,0x00002000,0x00002000, 0);
 
	bfly->test(9,0,0x4000000000l,0x00080000,0xfff80000, 1);
	bfly->test(9,1,0x4000000000l,0x00080000,0x00080000, 0);
	bfly->test(9,2,0x4000000000l,0x00000008,0x0000fff8, 0);
	bfly->test(9,3,0x4000000000l,0x00000008,0x00000008, 0);
 
	bfly->test(7,0,0x3fffbff9b9l,0xfffe0000,0x00000000, 1);
	bfly->test(7,1,0x3ffd4fed28l,0xfffc0000,0x00020000, 0);
	bfly->test(7,2,0x3ff85fe098l,0xfff80000,0x00060000, 0);
	bfly->test(7,3,0x3ff0efd409l,0xfff00000,0x000e0000, 0);
	bfly->test(7,4,0x3fe70fc77cl,0xffe60000,0x00180000, 0);
	bfly->test(7,5,0x3fdabfbaf1l,0xffda0000,0x00240000, 0);
	bfly->test(7,6,0x3fcbefae69l,0xffca0000,0x00340000, 0);
	bfly->test(7,7,0x3fbaafa1e4l,0xffba0000,0x00440000, 0);
 
	/*
	// Special tests
	bfly->test(9,0,0x4000000000l,0x00010000,0xffff0000, 1);
	bfly->test(9,1,0x4000000000l,0x00010000,0x00010000, 0);
	bfly->test(9,2,0x4000000000l,0x00000001,0x0000ffff, 0);
	bfly->test(9,3,0x4000000000l,0x00000001,0x00000001, 0);
	*/
 
	for(int n=0; n<4; n++) for(int k=0; k<TESTSZ; k++) {
		long	iv, rv;
		unsigned long	lft, rht, cof;
		double	c, s, W;
		bool	inv = 1;
		int	aux;
 
		W = ((inv)?-1:1) * 2.0 * M_PI * (2*k) / TESTSZ * 64;
		c = cos(W); s = sin(W);
		rv = (long)((double)(1l<<(16-2-n))*c+0.5);
		iv = (long)((double)(1l<<(16-2-n))*s+0.5);
 
		rv = (rv << 16) | (iv & (~(-1<<16)));
		lft = rv;
 
		W = ((inv)?-1:1) * 2.0 * M_PI * (2*k+1) / TESTSZ * 64;
		c = cos(W); s = sin(W);
		rv = (long)((double)(1l<<(16-2-n))*c+0.5);
		iv = (long)((double)(1l<<(16-2-n))*s+0.5);
 
		rv = (rv << 16) | (iv & (~(-1<<16)));
		rht = rv;
 
 
		// Switch the sign of W
		W = ((inv)?1:-1) * 2.0 * M_PI * (2*k) / TESTSZ;
		c = cos(W); s = sin(W);
		rv = (long)((double)(1l<<(20-2))*c+0.5); // Keep 20-2 bits for
		iv = (long)((double)(1l<<(20-2))*s+0.5); // coefficients
 
		rv = (rv << 20) | (iv & (~(-1<<20)));
		cof = rv;
 
		aux = ((k&(TESTSZ-1))==0);
 
		bfly->test(n,k, cof, lft, rht, aux);
	}
 
	int	k = TESTSZ;
	// Exhaustively test
#if (4*IWIDTH+2*CWIDTH <= 24)
		for(int a=0; a<(1<<(2*IWIDTH)); a++)
		for(int b=0; b<(1<<(2*IWIDTH)); b++)
		for(int c=0; c<(1<<(2*CWIDTH)); c++)
			bfly->test(0, k++, c, a, b, 0);
 
		printf("Exhaust complete\n");
#else
		for(int al=0; al<16; al++)
		for(int ar=0; ar<16; ar++)
		for(int bl=0; bl<16; bl++)
		for(int br=0; br<16; br++)
		for(int cl=0; cl<16; cl++)
		for(int cr=0; cr<16; cr++) {
			long a = gentestword(IWIDTH, al, ar);
			long b = gentestword(IWIDTH, bl, br);
			long c = gentestword(CWIDTH, cl, cr);
			bfly->test(0, k++, c, a, b, 0);
		}
		printf("Partial exhaust complete\n");
#endif
 
	delete	bfly;
 
	printf("SUCCESS!\n");
	exit(0);
}