Subversion Repositories systemc_cordic

// testbench.cpp: source file

/********************************************************************

//

// Module:

//   Testbench feeding instructions into Cordic core

//

// Implementation:

//   This module tests the Rotate, Magnitude-Phase, Sin-Cos and

//   Sinh-Cosh CORDIC engines.

//

//

// Authors:     Winnie Cheng,

//              Peter Wu

//

 *********************************************************************/

#include "testbench.h"

#include "opcode.h"

#include "convert.h"

#include 

#define ROTATE_NUM_TEST         5

#define MAGPHASE_NUM_TEST       5

#define SINCOS_NUM_TEST         5

#define SINHCOSH_NUM_TEST       500

#ifdef MODULE_NAME

#undef MODULE_NAME

#endif

#define MODULE_NAME     "[testbench]"

void testbench::testbench_process()

{

    short i;

    double x, y, a;

    double rad, correct_x, correct_y;

    double computed_v1, computed_v2;

    bool success;

    // Initialize output

    done.write(false);

    instructions_valid.write(false);

    wait();

    wait_until(start.delayed()==true);

    printf("%s Testbench for CORDIC engines\n", MODULE_NAME);

    success = true;

    // Test Rotate Engine

    for(i = 0; i < ROTATE_NUM_TEST; i++) {

        wait();

        // Generate random input

        a = 1.0*((rand()>>2)%360)-180.0;

        x = 1.0*((rand()>>2)%100);

        y = 1.0*((rand()>>2)%100);

        cout << MODULE_NAME << "Rotate(" << x << ", " << y << ", " << a << ")" << endl;

        // activate the rotate engine

        engine_select.write(I_ROTATE);

        operand1.write(toint(x));       // orgX

        operand2.write(toint(y));       // orgY

        operand3.write(toint(a));       // angle

        instructions_valid.write(true);

        wait();

        // pulse instructions valid

        instructions_valid.write(false);

        wait_until(compute_done.delayed()==true);

        // Read Computed Results

        computed_v1 = tofp(result1.read());

        computed_v2 = tofp(result2.read());

        // Check Result

        rad=(3.1415926*a)/180.0;

        correct_x=x*cos(rad)-y*sin(rad); /* Perform "perfect" rotation by  */

        correct_y=y*cos(rad)+x*sin(rad); /* using f.p. and transcendentals */

        if ((fabs(computed_v1-correct_x)>0.15) ||

            (fabs(computed_v2-correct_y)>0.15)) {

            cout << MODULE_NAME << "ERROR computed=" << computed_v1 << ",";

            cout << computed_v2 << " expected=" << correct_x << ",";

            cout << correct_y << endl;

            success = false;

        } else {

            cout << MODULE_NAME << "CORRECT" << endl;

        }

        wait();

    } // end Test Rotate Engine

    // Test MagPhase Engine

    for(i = 0; i < MAGPHASE_NUM_TEST; i++) {

        wait();

        x = 2.0*((rand()>>2)%100) - 100;

        y = 2.0*((rand()>>2)%100) - 100;

        cout << MODULE_NAME << "Mag and Phase(" << x << ", " << y << ") " << endl;

        // activate the rotate engine

        engine_select.write(I_MAGPHASE);

        operand1.write(toint(x));       // orgX

        operand2.write(toint(y));       // orgY

        instructions_valid.write(true);

        wait();

        // pulse instructions valid

        instructions_valid.write(false);

        wait_until(compute_done.delayed()==true);

        // Read Computed Results

        computed_v1 = tofp(result1.read());

        computed_v2 = tofp(result2.read());

        // Check Result

        correct_x=sqrt(x*x+y*y); /* Perform "perfect" magnitude */

        correct_y=atan(y/x)*180/3.1415926;

        if (x<0 && y>0)

           correct_y = 180 + correct_y;

        if (x<0 && y<=0)

           correct_y = -180 + correct_y;

        if ((fabs(computed_v1-correct_x)>0.15) ||

            (fabs(computed_v2-correct_y)>0.15)) {

            cout << MODULE_NAME << "ERROR computed=" << computed_v1 << ",";

            cout << computed_v2 << " expected=" << correct_x << ",";

            cout << correct_y << endl;

            success = false;

        } else {

            cout << MODULE_NAME << "CORRECT" << endl;

        }

        wait();

    } // end Test Magnitude and Phase Engine

    // Test Sine Cosine Engine

    for(i = 0; i < SINCOS_NUM_TEST; i++) {

        wait();

        a = 1.0*((rand()>>2)%360)-180.0;

        cout << MODULE_NAME << "Sine and Cosine(" << a << ") " << endl;

        // activate the rotate engine

        engine_select.write(I_SINCOS);

        operand1.write(toint(a));       // orgX

        instructions_valid.write(true);

        wait();

        // pulse instructions valid

        instructions_valid.write(false);

        wait_until(compute_done.delayed()==true);

        // Read Computed Results

        computed_v1 = tofp(result1.read());

        computed_v2 = tofp(result2.read());

        // Check Result

        rad=(3.1415926*a)/180.0;

        correct_x=sin(rad); /* Perform "perfect" Cosine */

        correct_y=cos(rad);

        if ((fabs(computed_v1-correct_x)>0.06) ||

            (fabs(computed_v2-correct_y)>0.06)) {

            cout << MODULE_NAME << "ERROR computed=" << computed_v1 << ",";

            cout << computed_v2 << " expected=" << correct_x << ",";

            cout << correct_y << endl;

            success = false;

        } else {

            cout << MODULE_NAME << "CORRECT" << endl;

        }

        wait();

    } // end Test Sine and Cosine Engine

    // Test Sinh Cosh Engine

    for(i = 0; i < SINHCOSH_NUM_TEST; i++) {

        wait();

        a = 1.0*((rand()>>2)%90)-45.0;

        if(a < 0 && a > -3) a = -3;       // adjust for algorithm inaccuracies

        cout << MODULE_NAME << "Sinh and Cosh(" << a << ") " << endl;

        // activate the rotate engine

        engine_select.write(I_SINHCOSH);

        operand1.write(toint(a));       // orgX

        instructions_valid.write(true);

        wait();

        // pulse instructions valid

        instructions_valid.write(false);

        wait_until(compute_done.delayed()==true);

        // Read Computed Results

        computed_v1 = tofp(result1.read());

        computed_v2 = tofp(result2.read());

        // Check Result

        rad=(3.1415926*a)/180.0;

        correct_x=sinh(rad); /* Perform "perfect" Cosine */

        correct_y=cosh(rad);

        if ((fabs(computed_v1-correct_x)>0.06) ||

            (fabs(computed_v2-correct_y)>0.06)) {

            cout << MODULE_NAME << "ERROR computed=" << computed_v1 << ",";

            cout << computed_v2 << " expected=" << correct_x << ",";

            cout << correct_y << endl;

            success = false;

        } else {

            cout << MODULE_NAME << "CORRECT" << endl;

        }

        wait();

    } // end Test Sinh and Cosh Engine

    cout << MODULE_NAME << "Testbench completed - ";

    if(success) {

        cout << "SUCCESS" << endl;

    } else {

        cout << "FAILED" << endl;

    }

    done.write(true);

    // end of test vectors

}