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

Subversion Repositories dblclockfft

[/] [dblclockfft/] [trunk/] [bench/] [cpp/] [butterfly_tb.cpp] - Blame information for rev 15

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

Line No. Rev Author Line
1 6 dgisselq
////////////////////////////////////////////////////////////////////////////
2
//
3
// Filename:    butterfly_tb.cpp
4
//
5
// Project:     A Doubletime Pipelined FFT
6
//
7
// Purpose:     A test-bench for the butterfly.v subfile of the double
8
//              clocked FFT.  This file may be run autonomously.  If so,
9
//              the last line output will either read "SUCCESS" on success,
10
//              or some other failure message otherwise.
11
//
12
//              This file depends upon verilator to both compile, run, and
13
//              therefore test butterfly.v
14
//
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 3 dgisselq
#include <stdio.h>
43
#include <stdint.h>
44
 
45
#include "Vbutterfly.h"
46
#include "verilated.h"
47
 
48 15 dgisselq
long    sbits(const long val, const int bits) {
49
        long    r;
50
 
51
        r = val & ((1l<<bits)-1);
52
        if (r & (1l << (bits-1)))
53
                r |= (-1l << bits);
54
        return r;
55
}
56
 
57
unsigned long   ubits(const long val, const int bits) {
58
        long    r;
59
 
60
        r = val & ((1l<<bits)-1);
61
        return r;
62
}
63
 
64
 
