Mercurial > hg > Members > yuuhi > OpenCL
annotate fft_fixstart/main.cc @ 4:8df0d3128672
add time measurement function
| author | Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 04 Feb 2013 03:43:17 +0900 |
| parents | f3cfea46e585 |
| children | 3602b23914ad |
| rev | line source |
|---|---|
| 3 | 1 #include <stdio.h> |
| 2 #include <stdlib.h> | |
| 3 #include <math.h> | |
| 4 #include <sys/stat.h> | |
| 5 #include <fcntl.h> | |
|
4
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
6 #include <sys/time.h> |
| 3 | 7 |
| 8 #ifdef __APPLE__ | |
| 9 #include <OpenCL/opencl.h> | |
| 10 #else | |
| 11 #include <CL/cl.h> | |
| 12 #endif | |
| 13 | |
| 14 #include "pgm.h" | |
| 15 | |
| 16 #define PI 3.14159265358979 | |
| 17 | |
| 18 #define MAX_SOURCE_SIZE (0x100000) | |
| 19 | |
| 20 #define AMP(a, b) (sqrt((a)*(a)+(b)*(b))) | |
| 21 | |
|
4
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
22 static double st_time; |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
23 static double ed_time; |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
24 |
| 3 | 25 cl_device_id device_id = NULL; |
| 26 cl_context context = NULL; | |
| 27 cl_command_queue queue = NULL; | |
| 28 cl_program program = NULL; | |
| 29 cl_device_type device_type = CL_DEVICE_TYPE_GPU; | |
| 30 | |
| 31 enum Mode { | |
| 32 forward = 0, | |
| 33 inverse = 1 | |
| 34 }; | |
| 35 | |
|
4
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
36 static double |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
37 getTime() |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
38 { |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
39 struct timeval tv; |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
40 gettimeofday(&tv, NULL); |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
41 return tv.tv_sec + (double)tv.tv_usec*1e-6; |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
42 } |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
43 |
| 3 | 44 int setWorkSize(size_t* gws, size_t* lws, cl_int x, cl_int y) |
| 45 { | |
| 46 switch(y) { | |
| 47 case 1: | |
| 48 gws[0] = x; | |
| 49 gws[1] = 1; | |
| 50 lws[0] = 1; | |
| 51 lws[1] = 1; | |
| 52 break; | |
| 53 default: | |
| 54 gws[0] = x; | |
| 55 gws[1] = y; | |
| 56 lws[0] = 1; | |
| 57 lws[1] = 1; | |
| 58 break; | |
| 59 } | |
| 60 | |
| 61 return 0; | |
| 62 } | |
| 63 | |
| 64 int fftCore(cl_mem dst, cl_mem src, cl_mem spin, cl_int m, enum Mode direction) | |
| 65 { | |
| 66 cl_int ret; | |
| 67 | |
| 68 cl_int iter; | |
| 69 cl_uint flag; | |
| 70 | |
| 71 cl_int n = 1<<m; | |
| 72 | |
| 73 cl_event kernelDone; | |
| 74 | |
| 75 cl_kernel brev = NULL; | |
| 76 cl_kernel bfly = NULL; | |
| 77 cl_kernel norm = NULL; | |
| 78 | |
| 79 brev = clCreateKernel(program, "bitReverse", &ret); | |
| 80 bfly = clCreateKernel(program, "butterfly", &ret); | |
| 81 norm = clCreateKernel(program, "norm", &ret); | |
| 82 | |
| 83 size_t gws[2]; | |
| 84 size_t lws[2]; | |
| 85 | |
| 86 switch (direction) { | |
| 87 case forward:flag = 0x00000000; break; | |
| 88 case inverse:flag = 0x80000000; break; | |
| 89 } | |
| 90 | |
| 91 ret = clSetKernelArg(brev, 0, sizeof(cl_mem), (void *)&dst); | |
| 92 ret = clSetKernelArg(brev, 1, sizeof(cl_mem), (void *)&src); | |
| 93 ret = clSetKernelArg(brev, 2, sizeof(cl_int), (void *)&m); | |
| 94 ret = clSetKernelArg(brev, 3, sizeof(cl_int), (void *)&n); | |
| 95 | |
| 96 ret = clSetKernelArg(bfly, 0, sizeof(cl_mem), (void *)&dst); | |
| 97 ret = clSetKernelArg(bfly, 1, sizeof(cl_mem), (void *)&spin); | |
| 98 ret = clSetKernelArg(bfly, 2, sizeof(cl_int), (void *)&m); | |
| 99 ret = clSetKernelArg(bfly, 3, sizeof(cl_int), (void *)&n); | |
| 100 ret = clSetKernelArg(bfly, 5, sizeof(cl_uint), (void *)&flag); | |
| 101 | |
| 102 ret = clSetKernelArg(norm, 0, sizeof(cl_mem), (void *)&dst); | |
| 103 ret = clSetKernelArg(norm, 1, sizeof(cl_int), (void *)&n); | |
| 104 | |
| 105 /* Reverse bit ordering */ | |
| 106 setWorkSize(gws, lws, n, n); | |
| 107 ret = clEnqueueNDRangeKernel(queue, brev, 2, NULL, gws, lws, 0, NULL, NULL); | |
| 108 | |
| 109 /* Perform Butterfly Operations*/ | |
| 110 setWorkSize(gws, lws, n/2, n); | |
| 111 for (iter=1; iter <= m; iter++) { | |
| 112 ret = clSetKernelArg(bfly, 4, sizeof(cl_int), (void *)&iter); | |
| 113 ret = clEnqueueNDRangeKernel(queue, bfly, 2, NULL, gws, lws, 0, NULL, &kernelDone); | |
| 114 ret = clWaitForEvents(1, &kernelDone); | |
| 115 } | |
| 116 | |
| 117 if (direction == inverse) { | |
| 118 setWorkSize(gws, lws, n, n); | |
| 119 ret = clEnqueueNDRangeKernel(queue, norm, 2, NULL, gws, lws, 0, NULL, &kernelDone); | |
| 120 ret = clWaitForEvents(1, &kernelDone); | |
| 121 } | |
| 122 | |
| 123 ret = clReleaseKernel(bfly); | |
| 124 ret = clReleaseKernel(brev); | |
| 125 ret = clReleaseKernel(norm); | |
| 126 | |
| 127 return 0; | |
| 128 } | |
| 129 | |
| 130 char * | |
| 131 init(int argc, char**argv){ | |
| 132 | |
| 133 char *filename = 0; | |
| 134 | |
| 135 for (int i = 1; argv[i]; ++i) { | |
| 136 if (strcmp(argv[i], "-file") == 0) { | |
| 137 filename = argv[i+1]; | |
| 138 } else if (strcmp(argv[i], "-cpu") == 0) { | |
| 139 device_type = CL_DEVICE_TYPE_CPU; | |
| 140 } else if (strcmp(argv[i], "-gpu") == 0) { | |
| 141 device_type = CL_DEVICE_TYPE_GPU; | |
| 142 } | |
| 143 } | |
| 144 if ( (argc == 1)||(filename==0)) { | |
| 145 printf("Usage: ./fft [image filename]\n"); | |
| 146 exit(-1); | |
| 147 } | |
| 148 | |
| 149 return filename; | |
| 150 } | |
| 151 | |
| 152 int main(int argc, char** argv) { | |
| 153 cl_mem xmobj = NULL; | |
| 154 cl_mem rmobj = NULL; | |
| 155 cl_mem wmobj = NULL; | |
| 156 cl_kernel sfac = NULL; | |
| 157 cl_kernel trns = NULL; | |
| 158 cl_kernel hpfl = NULL; | |
| 159 | |
| 160 cl_platform_id platform_id = NULL; | |
| 161 | |
| 162 cl_uint ret_num_devices; | |
| 163 cl_uint ret_num_platforms; | |
| 164 | |
| 165 cl_int ret; | |
| 166 | |
| 167 cl_float2 *xm; | |
| 168 cl_float2 *rm; | |
| 169 cl_float2 *wm; | |
| 170 | |
| 171 pgm_t ipgm; | |
| 172 pgm_t opgm; | |
| 173 | |
| 174 const char fileName[] = "./fft.cl"; | |
| 175 size_t source_size; | |
| 176 char *source_str; | |
| 177 cl_int i, j; | |
| 178 cl_int n; | |
| 179 cl_int m; | |
| 180 | |
| 181 size_t gws[2]; | |
| 182 size_t lws[2]; | |
| 183 | |
| 184 /* Load kernel source code */ | |
| 185 int fd = open(fileName, O_RDONLY); | |
| 186 | |
| 187 if (fd<0) { | |
| 188 fprintf(stderr, "Failed to load kernel %s.\n",fileName); | |
| 189 exit(1); | |
| 190 } | |
| 191 struct stat stats; | |
| 192 fstat(fd, &stats); | |
| 193 off_t size = stats.st_size; | |
| 194 if (size<=0) { | |
| 195 fprintf(stderr, "Failed to load kernel.\n"); | |
| 196 exit(1); | |
| 197 } | |
| 198 source_str = (char*)alloca(size); | |
| 199 source_size = read(fd, source_str, size); | |
| 200 close( fd ); | |
| 201 | |
| 202 char * pgm_file = init(argc,argv); | |
| 203 | |
| 204 /* Read image */ | |
| 205 int err = readPGM(&ipgm, pgm_file); | |
| 206 if (err<0) { | |
| 207 fprintf(stderr, "Failed to read image file.\n"); | |
| 208 exit(1); | |
| 209 } | |
| 210 | |
| 211 n = ipgm.width; | |
| 212 m = (cl_int)(log((double)n)/log(2.0)); | |
| 213 | |
| 214 xm = (cl_float2 *)malloc(n * n * sizeof(cl_float2)); | |
| 215 rm = (cl_float2 *)malloc(n * n * sizeof(cl_float2)); | |
| 216 wm = (cl_float2 *)malloc(n / 2 * sizeof(cl_float2)); | |
| 217 | |
| 218 for (i=0; i < n; i++) { | |
| 219 for (j=0; j < n; j++) { | |
| 220 ((float*)xm)[(2*n*j)+2*i+0] = (float)ipgm.buf[n*j+i]; | |
| 221 ((float*)xm)[(2*n*j)+2*i+1] = (float)0; | |
| 222 } | |
| 223 } | |
| 224 | |
|
4
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
225 st_time = getTime(); |
| 3 | 226 /* Get platform/device */ |
| 227 ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms); | |
| 228 ret = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_DEFAULT, 1, &device_id, &ret_num_devices); | |
| 229 | |
| 230 /* Create OpenCL context */ | |
| 231 context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &ret); | |
| 232 | |
| 233 /* Create Command queue */ | |
| 234 queue = clCreateCommandQueue(context, device_id, 0, &ret); | |
| 235 | |
| 236 /* Create Buffer Objects */ | |
| 237 xmobj = clCreateBuffer(context, CL_MEM_READ_WRITE, n*n*sizeof(cl_float2), NULL, &ret); | |
| 238 rmobj = clCreateBuffer(context, CL_MEM_READ_WRITE, n*n*sizeof(cl_float2), NULL, &ret); | |
| 239 wmobj = clCreateBuffer(context, CL_MEM_READ_WRITE, (n/2)*sizeof(cl_float2), NULL, &ret); | |
| 240 | |
| 241 /* Transfer data to memory buffer */ | |
| 242 ret = clEnqueueWriteBuffer(queue, xmobj, CL_TRUE, 0, n*n*sizeof(cl_float2), xm, 0, NULL, NULL); | |
| 243 | |
| 244 /* Create kernel program from source */ | |
| 245 program = clCreateProgramWithSource(context, 1, (const char **)&source_str, (const size_t *)&source_size, &ret); | |
| 246 | |
| 247 /* Build kernel program */ | |
| 248 ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL); | |
| 249 | |
| 250 if (ret<0) { | |
| 251 size_t size; | |
| 252 clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &size); | |
| 253 | |
| 254 char *log = new char[size]; | |
| 255 clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, size, log, NULL); | |
| 256 printf("%s ",log); | |
| 257 exit (ret); | |
| 258 } | |
| 259 | |
| 260 /* Create OpenCL Kernel */ | |
| 261 sfac = clCreateKernel(program, "spinFact", &ret); | |
| 262 trns = clCreateKernel(program, "transpose", &ret); | |
| 263 hpfl = clCreateKernel(program, "highPassFilter", &ret); | |
| 264 | |
| 265 /* Create spin factor */ | |
| 266 ret = clSetKernelArg(sfac, 0, sizeof(cl_mem), (void *)&wmobj); | |
| 267 ret = clSetKernelArg(sfac, 1, sizeof(cl_int), (void *)&n); | |
| 268 setWorkSize(gws, lws, n/2, 1); | |
| 269 ret = clEnqueueNDRangeKernel(queue, sfac, 1, NULL, gws, lws, 0, NULL, NULL); | |
| 270 | |
| 271 /* Butterfly Operation */ | |
| 272 fftCore(rmobj, xmobj, wmobj, m, forward); | |
| 273 | |
| 274 /* Transpose matrix */ | |
| 275 ret = clSetKernelArg(trns, 0, sizeof(cl_mem), (void *)&xmobj); | |
| 276 ret = clSetKernelArg(trns, 1, sizeof(cl_mem), (void *)&rmobj); | |
| 277 ret = clSetKernelArg(trns, 2, sizeof(cl_int), (void *)&n); | |
| 278 setWorkSize(gws, lws, n, n); | |
| 279 ret = clEnqueueNDRangeKernel(queue, trns, 2, NULL, gws, lws, 0, NULL, NULL); | |
| 280 | |
| 281 /* Butterfly Operation */ | |
| 282 fftCore(rmobj, xmobj, wmobj, m, forward); | |
| 283 | |
| 284 /* Apply high-pass filter */ | |
| 285 cl_int radius = n/8; | |
| 286 ret = clSetKernelArg(hpfl, 0, sizeof(cl_mem), (void *)&rmobj); | |
| 287 ret = clSetKernelArg(hpfl, 1, sizeof(cl_int), (void *)&n); | |
| 288 ret = clSetKernelArg(hpfl, 2, sizeof(cl_int), (void *)&radius); | |
| 289 setWorkSize(gws, lws, n, n); | |
| 290 ret = clEnqueueNDRangeKernel(queue, hpfl, 2, NULL, gws, lws, 0, NULL, NULL); | |
| 291 | |
| 292 /* Inverse FFT */ | |
| 293 | |
| 294 /* Butterfly Operation */ | |
| 295 fftCore(xmobj, rmobj, wmobj, m, inverse); | |
| 296 | |
| 297 /* Transpose matrix */ | |
| 298 ret = clSetKernelArg(trns, 0, sizeof(cl_mem), (void *)&rmobj); | |
| 299 ret = clSetKernelArg(trns, 1, sizeof(cl_mem), (void *)&xmobj); | |
| 300 setWorkSize(gws, lws, n, n); | |
| 301 ret = clEnqueueNDRangeKernel(queue, trns, 2, NULL, gws, lws, 0, NULL, NULL); | |
| 302 | |
| 303 /* Butterfly Operation */ | |
| 304 | |
| 305 fftCore(xmobj, rmobj, wmobj, m, inverse); | |
| 306 | |
| 307 /* Read data from memory buffer */ | |
| 308 ret = clEnqueueReadBuffer(queue, xmobj, CL_TRUE, 0, n*n*sizeof(cl_float2), xm, 0, NULL, NULL); | |
| 309 | |
| 310 /* */ | |
| 311 float* ampd; | |
| 312 ampd = (float*)malloc(n*n*sizeof(float)); | |
| 313 for (i=0; i < n; i++) { | |
| 314 for (j=0; j < n; j++) { | |
| 315 ampd[n*((i))+((j))] = (AMP(((float*)xm)[(2*n*i)+2*j], ((float*)xm)[(2*n*i)+2*j+1])); | |
| 316 } | |
| 317 } | |
| 318 opgm.width = n; | |
| 319 opgm.height = n; | |
| 320 normalizeF2PGM(&opgm, ampd); | |
| 321 free(ampd); | |
| 322 | |
| 323 /* Write out image */ | |
| 324 writePGM(&opgm, "output.pgm"); | |
| 325 | |
| 326 /* Finalizations*/ | |
| 327 ret = clFlush(queue); | |
| 328 ret = clFinish(queue); | |
|
4
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
329 ed_time = getTime(); |
| 3 | 330 ret = clReleaseKernel(hpfl); |
| 331 ret = clReleaseKernel(trns); | |
| 332 ret = clReleaseKernel(sfac); | |
| 333 ret = clReleaseProgram(program); | |
| 334 ret = clReleaseMemObject(xmobj); | |
| 335 ret = clReleaseMemObject(rmobj); | |
| 336 ret = clReleaseMemObject(wmobj); | |
| 337 ret = clReleaseCommandQueue(queue); | |
| 338 ret = clReleaseContext(context); | |
| 339 | |
| 340 destroyPGM(&ipgm); | |
| 341 destroyPGM(&opgm); | |
| 342 | |
| 343 free(wm); | |
| 344 free(rm); | |
| 345 free(xm); | |
| 346 | |
|
4
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
347 fprintf(stdout, "image out put succeeded.\n"); |
|
8df0d3128672
add time measurement function
Yuhi TOMARI <yuhi@cr.ie.u-ryukyu.ac.jp>
parents:
3
diff
changeset
|
348 printf("Time: %0.6f\n",ed_time-st_time); |
| 3 | 349 return 0; |
| 350 } |