anytestfunctions.cpp

PDE simulator on GPU.

// AnyTestFunctions.cpp: implementation of the TestFunctions class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "shadow.h"
#include "AnyTestFunctions.h"
#include <math.h>
#include "extgl.h"

#include "CommonHW.h"
#include "DenseMatrixOnGPU.h"
#include "VectorOnGPU.h"

#include "FragmentProgram.h"
#include "pbuffer.h"

#include "DenseMatrixMatrixOperation.h"
#include "DenseMatrixVectorMultiply.h"
#include "VectorVectorOperation.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////////
/// Test what I am thinking about the computations on GPU
/// Matrix-Matrix Mulitiply
///////////////////////////////////////////////////////////////////////////////////
#define SIZE1 4
#define SIZE2 4
#define SIZE3 4

void TestMatrixMultiply()
{
	CDenseMatrixOnGPU A,B,result;
	int i,j,k;
	float M1[SIZE1][SIZE2],M2[SIZE2][SIZE3],M[SIZE1][SIZE3];
	for(i=0;i<SIZE1;i++)
	{
		for(j=0;j<SIZE2;j++)
			M1[i][j] = (i*SIZE2+j)*0.01;
	}
	for(i=0;i<SIZE2;i++)
	{
		for(j=0;j<SIZE3;j++)
			M2[i][j] = (i*SIZE3+j)*0.01;
	}

	A.SetData(&M1[0][0],SIZE1,SIZE2);
	B.SetData(&M2[0][0],SIZE2,SIZE3);
	result.SetData(NULL,SIZE1,SIZE3);

	//A.SetData(&M1[0][0],SIZE1,SIZE2);
	//B.SetData(&M2[0][0],SIZE2,SIZE3);
	//result.SetData(NULL,SIZE1,SIZE3);

	int m,n,l;
	FILE *fp = fopen("..\\matrixmul.txt","w");

	m = A.GetHeight();
	n = B.GetWidth();
	l = A.GetWidth();


	fprintf(fp,"Matrix(%d,%d)\n",m,n);
	fprintf(fp,"A on CPU\n");
	for(i=0;i<m;i++)
	{
		for(j=0;j<l;j++)
			fprintf(fp,"%6.5f  ",M1[i][j]);
		fprintf(fp,"\n");
	}

	fprintf(fp,"B on CPU\n");
	for(i=0;i<l;i++)
	{
		for(j=0;j<n;j++)
			fprintf(fp,"%6.5f  ",M2[i][j]);
		fprintf(fp,"\n");
	}
	
	float *ta = A.GetData(m,n); //A.GetData4Channels(m,n);
	fprintf(fp,"A on GPU\n");
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
			fprintf(fp,"%6.5f  ",ta[i*n+j]);
		fprintf(fp,"\n");
	}

	float *tb = B.GetData(m,n); //B.GetData4Channels(m,n);
	fprintf(fp,"B on GPU\n");
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
			fprintf(fp,"%6.5f  ",tb[i*n+j]);
		fprintf(fp,"\n");
	}

	m = A.GetHeight();
	n = B.GetWidth();
	l = A.GetWidth();
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
		{
			M[i][j] = 0;
			for(k=0;k<l;k++)
				M[i][j] += ta[i*l+k]*tb[k*n+j];
		}
	}

	clMatMatWithRC(A, B, result);
	//clMatMatWithBlend(A, B, result);
	//clMatMatFP(A, B, result);
	//clMatMatBlockFP(A, B, result);
	//clMatMat4ChannelFP(A, B, result);

	fprintf(fp,"Result on CPU\n");
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
			fprintf(fp,"%6.5f  ",M[i][j]);
		fprintf(fp,"\n");
	}

	float *tmp = result.GetData(m,n); //result.GetData4Channels(m,n);
	fprintf(fp,"Result on GPU,m=%d,n=%d\n",m,n);
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
			fprintf(fp,"%6.5f  ",tmp[i*n+j]);
		fprintf(fp,"\n");
	}

	fclose(fp);

}

