1 #ifndef STAN_MATH_OPENCL_KERNEL_CL_HPP 2 #define STAN_MATH_OPENCL_KERNEL_CL_HPP 22 #define STRINGIFY(src) #src 27 namespace opencl_kernels {
64 m.add_read_write_event(e);
68 typename std::enable_if_t<std::is_same<T, cl::Event>::value,
int> = 0>
84 template <
typename Arg,
typename... Args>
88 assign_event<Arg>(new_event, m);
94 return std::vector<cl::Event>();
100 return m.write_events();
106 return m.read_write_events();
112 return m.read_write_events();
125 const std::vector<const char*>& sources,
126 std::map<const char*, int>& options) {
127 std::string kernel_opts =
"";
128 for (
auto&& comp_opts : options) {
129 kernel_opts += std::string(
" -D") + comp_opts.first +
"=" 130 + std::to_string(comp_opts.second);
132 std::string kernel_source;
133 for (
const char* source : sources) {
134 kernel_source.append(source);
138 cl::Program::Sources src(1, std::make_pair(kernel_source.c_str(),
139 strlen(kernel_source.c_str())));
143 return cl::Kernel(program, name);
144 }
catch (
const cl::Error&
e) {
146 if (e.err() == -11) {
147 std::string buildlog = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(
149 system_error(
"compile_kernel", name, e.err(), buildlog.c_str());
162 template <
typename... Args>
166 std::map<const char*, int> opts_;
176 const std::map<const char*, int>& options) {
178 for (
auto& it : options) {
179 if (base_opts[it.first] > it.second) {
180 base_opts[it.first] = it.second;
187 auto operator()()
const {
return cl::make_kernel<Args...>(kernel_); }
192 inline const std::map<const char*, int>&
get_opts()
const {
return opts_; }
200 template <
typename... Args>
211 const std::map<const char*, int>& options = {})
212 : make_functor(name, {source}, options) {}
220 kernel_cl(
const char* name,
const std::vector<const char*>& sources,
221 const std::map<const char*, int>& options = {})
222 : make_functor(name, sources, options) {}
231 auto f = make_functor();
232 const std::vector<cl::Event> kernel_events
233 =
vec_concat(internal::select_events<Args>(args)...);
248 auto operator()(cl::NDRange global_thread_size, cl::NDRange thread_block_size,
250 auto f = make_functor();
251 const std::vector<cl::Event> kernel_events
252 =
vec_concat(internal::select_events<Args>(args)...);
254 global_thread_size, thread_block_size);
std::vector< cl::Device > device()
Returns a vector containing the OpenCL device used to create the context.
const std::vector< T > & vec_concat(const std::vector< T > &v1)
Ends the recursion to extract the event stack.
void assign_event< in_out_buffer >(const cl::Event &e, const stan::math::matrix_cl &m)
void system_error(const char *function, const char *name, const int &y, const char *msg1, const char *msg2)
Throw a system error with a consistently formatted message.
void assign_event< in_buffer >(const cl::Event &e, const stan::math::matrix_cl &m)
const cl::Buffer & buffer() const
auto compile_kernel(const char *name, const std::vector< const char *> &sources, std::map< const char *, int > &options)
Compile an OpenCL kernel.
const std::vector< cl::Event > select_events(to_const_matrix_cl_t< T > &t)
The API to access the methods and values in opencl_context_base.
void assign_event< out_buffer >(const cl::Event &e, const stan::math::matrix_cl &m)
The matrix_cl class - allocates memory space on the OpenCL device, functions for transfering matrices...
void assign_events(const T &)
const std::vector< cl::Event > select_events< out_buffer >(const stan::math::matrix_cl &m)
auto operator()(cl::NDRange global_thread_size, internal::to_const_matrix_cl_t< Args > &... args) const
Executes a kernel.
Functor used for compiling kernels.
const kernel_functor< internal::to_const_buffer_t< Args > &... > make_functor
const typename internal::to_matrix_cl< T >::type to_const_matrix_cl_t
void assign_event(const cl::Event &, to_const_matrix_cl_t< T > &)
Represents a matrix on the OpenCL device.
checking OpenCL error numbers
const std::vector< cl::Event > select_events< in_out_buffer >(const stan::math::matrix_cl &m)
kernel_cl(const char *name, const char *source, const std::map< const char *, int > &options={})
Creates functor for kernels that only need access to defining the global work size.
cl::Context & context()
Returns the reference to the OpenCL context.
Initialization for OpenCL:
opencl_context_base::map_base_opts base_opts()
Returns a copy of the map of kernel defines.
double e()
Return the base of the natural logarithm.
auto operator()(cl::NDRange global_thread_size, cl::NDRange thread_block_size, internal::to_const_matrix_cl_t< Args > &... args) const
Executes a kernel.
Creates functor for kernels.
const std::map< const char *, int > & get_opts() const
kernel_cl(const char *name, const std::vector< const char *> &sources, const std::map< const char *, int > &options={})
Creates functor for kernels that only need access to defining the global work size.
const std::vector< cl::Event > select_events< in_buffer >(const stan::math::matrix_cl &m)
kernel_functor(const char *name, const std::vector< const char *> &sources, const std::map< const char *, int > &options)
functor to access the kernel compiler.
const T & get_kernel_args(const T &t)
Extracts the kernel's arguments, used in the global and local kernel constructor. ...
void check_opencl_error(const char *function, const cl::Error &e)
Throws the domain error with specifying the OpenCL error that occured.
cl::CommandQueue & queue()
Returns the reference to the active OpenCL command queue for the device.