65 5 dgisselq
class   BFLY_TB {
66
public:
67
        Vbutterfly      *m_bfly;
68
        unsigned long   m_left[64], m_right[64];
69 6 dgisselq
        bool            m_aux[64];
70 13 dgisselq
        int             m_addr, m_lastaux, m_offset;
71 6 dgisselq
        bool            m_syncd;
72 3 dgisselq
 
73 5 dgisselq
        BFLY_TB(void) {
74
                m_bfly = new Vbutterfly;
75
                m_addr = 0;
76 6 dgisselq
                m_syncd = 0;
77 5 dgisselq
        }
78 3 dgisselq
 
79 5 dgisselq
        void    tick(void) {
80
                m_lastaux = m_bfly->o_aux;
81
                m_bfly->i_clk = 0;
82
                m_bfly->eval();
83
                m_bfly->i_clk = 1;
84
                m_bfly->eval();
85 6 dgisselq
 
86 13 dgisselq
                if ((!m_syncd)&&(m_bfly->o_aux))
87
                        m_offset = m_addr;
88 6 dgisselq
                m_syncd = (m_syncd) || (m_bfly->o_aux);
89 5 dgisselq
        }
90
 
91
        void    reset(void) {
92
                m_bfly->i_ce    = 0;
93 6 dgisselq
                m_bfly->i_rst   = 1;
94 5 dgisselq
                m_bfly->i_coef  = 0l;
95
                m_bfly->i_left  = 0;
96
                m_bfly->i_right = 0;
97
                tick();
98 6 dgisselq
                m_bfly->i_rst = 0;
99 5 dgisselq
                m_bfly->i_ce  = 1;
100 6 dgisselq
                //
101
                // Let's run a RESET test here, forcing the whole butterfly
102
                // to be filled with aux=1.  If the reset works right,
103
                // we'll never get an aux=1 output.
104
                //
105
                m_bfly->i_rst = 1;
106
                m_bfly->i_ce  = 1;
107 5 dgisselq
                m_bfly->i_aux = 1;
108 6 dgisselq
                for(int i=0; i<200; i++)
109
                        tick();
110 5 dgisselq
 
111 6 dgisselq
                // Now here's the RESET line, so let's see what the test does
112
                m_bfly->i_rst = 1;
113
                m_bfly->i_ce  = 1;
114
                m_bfly->i_aux = 1;
115 5 dgisselq
                tick();
116 6 dgisselq
                m_bfly->i_rst = 0;
117
                m_syncd = 0;
118 5 dgisselq
        }
119
 
120
        void    test(const int n, const int k, const unsigned long cof,
121
                        const unsigned lft, const unsigned rht, const int aux) {
122
 
123
                m_bfly->i_coef  = cof & (~(-1l << 40));
124
                m_bfly->i_left  = lft;
125
                m_bfly->i_right = rht;
126
                m_bfly->i_aux   = aux & 1;
127
 
128
                tick();
129
 
130
                if ((m_bfly->o_aux)&&(!m_lastaux))
131
                        printf("\n");
132
                printf("n,k=%d,%3d: COEF=%010lx, LFT=%08x, RHT=%08x, A=%d, OLFT =%09lx, ORHT=%09lx, AUX=%d\n",
133
                        n,k,
134
                        m_bfly->i_coef & (~(-1l<<40)),
135
                        m_bfly->i_left,
136
                        m_bfly->i_right,
137
                        m_bfly->i_aux,
138
                        m_bfly->o_left,
139
                        m_bfly->o_right,
140
                        m_bfly->o_aux);
141
                /*
142
                printf("\tFI=%010lx",
143
                        ((((long)m_bfly->v__DOT__r_aux_2)&1l)<<34)
144
                        |((((long)m_bfly->v__DOT__r_sum_r)&0x01ffffl)<<17)
145
                        |(((long)m_bfly->v__DOT__r_sum_i)&0x01ffffl));
146
                printf("\tFO=%010lx SUMR=%05x SUMI=%05x A=%d",
147
                        m_bfly->v__DOT__fifo_read,
148
                        m_bfly->v__DOT__r_sum_r,
149
                        m_bfly->v__DOT__r_sum_i,
150
                        m_bfly->v__DOT__r_aux_2);
151
                printf("\tML=%09lx, MR=%09lx, ",
152
                        m_left[ (m_addr-23)&(64-1)],
153
                        m_right[(m_addr-23)&(64-1)]);
154
                */
155
                /*
156
                printf("\tBLFTR=%10lx BLFTI=%10lx",
157
                        m_bfly->v__DOT__b_left_r & (~(-1l<<40)),
158
                        m_bfly->v__DOT__b_left_i & (~(-1l<<40)));
159
                printf("\tMPYR=%10lx MPYI=%10lx",
160
                        m_bfly->v__DOT__mpy_r & (~(-1l<<40)),
161
                        m_bfly->v__DOT__mpy_i & (~(-1l<<40)));
162
                printf("\n");
163
                */
164
 
165 13 dgisselq
                if ((m_syncd)&&(m_left[(m_addr-m_offset)&(64-1)] != m_bfly->o_left)) {
166 15 dgisselq
                        fprintf(stderr, "WRONG O_LEFT! (%lx(exp) != %lx(sut)\n",
167
                                m_left[(m_addr-m_offset)&(64-1)],
168
                                m_bfly->o_left);
169 5 dgisselq
                        exit(-1);
170
                }
171
 
172 13 dgisselq
                if ((m_syncd)&&(m_right[(m_addr-m_offset)&(64-1)] != m_bfly->o_right)) {
173 5 dgisselq
                        fprintf(stderr, "WRONG O_RIGHT!\n");
174
                        exit(-1);
175
                }
176
 
177 13 dgisselq
                if ((m_syncd)&&(m_aux[(m_addr-m_offset)&(64-1)] != m_bfly->o_aux)) {
178 6 dgisselq
                        fprintf(stderr, "FAILED AUX CHANNEL TEST (i.e. the SYNC)\n");
179
                        exit(-1);
180
                }
181
 
182
                if ((m_addr > 22)&&(!m_syncd)) {
183
                        fprintf(stderr, "NO SYNC PULSE!\n");
184
                        exit(-1);
185
                }
186
 
187 5 dgisselq
                // Now, let's calculate an "expected" result ...
188
                long    rlft, ilft;
189
 
190
                // Extract left and right values ...
191 15 dgisselq
                rlft = sbits(m_bfly->i_left >> 16, 16);
192
                ilft = sbits(m_bfly->i_left      , 16);
193 5 dgisselq
 
194
                // Now repeat for the right hand value ...
195
                long    rrht, irht;
196
                // Extract left and right values ...
197 15 dgisselq
                rrht = sbits(m_bfly->i_right >> 16, 16);
198
                irht = sbits(m_bfly->i_right      , 16);
199 5 dgisselq
 
200
                // and again for the coefficients
201
                long    rcof, icof;
202
                // Extract left and right values ...
203 15 dgisselq
                rcof = sbits(m_bfly->i_coef >> 20, 20);
204
                icof = sbits(m_bfly->i_coef      , 20);
205 5 dgisselq
 
206
                // Now, let's do the butterfly ourselves ...
207
                long sumi, sumr, difi, difr;
208
                sumr = rlft + rrht;
209
                sumi = ilft + irht;
210
                difr = rlft - rrht;
211
                difi = ilft - irht;
212
 
213
        /*
214
                printf("L=%5lx+%5lx,R=%5lx+%5lx,S=%5lx+%5lx,D=%5lx+%5lx, ",
215
                        rlft & 0x02ffffl,
216
                        ilft & 0x02ffffl,
217
                        rrht & 0x02ffffl,
218
                        irht & 0x02ffffl,
219
                        sumr & 0x02ffffl,
220
                        sumi & 0x02ffffl,
221
                        difr & 0x02ffffl,
222
                        difi & 0x02ffffl);
223
        */
224
                long p1, p2, p3, mpyr, mpyi;
225
                p1 = difr * rcof;
226
                p2 = difi * icof;
227
                p3 = (difr + difi) * (rcof + icof);
228
 
229 15 dgisselq
                mpyr = p1-p2 + (1<<17);
230
                mpyi = p3-p1-p2 + (1<<17);
231 5 dgisselq
 
232
        /*
233
                printf("RC=%lx, IC=%lx, ", rcof, icof);
234
                printf("P1=%lx,P2=%lx,P3=%lx, ", p1,p2,p3);
235
                printf("MPYr = %lx, ", mpyr);
236
                printf("MPYi = %lx, ", mpyi);
237
        */
238
 
239
                long    o_left_r, o_left_i, o_right_r, o_right_i;
240
                unsigned long   o_left, o_right;
241
 
242
                o_left_r = sumr & 0x01ffff; o_left_i = sumi & 0x01ffff;
243
                o_left = (o_left_r << 17) | (o_left_i);
244
 
245
                o_right_r = (mpyr>>18) & 0x01ffff;
246
                o_right_i = (mpyi>>18) & 0x01ffff;
247
                o_right = (o_right_r << 17) | (o_right_i);
248
        /*
249
                printf("oR_r = %lx, ", o_right_r);
250
                printf("oR_i = %lx\n", o_right_i);
251
        */
252
 
253
                m_left[ m_addr&(64-1)] = o_left;
254
                m_right[m_addr&(64-1)] = o_right;
255 6 dgisselq
                m_aux[  m_addr&(64-1)] = aux;
256 5 dgisselq
 
257
                m_addr++;
258
        }
259
};
260
 