////////////////////////////////////////////////////////////////////////////////////////
/// OUTPUT to DEBUG
/// 1, Vector op Vector
/// 2, Vector reduce
/// 3, Matrix * Vector
////////////////////////////////////////////////////////////////////////////////////////
void TestLinearOnGPU()
{
	CVectorOnGPU x,y,result;
	CDenseMatrixOnGPU A;
	float M1[DIM_TEST],M2[DIM_TEST],M[3];//M[DIM_TEST*DIM_TEST];
	int i,j;
	for(i=0;i<DIM_TEST;i++)
	{
		M1[i] = i*0.02;
		M2[i] = i*0.02;
		for(j=0;j<DIM_TEST;j++)
		{
			M[i*DIM_TEST+j] = i*0.01 + j*0.01;
		}
	}
	
	////////////////////////////////////////////////
	FILE *fp = fopen("..\\whole_data.txt","w");
	fprintf(fp,"Input data x:\n");
	
    for(i=0;i<DIM_TEST;i++)
	{
		fprintf(fp,"%4.3f ",M1[i]);
	}

	fprintf(fp,"\nInput data y:\n");
	for(i=0;i<DIM_TEST;i++)
	{
		fprintf(fp,"%4.3f ",M2[i]);
	}
/*	
	fprintf(fp,"\nInput data Matrix A:\n");
	for(i=0;i<DIM_TEST;i++)
	{
		for(j=0;j<DIM_TEST;j++)
			fprintf(fp,"%4.3f ",M[i*DIM_TEST+j]);
		fprintf(fp,"\n");
	}
*/

	///////////////////////////////////////////////////////
	//// Initialize vectors and matrix
	x.SetData(M1,DIM_TEST);

	y.SetData(M2,DIM_TEST);
	result.SetData(NULL,DIM_TEST);
	A.SetData(M,DIM_TEST);

	////////////////////////////////////////////////////////
	//// Output the data contained in these texture to 
	//// have a verification
	int Dim;
	float *m_result;
	float *m1 = x.GetData(Dim);
	fprintf(fp,"\nAfter Texture Input data x(Dim=%d):\n",Dim);
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m1[i]);
	}

	float *m2 = y.GetData(Dim);
	fprintf(fp,"\nAfter Texture Input data y(Dim=%d):\n",Dim);
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m2[i]);
	}

	float *m = A.GetData(Dim);
	fprintf(fp,"\nAfter Texture Input data Matrix A(Dim=%d):\n",Dim);
	for(i=0;i<Dim;i++)
	{
		for(j=0;j<Dim;j++)
			fprintf(fp,"%4.3f ",m[i*Dim+j]);
		fprintf(fp,"\n");
	}

	

    //////////////////////////////////////////////////////////////////
	///// Check the x+y operation----ADD
	clVecOp(CL_VECT_ADD_VECT_RECT,1.0,1.0, x,y,result);
	/////////////////////////////////////////////////
	//// compuate result = x + y
	m_result = x.GetData(Dim);
	fprintf(fp,"\nxxxxx:\n");
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m_result[i]);
	}
	
	m_result= result.GetData(Dim);
	fprintf(fp,"\n------------------------Add After Computation with CPU:\n");
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m1[i]+m2[i]);
	}

	fprintf(fp,"\nAfter Computation with GPU:\n");
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m_result[i]);
	}

/*
	//////////////////////////////////////////////////////////////////
	///// Check the x-y operation----Sub
	/////////////////////////////////////////////////

	
	CVectorOnGPU result1;
	result1.SetData(NULL, Dim);
	clVecOp(CL_VECT_SUB_VECT_RECT,1.0,0.5, x,y,result1);
	//// compuate result = x - y
	m_result = result1.GetData(Dim);
	fprintf(fp,"\n------------------------SUB After Computation with CPU:\n");
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m1[i]-m2[i]*0.5);
	}

	fprintf(fp,"\nAfter Computation with GPU:\n");
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m_result[i]);
	}
*/

/*
	//////////////////////////////////////////////////////////////////
	///// Check the x*y operation----Mul
	clVecOpFP(CL_VECT_MULT_VECT_RECT,0.5,1.0, x,y,result);
	/////////////////////////////////////////////////
	//// compuate result = x * y
	m_result = result.GetData(Dim);
	fprintf(fp,"\n------------------------MUL After Computation with CPU:\n");
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.0f ",(m1[i]*m2[i])*256*0.5);
	}

	fprintf(fp,"\nAfter Computation with GPU:\n");
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.0f ",m_result[i]*256);
	}
*/

	m_result = x.GetData(Dim);
	fprintf(fp,"\nxxxxx11111-->%d:\n", x.GetTextureID());
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m_result[i]);
	}	

	//////////////////////////////////////////////////////////////////
	///// Check the Matrix * Vector Operation
	float tmp[DIM_TEST];
	DenseMatVecFP( A, x, result);

	/////////////////////////////////////////////////
	//// compuate result = A * x
	m_result = result.GetData(Dim);
	for(i=0;i<Dim;i++)
	{
		tmp[i] = 0;
		for(j=0;j<Dim;j++)
		{
			tmp[i] += M[i*Dim+j] * M1[j];	
		}
	}

	fprintf(fp,"\n\n------------------------Ax After Computation with CPU:\n");
	fprintf(fp,"After Computation with CPU:\n");
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",tmp[i]);
	}

	fprintf(fp,"\nAfter Computation with GPU:\n");
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m_result[i]);
	}

	/////////////////////////////////////
	/// test the inner_product of x and y
	/////////////////////////////////////
	float innCPU = 0;
	fprintf(fp,"\nAfter Computation with GPU:\n");
	for(i=0;i<Dim;i++)
	{	
		innCPU += m_result[i]*m_result[i];
		
	}
	fprintf(fp,"%4.3f ",innCPU);
	
	float inn =	clInnerProductFP(result, result);//clVecReduceFP(CL_MAX, result);//
	fprintf(fp,"\nAfter Computation with GPU:\n");
	fprintf(fp,"%4.3f\n",inn);

	m_result = result.GetData(Dim);
	for(i=0;i<Dim;i++)
	{
		fprintf(fp,"%4.3f ",m_result[i]);
	}	


	
	fclose(fp);

	return;
}

///////////////////////////////////////////////////////////////////////////////////
/// This Function try to learn the complex computations with TEXTURE 
/// Just availabe on OpenGL1.4
///////////////////////////////////////////////////////////////////////////////////
void TestTextureOp()
{