flops_testcode.c

Go to the documentation of this file.

/* This includes various workloads that had been scattered all over */
/* the various ctests.  The goal is to have them in one place, and */
/* share them, as well as maybe have only one file that has to be */
/* compiled with reduced optimizations */

#include <stdio.h>
#include <stdlib.h>

#include "testcode.h"

#define ROWS    1000
#define COLUMNS 1000

static float float_matrixa[ROWS][COLUMNS],
        float_matrixb[ROWS][COLUMNS],
        float_mresult[ROWS][COLUMNS];

static double double_matrixa[ROWS][COLUMNS],
        double_matrixb[ROWS][COLUMNS],
        double_mresult[ROWS][COLUMNS];


int flops_float_init_matrix(void) {

    int i,j;

    /* Initialize the Matrix arrays */
    /* Non-optimail row major.  Intentional? */
    for ( i = 0; i < ROWS; i++ ) {
        for ( j = 0; j < COLUMNS; j++) {
            float_mresult[j][i] = 0.0;
            float_matrixa[j][i] = ( float ) rand() * ( float ) 1.1;
            float_matrixb[j][i] = ( float ) rand() * ( float ) 1.1;
        }
    }

#if defined(__powerpc__)
    /* Has fused multiply-add */
    return ROWS*ROWS*ROWS;
#else
    return ROWS*ROWS*ROWS*2;
#endif

}

float flops_float_matrix_matrix_multiply(void) {

    int i,j,k;

    /* Matrix-Matrix multiply */
    for ( i = 0; i < ROWS; i++ ) {
        for ( j = 0; j < COLUMNS; j++ ) {
            for ( k = 0; k < COLUMNS; k++ ) {
                float_mresult[i][j] += float_matrixa[i][k] * float_matrixb[k][j];
            }
        }
    }

    return float_mresult[10][10];
}

float flops_float_swapped_matrix_matrix_multiply(void) {

    int i, j, k;

    /* Matrix-Matrix multiply */
    /* With inner loops swapped */

    for (i = 0; i < ROWS; i++) {
        for (k = 0; k < COLUMNS; k++) {
            for (j = 0; j < COLUMNS; j++) {
                float_mresult[i][j] += float_matrixa[i][k] * float_matrixb[k][j];
            }
        }
    }
    return float_mresult[10][10];
}



int flops_double_init_matrix(void) {

    int i,j;

    /* Initialize the Matrix arrays */
    /* Non-optimail row major.  Intentional? */
    for ( i = 0; i < ROWS; i++ ) {
        for ( j = 0; j < COLUMNS; j++) {
            double_mresult[j][i] = 0.0;
            double_matrixa[j][i] = ( double ) rand() * ( double ) 1.1;
            double_matrixb[j][i] = ( double ) rand() * ( double ) 1.1;
        }
    }

#if defined(__powerpc__)
        /* has fused multiply-add */
        return ROWS*ROWS*ROWS;
#else
    return ROWS*ROWS*ROWS*2;
#endif

}

double flops_double_matrix_matrix_multiply(void) {

    int i,j,k;

    /* Matrix-Matrix multiply */
    for ( i = 0; i < ROWS; i++ ) {
        for ( j = 0; j < COLUMNS; j++ ) {
            for ( k = 0; k < COLUMNS; k++ ) {
                double_mresult[i][j] += double_matrixa[i][k] * double_matrixb[k][j];
            }
        }
    }

    return double_mresult[10][10];
}

double flops_double_swapped_matrix_matrix_multiply(void) {

    int i, j, k;

    /* Matrix-Matrix multiply */
    /* With inner loops swapped */

    for (i = 0; i < ROWS; i++) {
        for (k = 0; k < COLUMNS; k++) {
            for (j = 0; j < COLUMNS; j++) {
                double_mresult[i][j] += double_matrixa[i][k] * double_matrixb[k][j];
            }
        }
    }
    return double_mresult[10][10];
}


/* This was originally called "dummy3" in the various sdsc tests */
/* Does a lot of floating point ops near 1.0 */
/* In theory returns a value roughly equal to the number of flops */
double
do_flops3( double x, int iters, int quiet )
{
    int i;
    double w, y, z, a, b, c, d, e, f, g, h;
    double result;
    double one;
    one = 1.0;
    w = x;
    y = x;
    z = x;
    a = x;
    b = x;
    c = x;
    d = x;
    e = x;
    f = x;
    g = x;
    h = x;
    for ( i = 1; i <= iters; i++ ) {
        w = w * 1.000000000001 + one;
        y = y * 1.000000000002 + one;
        z = z * 1.000000000003 + one;
        a = a * 1.000000000004 + one;
        b = b * 1.000000000005 + one;
        c = c * 0.999999999999 + one;
        d = d * 0.999999999998 + one;
        e = e * 0.999999999997 + one;
        f = f * 0.999999999996 + one;
        g = h * 0.999999999995 + one;
        h = h * 1.000000000006 + one;
    }
    result = 2.0 * ( a + b + c + d + e + f + w + x + y + z + g + h );

    if (!quiet) printf("Result = %lf\n", result);

    return result;
}


volatile double a = 0.5, b = 2.2;

double
do_flops( int n, int quiet )
{
        int i;
        double c = 0.11;

        for ( i = 0; i < n; i++ ) {
                c += a * b;
        }

    if (!quiet) printf("%lf\n",c);

    return c;
}