MergeSort_GPU/cuda_header.h at master · mteaudors/MergeSort_GPU · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#ifndef CUDA_HEADER_H
#define CUDA_HEADER_H

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <cstdio>
#include <cstdlib>
#include <string>
#include <ctime>

#define SIZE_A 512
#define SIZE_B 512
#define SIZE_M (SIZE_A + SIZE_B)
#define N 1000

#define D 0b100000000
#define BATCH_THRESHOLD 1024
#define USE_BATCH 1 // 0 : False ; everything else : True
#define RECORD_TIME 1  // 0 : False ; everything else : True

#define LENGTH_A (SIZE_A * sizeof(int))
#define LENGTH_B (SIZE_B * sizeof(int))
#define LENGTH_M (SIZE_M * sizeof(int))

#define ARRAY_SIZES 64
#define TWO_ARRAY_SIZE (ARRAY_SIZES * 2)
#define TOTAL_SIZE (ARRAY_NUMBER * ARRAY_SIZES)

#define ARRAY_LENGTH (ARRAY_SIZES * sizeof(int))
#define TOTAL_LENGTH (TOTAL_SIZE * sizeof(int))

#define BLOCKSIZE 64
#define GRIDSIZE(DATA_SIZE) (((DATA_SIZE) + (BLOCKSIZE) - 1)/(BLOCKSIZE))

typedef struct {
	int x;
	int y;
} duo;

void testcuda(cudaError_t error, const char *file, int line) {
	if (error != cudaSuccess) {
		fprintf(stderr, "error in file %s at line %d\n", file, line);
		fprintf(stderr, "error is %s : %s\n", cudaGetErrorName(error), cudaGetErrorString(error));
		exit(1);
	}
}

#define testCUDA(error) (testcuda((error), __FILE__, __LINE__))

int* generate_array(int length) {
	int* arr = (int*) malloc(length*sizeof(int));
	int r = rand()%1000;
	for (int i = 0; i < length; ++i)
		arr[i] = i * (i+r);
	return arr;
}


int *generate_array_batch(int length,int sub_length) {
	int *arr = (int*)malloc(length*sizeof(int));
	for (int k=0 ; k<length/sub_length ; ++k) {
		int r = rand()%1000;
		for(int i=0 ; i<sub_length ; ++i)
			arr[sub_length*k + i] = i * (i+r);
	}
	return arr;

}

int* generate_unsorted_array(int length) {
	int* arr = (int*) malloc(length*sizeof(int));
	for (int i = 0; i < length; ++i)
		arr[i] = rand()%100000;
	return arr;
}

void print_array(int *arr, int length, std::string name) {
	printf("\n\t\t############### %s ###############\n\n",name.c_str());
	for (int i = 0; i < length ; ++i) {
		printf("%s[%d] = %d", name.c_str(), i, *(arr + i));

		if(i>0 && arr[i-1] > arr[i]) {
			printf("============================================================================\n");
			printf("Array not sorted : %s[%d] = %d > %s[%d] = %d\n",name.c_str(),i-1,arr[i-1],name.c_str(),i,arr[i]);
			printf("============================================================================\n");
			return;
        }
		if(i != length-1) printf(", ");
	}
	printf("\n");
	printf("============================================================================\n");
	printf("Array %s containing %d elements is sorted\n", name.c_str(), length);
	printf("============================================================================\n");
}

void print_unsorted_array(int *arr, int length, std::string name) {
	printf("\n\t\t############### %s ###############\n\n",name.c_str());
	for (int i = 0; i < length ; ++i) {
		printf("%s[%d] = %d", name.c_str(), i, *(arr + i));
		if(i != length-1) printf(", ");
	}
	printf("\n");
}

void check_array_sorted(int *arr, int length, std::string name) {
	for(int i=1; i<length; ++i) {
		if(arr[i-1] > arr[i]) {
			printf("============================================================================\n");
			printf("Array not sorted : %s[%d] = %d > %s[%d] = %d\n",name.c_str(),i-1,arr[i-1],name.c_str(),i,arr[i]);
			printf("============================================================================\n");
			return;
        }
	}
	printf("============================================================================\n");
	printf("Array %s containing %d elements is sorted\n", name.c_str(), length);
	printf("============================================================================\n");
}

bool check_array_sorted_no_print(int *arr, int length) {
	for(int i=1; i<length; ++i) {
		if(arr[i-1] > arr[i]) {
			return false;
        	}
	}
	return true;
}

#endif // CUDA_HEADER_H