#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>

#define  N   		1024
#define  BLOCK_SIZE	1024

float hArray[N];
float *dArray;
int blocks;

float* result;
float* dResult;

void prologue(void) {
	cudaMalloc((void**) &dArray, sizeof(hArray));
	cudaMemcpy(dArray, hArray, sizeof(hArray), cudaMemcpyHostToDevice);
	cudaMalloc((void**) &dResult, sizeof(result));
	cudaMemcpy(dResult, result, sizeof(result), cudaMemcpyHostToDevice);
}

void epilogue(void) {
	cudaMemcpy(hArray, dArray, sizeof(hArray), cudaMemcpyDeviceToHost);
	cudaFree(dArray);
	cudaMemcpy(result, dResult, sizeof(result), cudaMemcpyDeviceToHost);
	cudaFree(dResult);
}

__global__ void calcDevice(float *A, float* result, float value) {
	int x = blockDim.x * blockIdx.x + threadIdx.x;

	if (x < N) {
		if (A[x] == value)
			*result = A[x];
	}
}

int compare(const void* a, const void* b)
{
	if (*(float*)a < *(float*)b)
		return -1;
	else if (*(float*)a > *(float*)b)
		return 1;
	else
		return 0;
}

void findMax(void) {
	srand(time(NULL));
	for (int i = 0; i < N; i++) {
		hArray[i] = (float) rand() / RAND_MAX;
	}
	qsort(hArray, N, sizeof(float), compare);

	float found = 0.0F;
	result = &found;

	float value = hArray[22];
	float* bFound = (float*) bsearch(&value, hArray, N, sizeof(float), compare);
	printf("Value = %f\n", value);
	printf("bsearch() = %f\n", *bFound);

	prologue();

	blocks = N / BLOCK_SIZE;
	if (N % BLOCK_SIZE)
		blocks++;

	calcDevice<<<blocks, BLOCK_SIZE>>>(dArray, dResult, value);

	cudaThreadSynchronize();
	epilogue();

	printf("Result = %f\n", found);
}

int main(int argc, char** argv) {
	int devCnt;

	cudaGetDeviceCount(&devCnt);
	if (devCnt == 0) {
		perror("No CUDA devices available -- exiting.");
		return 1;
	}

	findMax();

	return 0;
}