forked from GerhardR/kfusion
-
Notifications
You must be signed in to change notification settings - Fork 4
/
common_opencl.h
195 lines (171 loc) · 6.23 KB
/
common_opencl.h
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
/*
Copyright (c) 2014 University of Edinburgh, Imperial College, University of Manchester.
Developed in the PAMELA project, EPSRC Programme Grant EP/K008730/1
This code is licensed under the MIT License.
*/
#ifndef _COMMON_OPENCL_
#define _COMMON_OPENCL_
#define __NO_STD_VECTOR // Use cl::vector instead of STL version
#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
#include <commons.h>
// OPEN CL STUFF
extern cl_int clError;
extern cl_platform_id platform_id;
extern cl_event event;
extern cl_device_id device_id;
extern cl_context context;
extern cl_program program;
extern cl_command_queue commandQueue;
extern size_t _ls[2];
inline std::string descriptionOfError(cl_int err) {
switch (err) {
case CL_SUCCESS:
return "Success!";
case CL_DEVICE_NOT_FOUND:
return "Device not found.";
case CL_DEVICE_NOT_AVAILABLE:
return "Device not available";
case CL_COMPILER_NOT_AVAILABLE:
return "Compiler not available";
case CL_MEM_OBJECT_ALLOCATION_FAILURE:
return "Memory object allocation failure";
case CL_OUT_OF_RESOURCES:
return "Out of resources";
case CL_OUT_OF_HOST_MEMORY:
return "Out of host memory";
case CL_PROFILING_INFO_NOT_AVAILABLE:
return "Profiling information not available";
case CL_MEM_COPY_OVERLAP:
return "Memory copy overlap";
case CL_IMAGE_FORMAT_MISMATCH:
return "Image format mismatch";
case CL_IMAGE_FORMAT_NOT_SUPPORTED:
return "Image format not supported";
case CL_BUILD_PROGRAM_FAILURE:
return "Program build failure";
case CL_MAP_FAILURE:
return "Map failure";
case CL_INVALID_VALUE:
return "Invalid value";
case CL_INVALID_DEVICE_TYPE:
return "Invalid device type";
case CL_INVALID_PLATFORM:
return "Invalid platform";
case CL_INVALID_DEVICE:
return "Invalid device";
case CL_INVALID_CONTEXT:
return "Invalid context";
case CL_INVALID_QUEUE_PROPERTIES:
return "Invalid queue properties";
case CL_INVALID_COMMAND_QUEUE:
return "Invalid command queue";
case CL_INVALID_HOST_PTR:
return "Invalid host pointer";
case CL_INVALID_MEM_OBJECT:
return "Invalid memory object";
case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
return "Invalid image format descriptor";
case CL_INVALID_IMAGE_SIZE:
return "Invalid image size";
case CL_INVALID_SAMPLER:
return "Invalid sampler";
case CL_INVALID_BINARY:
return "Invalid binary";
case CL_INVALID_BUILD_OPTIONS:
return "Invalid build options";
case CL_INVALID_PROGRAM:
return "Invalid program";
case CL_INVALID_PROGRAM_EXECUTABLE:
return "Invalid program executable";
case CL_INVALID_KERNEL_NAME:
return "Invalid kernel name";
case CL_INVALID_KERNEL_DEFINITION:
return "Invalid kernel definition";
case CL_INVALID_KERNEL:
return "Invalid kernel";
case CL_INVALID_ARG_INDEX:
return "Invalid argument index";
case CL_INVALID_ARG_VALUE:
return "Invalid argument value";
case CL_INVALID_ARG_SIZE:
return "Invalid argument size";
case CL_INVALID_KERNEL_ARGS:
return "Invalid kernel arguments";
case CL_INVALID_WORK_DIMENSION:
return "Invalid work dimension";
case CL_INVALID_WORK_GROUP_SIZE:
return "Invalid work group size";
case CL_INVALID_WORK_ITEM_SIZE:
return "Invalid work item size";
case CL_INVALID_GLOBAL_OFFSET:
return "Invalid global offset";
case CL_INVALID_EVENT_WAIT_LIST:
return "Invalid event wait list";
case CL_INVALID_EVENT:
return "Invalid event";
case CL_INVALID_OPERATION:
return "Invalid operation";
case CL_INVALID_GL_OBJECT:
return "Invalid OpenGL object";
case CL_INVALID_BUFFER_SIZE:
return "Invalid buffer size";
case CL_INVALID_MIP_LEVEL:
return "Invalid mip-map level";
default:
return "Unknown";
}
}
#define checkErr(err,name) \
if (err != CL_SUCCESS) {\
std::cerr << "ERR: " << std::string(name) << "(";\
std::cerr << descriptionOfError(err); \
std::cerr << ") " << __FILE__ << ":"<< __LINE__ << std::endl; \
exit(EXIT_FAILURE);\
}
inline void checkErrX(cl_int err, const char * name) {
if (err != CL_SUCCESS) {
std::cerr << "ERROR: " << name << " (" << err << ")" << std::endl;
exit(EXIT_FAILURE);
}
}
void opencl_init(void);
void opencl_clean(void);
#define RELEASE_IN_BUFFER(name) \
clError = clReleaseMemObject(name##Buffer);\
checkErr( clError, "clReleaseMemObject");
#define RELEASE_OUT_BUFFER(name) \
clError = clEnqueueReadBuffer(commandQueue , name##Buffer, CL_TRUE, 0, name##BufferSize, name##Ptr, 0, NULL, NULL ); \
checkErr( clError, "clEnqueueReadBuffer");\
clError = clReleaseMemObject(name##Buffer);\
checkErr( clError, "clReleaseMemObject");
#define RELEASE_INOUT_BUFFER(name) \
clError = clEnqueueReadBuffer(commandQueue , name##Buffer, CL_TRUE, 0, name##BufferSize, name##Ptr, 0, NULL, NULL ); \
checkErr( clError, "clEnqueueReadBuffer");\
clError = clReleaseMemObject(name##Buffer);\
checkErr( clError, "clReleaseMemObject");
#define RELEASE_KERNEL(kernelname) clError = clReleaseKernel(kernelname); checkErr( clError, "clReleaseKernel");
#define CREATE_KERNEL(name) CREATE_KERNELVAR(name,#name);
#define CREATE_KERNELVAR(varname,kernelname) cl_kernel varname = clCreateKernel(program,kernelname, &clError); checkErr( clError, "clCreateKernel" );
#define CREATE_OUT_BUFFER(name,ptr,size)\
size_t name##BufferSize = size;\
void * name##Ptr = (void *) ptr;\
cl_mem name##Buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY , name##BufferSize , NULL , &clError);\
checkErr( clError, "clCreateBuffer input" );
#define CREATE_IN_BUFFER(name,ptr,size)\
size_t name##BufferSize = size;\
void * name##Ptr = (void *) ptr;\
cl_mem name##Buffer = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR , name##BufferSize , name##Ptr , &clError);\
checkErr( clError, "clCreateBuffer input" );\
#define CREATE_INOUT_BUFFER(name,ptr,size)\
size_t name##BufferSize = size;\
void * name##Ptr = (void *) ptr;\
cl_mem name##Buffer = clCreateBuffer(context, CL_MEM_READ_WRITE , name##BufferSize , NULL , &clError);\
checkErr( clError, "clCreateBuffer input" );\
clError = clEnqueueWriteBuffer(commandQueue, name##Buffer , CL_TRUE, 0, name##BufferSize , ptr, 0, NULL, NULL);\
checkErr( clError, "clEnqueueWriteBuffer" ) ;
// Remove the CL_TRUE in the write here?
#endif // _COMMON_OPENCL_