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;
}