261 3 dgisselq
int     main(int argc, char **argv, char **envp) {
262
        Verilated::commandArgs(argc, argv);
263 5 dgisselq
        BFLY_TB *bfly = new BFLY_TB;
264 3 dgisselq
        int16_t         ir0, ii0, lstr, lsti;
265
        int32_t         sumr, sumi, difr, difi;
266
        int32_t         smr, smi, dfr, dfi;
267
        int             rnd = 0;
268
 
269 5 dgisselq
        const int       TESTSZ = 256;
270 3 dgisselq
 
271 5 dgisselq
        bfly->reset();
272 3 dgisselq
 
273 5 dgisselq
        bfly->test(9,0,0x4000000000l,0x7fff0000,0x7fff0000, 1);
274
        bfly->test(9,1,0x4000000000l,0x7fff0000,0x80010000, 0);
275
        bfly->test(9,2,0x4000000000l,0x00007fff,0x00008001, 0);
276
        bfly->test(9,3,0x4000000000l,0x00007fff,0x00007fff, 0);
277 3 dgisselq
 
278 5 dgisselq
        bfly->test(8,0,0x4000000000l,0x80010000,0x80010000, 1);
279
        bfly->test(8,1,0x4000000000l,0x00008001,0x00008001, 0);
280 3 dgisselq
 
281 5 dgisselq
        bfly->test(9,0,0x4000000000l,0x40000000,0xc0000000, 1);
282
        bfly->test(9,1,0x4000000000l,0x40000000,0x40000000, 0);
283
        bfly->test(9,2,0x4000000000l,0x00004000,0x0000c000, 0);
284
        bfly->test(9,3,0x4000000000l,0x00004000,0x00004000, 0);
285 3 dgisselq
 
286 5 dgisselq
        bfly->test(9,0,0x4000000000l,0x20000000,0xe0000000, 1);
287
        bfly->test(9,1,0x4000000000l,0x20000000,0x20000000, 0);
288
        bfly->test(9,2,0x4000000000l,0x00002000,0x0000e000, 0);
289
        bfly->test(9,3,0x4000000000l,0x00002000,0x00002000, 0);
290 3 dgisselq
 
291 5 dgisselq
        bfly->test(9,0,0x4000000000l,0x00080000,0xfff80000, 1);
292
        bfly->test(9,1,0x4000000000l,0x00080000,0x00080000, 0);
293
        bfly->test(9,2,0x4000000000l,0x00000008,0x0000fff8, 0);
294
        bfly->test(9,3,0x4000000000l,0x00000008,0x00000008, 0);
295 3 dgisselq
 
296 8 dgisselq
        bfly->test(7,0,0x3fffbff9b9l,0xfffe0000,0x00000000, 1);
297
        bfly->test(7,1,0x3ffd4fed28l,0xfffc0000,0x00020000, 0);
298
        bfly->test(7,2,0x3ff85fe098l,0xfff80000,0x00060000, 0);
299
        bfly->test(7,3,0x3ff0efd409l,0xfff00000,0x000e0000, 0);
300
        bfly->test(7,4,0x3fe70fc77cl,0xffe60000,0x00180000, 0);
301
        bfly->test(7,5,0x3fdabfbaf1l,0xffda0000,0x00240000, 0);
302
        bfly->test(7,6,0x3fcbefae69l,0xffca0000,0x00340000, 0);
303
        bfly->test(7,7,0x3fbaafa1e4l,0xffba0000,0x00440000, 0);
304
 
305
        /*
306
        // Special tests
307 5 dgisselq
        bfly->test(9,0,0x4000000000l,0x00010000,0xffff0000, 1);
308
        bfly->test(9,1,0x4000000000l,0x00010000,0x00010000, 0);
309
        bfly->test(9,2,0x4000000000l,0x00000001,0x0000ffff, 0);
310
        bfly->test(9,3,0x4000000000l,0x00000001,0x00000001, 0);
311 8 dgisselq
        */
312 3 dgisselq
 
313 5 dgisselq
        for(int n=0; n<4; n++) for(int k=0; k<TESTSZ; k++) {
314
                long    iv, rv;
315
                unsigned long   lft, rht, cof;
316
                double  c, s, W;
317
                bool    inv = 1;
318
                int     aux;
319 3 dgisselq
 
320 5 dgisselq
                W = ((inv)?-1:1) * 2.0 * M_PI * (2*k) / TESTSZ * 64;
321
                c = cos(W); s = sin(W);
322
                rv = (long)((double)(1l<<(16-2-n))*c+0.5);
323
                iv = (long)((double)(1l<<(16-2-n))*s+0.5);
324 3 dgisselq
 
325 5 dgisselq
                rv = (rv << 16) | (iv & (~(-1<<16)));
326
                lft = rv;
327 3 dgisselq
 
328 5 dgisselq
                W = ((inv)?-1:1) * 2.0 * M_PI * (2*k+1) / TESTSZ * 64;
329
                c = cos(W); s = sin(W);
330
                rv = (long)((double)(1l<<(16-2-n))*c+0.5);
331
                iv = (long)((double)(1l<<(16-2-n))*s+0.5);
332
 
333
                rv = (rv << 16) | (iv & (~(-1<<16)));
334
                rht = rv;
335
 
336
 
337
                // Switch the sign of W
338
                W = ((inv)?1:-1) * 2.0 * M_PI * (2*k) / TESTSZ;
339
                c = cos(W); s = sin(W);
340
                rv = (long)((double)(1l<<(20-2))*c+0.5); // Keep 20-2 bits for
341
                iv = (long)((double)(1l<<(20-2))*s+0.5); // coefficients
342
 
343
                rv = (rv << 20) | (iv & (~(-1<<20)));
344
                cof = rv;
345
 
346
                aux = ((k&(TESTSZ-1))==0);
347
 
348
                bfly->test(n,k, cof, lft, rht, aux);
349 3 dgisselq
        }
350
 
351
        delete  bfly;
352
 
353 4 dgisselq
        printf("SUCCESS!\n");
354 3 dgisselq
        exit(0);
355
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.