/* 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;

}