dsp_fft32x32_d.c

TI c64x的FFT程序

    -0x7ABD448A, -0x62F2C894,  0x67495631, -0x6BEDD750,
    -0x4CE79237,  0x076DB606,  0x3C079D7B,  0x499B228A,
    -0x3FD4B6FB, -0x6E11D15A, -0x1A82C764, -0x6A018989,
    -0x1706096D,  0x0CCF94CA, -0x38BD1DF9,  0x6575AB1D,
    -0x4B3ED5DE,  0x513B2958,  0x1A6A20C4, -0x2A661DD3,
    -0x757B5C59,  0x037EC54E,  0x4C299049, -0x62412E0F,
     0x7C656C31,  0x34A9174E, -0x1FEE3BA0, -0x6EF11FFB,
    -0x1F150F03,  0x6D424CA4,  0x5873308E, -0x2E1A0146,
     0x269F5C54, -0x5E8A54D7, -0x5B9D6674,  0x1FF69FA3,
     0x7D96C8BA, -0x7EC06A70, -0x72275EC0, -0x2F5B993E,
    -0x4EB14925, -0x4AE0855B, -0x4A882F36, -0x13D90412,
    -0x258AAA37,  0x7CCB33E7, -0x728C48F1, -0x10176C2D,
     0x4A131800,  0x2D5C5119, -0x29EC66AE, -0x515260DD,
     0x3B8913B3,  0x2487D52F,  0x2C5F1F57, -0x1D0AD393,
    -0x30FD511E, -0x74B22ECF,  0x0A63A291, -0x24DF8FE1,
    -0x374AE149, -0x6E4C7E82, -0x1F668432, -0x2E2DFFCF,
    -0x716ED44B,  0x7EF645F8, -0x5A082006,  0x631D38F5,
    -0x0D3537DE,  0x33C50F9E,  0x6F17CC63, -0x4D18B16A,
     0x3FC3F445, -0x750A41F2, -0x67FA7DF7, -0x58EB7045,

     0x0BD967E7,  0x1B3EE06B, -0x22D3F58F, -0x2212B02A,
     0x4B9794A4, -0x138A95CF,  0x07E6448D, -0x52B3FD65,
     0x30BE697A,  0x7FC4D572, -0x63D9F4E2, -0x19F6FEE0,
     0x46BA6D2A, -0x3796D008,  0x11D2E02F, -0x62D880DB
},

};

int x_cn[NUM_INPUTS][2*N + 2*PAD];
int x_i[NUM_INPUTS][2*N + 2*PAD];
int x_sa[NUM_INPUTS][2*N + 2*PAD];

int y_cn[NUM_INPUTS][2*N + 2*PAD];
int y_i[NUM_INPUTS][2*N + 2*PAD];
int y_sa[NUM_INPUTS][2*N + 2*PAD];

int w[NUM_INPUTS][2*N + 2*PAD];

/* ======================================================================== */
/*  Prototypes for timing functions.                                        */
/* ======================================================================== */
clock_t time_cn(int cur_input, int n);
clock_t time_i(int cur_input, int n);
clock_t time_sa(int cur_input, int n);

/* ======================================================================== */
/*  MAIN -- Top level driver for the test.                                  */
/* ======================================================================== */
int main()
{
    clock_t t_overhead, t_start, t_stop;
    clock_t t_cn, t_i, t_sa;
    int i, j, k, m, n, radix, fail;

    /* -------------------------------------------------------------------- */
    /*  Compute the overhead of calling clock() twice to get timing info.   */
    /* -------------------------------------------------------------------- */
    t_start = clock();
    t_stop = clock();
    t_overhead = t_stop - t_start;

    for (j = 16, k = 1, fail = 0; j <= N; k++, j *= 2) {
        t_cn = 0;
        t_i = 0;
        t_sa = 0;
        
        for (n = 31, m = 1; (j & (1 << n)) == 0; n--, m++)
            ;
        radix = m & 1 ? 2 : 4;

        /* -------------------------------------------------------------------- */
        /* Generate twiddle factors                                             */
        /* -------------------------------------------------------------------- */
        gen_twiddle_fft32x32(&w[0][PAD], j, 2147483647.5);

        /* -------------------------------------------------------------------- */
        /*  Copy vector to all inputs.                                          */
        /* -------------------------------------------------------------------- */
        memcpy(x_cn, x, sizeof(x_cn));
        memcpy(x_i, x, sizeof(x_i));
        memcpy(x_sa, x, sizeof(x_sa));

        /* -------------------------------------------------------------------- */
        /*  Force uninitialized arrays to fixed values.                         */
        /* -------------------------------------------------------------------- */
        memset(y_cn, 0xA5, sizeof(y_cn));
        memset(y_i, 0xA5, sizeof(y_i));
        memset(y_sa, 0xA5, sizeof(y_sa));

        printf("DSP_fft32x32\tIter#: %d\t", k);

        /* -------------------------------------------------------------------- */
        /*  Check the results arrays, and report any failures.                  */
        /* -------------------------------------------------------------------- */
        for(i = 0; i < NUM_INPUTS; i++) {
            t_cn += time_cn(i, j) - t_overhead;
            t_i += time_i(i, j) - t_overhead;
            t_sa += time_sa(i, j) - t_overhead;
        }

        printf("DSP_fft32x32\tIter#: %d\t", k);

        if (memcmp(y_cn, y_i, sizeof(y_cn))) {
            fail++;
            printf("Result Failure (y_i) ");
        }
        else
            printf("Result Successful (y_i) ");

        if (memcmp(y_cn, y_sa, sizeof(y_cn))) {
            fail++;
            printf("Result Failure (y_sa) ");
        }
        else
            printf("Result Successful (y_sa) ");


        printf("\tRadix = %d\tN = %d\tnatC: %d\tintC: %d\tSA: %d\n", radix, j, t_cn, t_i, t_sa);
    }

    return (fail);
}

/* ======================================================================== */
/*  TIME_CN  -- Measure elapsed time for natural C version.                 */
/* ======================================================================== */
clock_t time_cn(int cur_input, int n)
{
    clock_t t_start, t_stop;

    t_start = clock();
    DSP_fft32x32_cn(&w[cur_input][PAD], n, &x_cn[cur_input][PAD], &y_cn[cur_input][PAD]);
    t_stop  = clock();
    return  t_stop - t_start;
}

/* ======================================================================== */
/*  TIME_I   -- Measure elapsed time for intrinsic C version.               */
/* ======================================================================== */
clock_t time_i(int cur_input, int n)
{
    clock_t t_start, t_stop;

    t_start = clock();
    DSP_fft32x32_i(&w[cur_input][PAD], n, &x_i[cur_input][PAD], &y_i[cur_input][PAD]);
    t_stop  = clock();
    return  t_stop - t_start;
}

/* ======================================================================== */
/*  TIME_SA   -- Measure elapsed time for intrinsic C version.              */
/* ======================================================================== */
clock_t time_sa(int cur_input, int n)
{
    clock_t t_start, t_stop;

    t_start = clock();
    DSP_fft32x32(&w[cur_input][PAD], n, &x_sa[cur_input][PAD], &y_sa[cur_input][PAD]);
    t_stop  = clock();
    return  t_stop - t_start;
}

/* ======================================================================== */
/*  End of file:  DSP_fft32x32_d.c                                          */
/* ------------------------------------------------------------------------ */
/*          Copyright (C) 2007 Texas Instruments, Incorporated.             */
/*                          All Rights Reserved.                            */
/* ======================================================================== */