testvectoroperations.cpp

PDE simulator on GPU.

// TestVectorOperations.cpp: implementation of the TestVectorOperations class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "shadow.h"
#include "TestVectorOperations.h"

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

#include "CommonHW.h"
#include "pbuffer.h"
#include "VectorOnGPU.h"
#include "VectorVectorOperation.h"

void TestclVecOp()
{
	CVectorOnGPU x ,y, Vresult;
	float coefficient_x, coefficient_y;
	int i;

	float *Vx = new float[DIM_TEST];
	float *Vy = new float[DIM_TEST];
	/////input data
	for(i=0;i<DIM_TEST;i++)
	{
		Vx[i] = i*1000;
		Vy[i] = i;
	}
	///////////////////////////////////////////////////////
	//// Initialize vectors and matrix

TEST_RESULT_START
	x.SetData(Vx,DIM_TEST);
	y.SetData(Vy,DIM_TEST);
	Vresult.SetData(NULL, DIM_TEST);
TEST_RESULT_END

	int Width = x.GetWidth();
	int Height = x.GetHeight();

	////// Render To Texture with Float PBuffer
	if(	resultBuffer != NULL)
	{
		delete resultBuffer;
		resultBuffer = NULL;
	}

	resultBuffer = new CFloatPBuffer(Width, Height);
	resultBuffer->Initialize();
	resultBuffer->BeginCapture();

	//////////////////////////////////////////////
	///// Clear the framebuffer firstly to avoid the previous computation
	///// This step is important to avoid computation errors
	// The viewing settings.
	glShadeModel( GL_FLAT );
	glDisable ( GL_DEPTH_TEST );
	glDisable(GL_CULL_FACE);
	glClearColor( 0.0, 0.0, 0.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	
	glViewport(0,0,Width,Height);
	glMatrixMode ( GL_PROJECTION );
	glLoadIdentity();
	glOrtho( 0, 1, 0, 1, 0.0, 1.0 );
	glMatrixMode ( GL_MODELVIEW );
	glLoadIdentity();

	//////////////////////////////////////////////////////////////////////////////
	////	vector + vector		......1
	coefficient_x = 1.0;
	coefficient_y = 1.0;
TEST_RESULT_START
	//for(int k=0;k<30;k++)
		clVecOpFP(CL_VECT_SUB_VECT_RECT,  coefficient_x, coefficient_y, x, y, Vresult);
TEST_RESULT_END
	/////////////////////////////////////////////////////////////
	/////// Use float PBuffer to sever the result
	resultBuffer->EndCapture();

	FILE *fp = fopen("testTime.txt","w");
	fprintf(fp,"time = %f\n", time_cost/30);

	int Dim_Vector;

	float *vx = x.GetData(Dim_Vector);

	float *vy = y.GetData(Dim_Vector);

TEST_RESULT_START	
	float *vr = Vresult.GetData(Dim_Vector);
TEST_RESULT_END

	float diff = 0;
	float result ;
	for(i=0;i<Dim_Vector;i++)
	{
		result = coefficient_x*vx[i] - coefficient_y*vy[i];
		fprintf(fp,"result%i from GPU = %f, from CPU = %f\n",i, vr[i], result);
		diff += vr[i] - result;
	}	
	
	fprintf(fp,"GPU - CPU = %f ",diff);
	fclose(fp);
	
	delete[] vx;
	vx = NULL;	
	
	delete[] vy;
	vy = NULL;

	delete[] vr;
	vr = NULL;

	delete[] Vx;
	delete[] Vy;

	return;
}

void TestclVecReduceFP()
{
	CVectorOnGPU x;
	int i;

	float *Vx = new float[DIM_TEST];
	/////input data
	for(i=0;i<DIM_TEST;i++)
	{
		Vx[i] = 0.5;
	}
	///////////////////////////////////////////////////////
	//// Initialize vectors and matrix

	x.SetData(Vx,DIM_TEST);
	
  	int Width = x.GetWidth();
	int Height = x.GetHeight();

	////// Render To Texture with Float PBuffer
	if(	resultBuffer != NULL)
	{
		delete resultBuffer;
		resultBuffer = NULL;
	}

	resultBuffer = new CFloatPBuffer(Width, Height);
	resultBuffer->Initialize();
	resultBuffer->BeginCapture();

	//////////////////////////////////////////////
	///// Clear the framebuffer firstly to avoid the previous computation
	///// This step is important to avoid computation errors
	// The viewing settings.
	glShadeModel( GL_FLAT );
	glDisable ( GL_DEPTH_TEST );
	glDisable(GL_CULL_FACE);
	glClearColor( 0.0, 0.0, 0.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	
	glViewport(0,0,Width,Height);
	glMatrixMode ( GL_PROJECTION );
	glLoadIdentity();
	glOrtho( 0, 1, 0, 1, -1.0, 1.0 );
	glMatrixMode ( GL_MODELVIEW );
	glLoadIdentity();

	float result;
TEST_RESULT_START
	//for(int k=0;k<30;k++)
		result = clVecReduceFP(CL_VECT_NORMAL_RECT, x);
TEST_RESULT_END

	/////////////////////////////////////////////////////////////
	/////// Use float PBuffer to sever the result
	resultBuffer->EndCapture();

	int Dim_Vector;
	FILE *fp = fopen("testTime.txt","w");
	fprintf(fp,"time = %f\n", time_cost/30);

	//but current implementation will change the values stored in X
	float *vx = x.GetData(Dim_Vector);
	float tmp=0;
	for(i=0;i<Dim_Vector;i++)
	{ 
		//if(tmp<vx[i])
		fprintf(fp, "=%f\n", vx[i]);
		tmp += vx[i];
	}
	fprintf(fp, "result on CPU=%f\n", tmp);
	fprintf(fp, "result on GPU=%f\n", result);
		
	fclose(fp);

	delete[] vx;
	vx = NULL;	

	delete[] Vx;

	return;
}

void TestclInnerProductFP()
{
	CVectorOnGPU x ,y;
	int i;

	float *Vx = new float[DIM_TEST];
	float *Vy = new float[DIM_TEST];
	/////input data
	for(i=0;i<DIM_TEST;i++)
	{
		Vx[i] = 1;
		Vy[i] = 1;
	}
	///////////////////////////////////////////////////////
	//// Initialize vectors and matrix

TEST_RESULT_START
	x.SetData(Vx,DIM_TEST);
	y.SetData(Vy,DIM_TEST);
TEST_RESULT_END

	int Width = x.GetWidth();
	int Height = x.GetHeight();

	////// Render To Texture with Float PBuffer
	if(	resultBuffer != NULL)
	{
		delete resultBuffer;
		resultBuffer = NULL;
	}

	resultBuffer = new CFloatPBuffer(Width, Height);
	resultBuffer->Initialize();
	resultBuffer->BeginCapture();

	//////////////////////////////////////////////
	///// Clear the framebuffer firstly to avoid the previous computation
	///// This step is important to avoid computation errors
	// The viewing settings.
	glShadeModel( GL_FLAT );
	glDisable ( GL_DEPTH_TEST );
	glDisable(GL_CULL_FACE);
	glClearColor( 0.0, 0.0, 0.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	
	glViewport(0,0,Width,Height);
	glMatrixMode ( GL_PROJECTION );
	glLoadIdentity();
	glOrtho( 0, Width, 0, Height, -1.0, 1.0 );
	glMatrixMode ( GL_MODELVIEW );
	glLoadIdentity();

	float result = clInnerProductFP(x, y);

	/////////////////////////////////////////////////////////////
	/////// Use float PBuffer to sever the result
	resultBuffer->EndCapture();

	int Dim_Vector;
	FILE *fpTimeFile = fopen ("testTime.txt", "w");
	float *vx = x.GetData(Dim_Vector);
	fprintf(fpTimeFile,"\nAfter Texture Input data x(Dim=%d):\n", Dim_Vector);
	for(i=0;i<Dim_Vector;i++)
	{
		fprintf(fpTimeFile,"%4.3f ",vx[i]);
	}

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

	fprintf(fpTimeFile, "\nresult on CPU=%f", tmp);
	fprintf(fpTimeFile, "\nresult on GPU=%f", result);


	delete[] vx;
	vx = NULL;	
	
	delete[] vy;
	vy = NULL;

	fclose(fpTimeFile);

	delete[] Vx;
	delete[] Vy;

	return;
}