#if 1
#include <iostream>
#include <conio.h>
// Libra
#include <Libra.h>    // C and C++ API

const int iterationCount = 15;

const int N = 1500;
int backend1OpsCounter = 0;
int backend2OpsCounter = 0;

struct UserData
{
	gVar* C;
	double stopTime;
};

void getDataCompletedCallbackBackend1(float* memory, void* userData)
{
	const UserData& data = *(UserData*)userData;

	// Verify downloaded data
	const int index = int((::rand()/float(RAND_MAX-1))*N*N);
	if (memory[index] != float(N))
		printf("Backend1 : Error value %f at index %d\n", memory[index], index);

	backend1OpsCounter++;
}

void getDataCompletedCallbackBackend2(float* memory, void* userData)
{
	const UserData& data = *(UserData*)userData;

	// Verify downloaded data
	const int index = int((::rand()/float(RAND_MAX-1))*N*N);
	if (memory[index] != float(N))
		printf("Backend2 : Error value %f at index %d\n", memory[index], index);

	backend2OpsCounter++;
}

double computeBackendRatio(gBackend backend1, gBackend backend2, gVar& A1, gVar& B1, gVar& C1, gVar& A2, gVar& B2, gVar& C2, float* buffer1, float* buffer2, UserData& userData)
{
	libra_SetCurrentBackend(backend1);
	/* Create two N by N matrices on the GPU (default compute backend). */
	A1 = ones(N);
	B1 = A1;
	/* warm up phase of the backend1! (to get accurate timing results) */
	C1 = A1 * B1; C1 = A1 * B1;
	C1 = A1 * B1; C1 = A1 * B1;
	/* Now, create two N by N matrices on backend2 (use libra_SetCurrentBackend()). */
	libra_SetCurrentBackend(backend2);
	A2 = ones(N);
	B2 = A2;
	/* warm up phase of the cpu! (to get accurate timing results) */
	C2 = A2 * B2; C2 = A2 * B2;
	C2 = A2 * B2; C2 = A2 * B2;

	// Compute backend ratio.
	libra_SetCurrentBackend(backend2);
	double startTime = libra_GetTime();
	for (int i=0;i<iterationCount;++i)
	{
		C2 = A2 * B2;
		C2.getData(buffer2, 0, 0, getDataCompletedCallbackBackend2, &userData);
	}
	double stopTime = libra_GetTime()-startTime;
	libra_SetCurrentBackend(backend1);
	startTime = libra_GetTime();
	for (int i=0;i<iterationCount;++i)
	{
		C1 = A1 * B1;
		C1.getData(buffer1, 0, 0, getDataCompletedCallbackBackend1, &userData);
	}
	double stopTime2 = libra_GetTime()-startTime;

	return stopTime2/stopTime;
}

int main(int argc, char** argv)
{
	long long flopCount;
	double gflops;
	gVar A1, B1, C1;
	gVar A2, B2, C2;
	UserData userData;

	printf("*************************************************************\n\n");
	printf("SGEMM : matrix multiplication using multiple compute backends.\n\n");
	printf("*************************************************************\n\n");

	if (libra_Init(argc, argv) != 0)
		return 1;

	// Pick default accelerator backend (GPU).
	gBackend backend1 = libra_GetCurrentBackend();

	// Create data buffers optimized for accelerator backend1
	float* dataBuffer1 = (float*)libra_new(sizeof(float)*N*N);
	float* dataBuffer2 = (float*)libra_new(sizeof(float)*N*N);

	// Choose the CPU as the second compute backend.
	gBackend backend2 = CPU_BACKEND;
	libra_SetDefaultDataType(GFLOAT32);

	//
	double ratio = 0.25f*computeBackendRatio(backend1, backend2, A1, B1, C1, A2, B2, C2, dataBuffer1, dataBuffer2, userData);

	// Synchoronize all getData() transfers/callbacks to complete
	libra_Finish();

	/* Reset data transfer counters and perform matrix multiplications using 2 available compute backends */
	backend1OpsCounter = 0;
	backend2OpsCounter = 0;
	
	double startTime = libra_GetTime();

	// Select backend
	libra_SetCurrentBackend(backend1);
	// Enqueue operations on first backend.
	for (int i=0;i<iterationCount;i++)
	{
		// Compute
		C1 = A1 * B1;
		// Get result
		C1.getData(dataBuffer1, 0, 0, getDataCompletedCallbackBackend1, &userData);
	}
	// Select backend
	libra_SetCurrentBackend(backend2);
	// Enqueue operations on second backend.
	for (int i=0;i<ratio*iterationCount;i++)
	{
		// Compute
		C2 = A2 * B2;
		// Get result
		C2.getData(dataBuffer2, 0, 0, getDataCompletedCallbackBackend2, &userData);
	}
	//
	double time = (libra_GetTime()-startTime);
	printf("Total time : %g%s", time*1000, " milliseconds\n");

	/* Compute a performance measurement. Gigaflop / s. */
	flopCount = ((2*N-1)*N*(long long)N)*(backend1OpsCounter+backend2OpsCounter);
	gflops = flopCount / time / 1e9;
	printf("%g%s", gflops, " GFlop/s.\n");

	// Destroy data buffers using same backend as when created.
	libra_SetCurrentBackend(backend1);
	libra_delete(dataBuffer1);
	libra_delete(dataBuffer2);

	libra_Shutdown();

	printf("\nPress a key to exit...\n");
	_getch();

	return 0;
}

#endif