21 #ifndef __TBB_flow_graph_opencl_node_H 22 #define __TBB_flow_graph_opencl_node_H 25 #if __TBB_PREVIEW_OPENCL_NODE 38 #include <OpenCL/opencl.h> 46 namespace interface10 {
48 template <
typename DeviceFilter>
51 namespace opencl_info {
55 template <
typename Factory>
59 if (err != CL_SUCCESS) {
60 std::cerr << msg <<
"; error code: " << err << std::endl;
68 enforce_cl_retcode(clGetEventInfo(e, i,
sizeof(res), &res, NULL),
"Failed to get OpenCL event information");
75 enforce_cl_retcode(clGetDeviceInfo(
d, i,
sizeof(res), &res, NULL),
"Failed to get OpenCL device information");
80 inline std::string device_info<std::string>(cl_device_id
d, cl_device_info i) {
82 enforce_cl_retcode(clGetDeviceInfo(
d, i, 0, NULL, &required),
"Failed to get OpenCL device information");
84 char *buff = (
char*)alloca(required);
85 enforce_cl_retcode(clGetDeviceInfo(
d, i, required, buff, NULL),
"Failed to get OpenCL device information");
93 enforce_cl_retcode(clGetPlatformInfo(
p, i,
sizeof(res), &res, NULL),
"Failed to get OpenCL platform information");
98 inline std::string platform_info<std::string>(cl_platform_id
p, cl_platform_info i) {
100 enforce_cl_retcode(clGetPlatformInfo(
p, i, 0, NULL, &required),
"Failed to get OpenCL platform information");
102 char *buff = (
char*)alloca(required);
103 enforce_cl_retcode(clGetPlatformInfo(
p, i, required, buff, NULL),
"Failed to get OpenCL platform information");
124 return platform_info<std::string>(
platform_id(), CL_PLATFORM_PROFILE );
127 return platform_info<std::string>(
platform_id(), CL_PLATFORM_VERSION );
130 return platform_info<std::string>(
platform_id(), CL_PLATFORM_NAME );
133 return platform_info<std::string>(
platform_id(), CL_PLATFORM_VENDOR );
136 return platform_info<std::string>(
platform_id(), CL_PLATFORM_EXTENSIONS );
139 template <
typename T>
140 void info( cl_device_info i, T &t )
const {
149 std::sscanf(
version().c_str(),
"OpenCL %d", &major );
154 std::sscanf(
version().c_str(),
"OpenCL %d.%d", &major, &minor );
160 return (device_info<cl_command_queue_properties>(
my_cl_device_id, CL_DEVICE_QUEUE_ON_HOST_PROPERTIES ) & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE) != 0;
163 return (device_info<cl_command_queue_properties>(
my_cl_device_id, CL_DEVICE_QUEUE_PROPERTIES ) & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE) != 0;
168 return (device_info<cl_command_queue_properties>(
my_cl_device_id, CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES ) & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE) != 0;
174 return device_info<std::array<size_t, 3>>(
my_cl_device_id, CL_DEVICE_MAX_WORK_ITEM_SIZES );
177 return device_info<size_t>(
my_cl_device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE );
180 const std::string semi =
";";
182 return (semi +
built_in_kernels() + semi).find( semi + k + semi ) != std::string::npos;
185 return device_info<std::string>(
my_cl_device_id, CL_DEVICE_BUILT_IN_KERNELS );
194 return device_info<cl_bool>(
my_cl_device_id, CL_DEVICE_COMPILER_AVAILABLE );
197 return device_info<cl_bool>(
my_cl_device_id, CL_DEVICE_LINKER_AVAILABLE );
200 const std::string space =
" ";
202 return (space +
extensions() + space).find( space + ext + space ) != std::string::npos;
205 return device_info<std::string>(
my_cl_device_id, CL_DEVICE_EXTENSIONS );
217 return device_info<cl_uint>(
my_cl_device_id, CL_DEVICE_ADDRESS_BITS );
233 return device_info<cl_platform_id>(
my_cl_device_id, CL_DEVICE_PLATFORM );
244 template <
typename DeviceFilter>
246 template <
typename Factory>
248 template <
typename Factory>
252 template <
typename T,
typename Factory>
287 cl_uint num_platforms;
288 enforce_cl_retcode(clGetPlatformIDs(0, NULL, &num_platforms),
"clGetPlatformIDs failed");
290 std::vector<cl_platform_id> platforms(num_platforms);
291 enforce_cl_retcode(clGetPlatformIDs(num_platforms, platforms.data(), NULL),
"clGetPlatformIDs failed");
294 std::vector<cl_platform_id>::iterator platforms_it = platforms.begin();
295 cl_uint num_all_devices = 0;
296 while (platforms_it != platforms.end()) {
297 cl_int err = clGetDeviceIDs(*platforms_it, CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices);
298 if (err == CL_DEVICE_NOT_FOUND) {
299 platforms_it = platforms.erase(platforms_it);
303 num_all_devices += num_devices;
308 std::vector<cl_device_id> devices(num_all_devices);
309 std::vector<cl_device_id>::iterator devices_it = devices.begin();
310 for (
auto p = platforms.begin();
p != platforms.end(); ++
p) {
311 enforce_cl_retcode(clGetDeviceIDs((*
p), CL_DEVICE_TYPE_ALL, (cl_uint)std::distance(devices_it, devices.end()), &*devices_it, &num_devices),
"clGetDeviceIDs failed");
312 devices_it += num_devices;
315 for (
auto d = devices.begin();
d != devices.end(); ++
d) {
319 return opencl_devices;
325 namespace opencl_info {
338 virtual void call() = 0;
342 template <
typename Callback,
typename T>
354 template <
typename T,
typename Factory = opencl_info::default_opencl_factory>
381 const T&
data(
bool wait =
true )
const {
402 dmsg.my_is_event =
false;
432 cl_command_queue cq = event_info<cl_command_queue>(
my_event, CL_EVENT_COMMAND_QUEUE );
433 if ( cq != event_info<cl_command_queue>( e, CL_EVENT_COMMAND_QUEUE ) )
444 enforce_cl_retcode( clFlush( event_info<cl_command_queue>(
my_event, CL_EVENT_COMMAND_QUEUE ) ),
"Failed to flush an OpenCL command queue" );
450 template <
typename Callback>
456 operator T&() {
return data(); }
457 operator const T&()
const {
return data(); }
481 __TBB_ASSERT( event_command_exec_status == CL_COMPLETE, NULL );
495 template <
typename K,
typename T,
typename Factory>
498 const T &t = dmsg.
data(
false );
500 return key_from_message<K, T>( t );
503 template <
typename Factory>
561 my_factory->enqueue_unmap_buffer(device, *
this,
d);
591 template <
typename Factory>
604 cl_buffer_region region = { index,
size };
605 this->
my_cl_mem = clCreateSubBuffer( m, 0, CL_BUFFER_CREATE_TYPE_REGION, ®ion, &err );
614 this->
my_factory->enqueue_map_buffer( device, *
this, dmsg );
618 template <
typename,
typename>
629 template <
typename T,
typename Factory = opencl_info::default_opencl_factory>
632 template <
typename T,
typename Factory = opencl_info::default_opencl_factory>
641 template <access_type a>
643 T* ptr = (T*)
my_impl->get_host_ptr();
648 T*
data()
const {
return &access<read_write>()[0]; }
650 template <access_type a = read_write>
653 template <access_type a = read_write>
675 const cl_event *e =
d.get_event();
682 const cl_event *e =
d.get_event();
702 template <
typename,
typename>
706 template <
typename T,
typename Factory>
715 template <
typename T,
typename Factory>
721 #define is_typedef(type) \ 722 template <typename T> \ 724 template <typename C> \ 725 static std::true_type check( typename C::type* ); \ 726 template <typename C> \ 727 static std::false_type check( ... ); \ 729 static const bool value = decltype(check<T>(0))::value; \ 735 template <
typename T>
737 return t.native_object();
740 template <
typename T>
746 template <
typename T,
typename Factory>
748 const T &t = dmsg.
data(
false );
749 typedef typename T::memory_object_type mem_obj_t;
750 mem_obj_t mem_obj = t.memory_object();
753 mem_obj.send( device,
d );
754 if (
d.get_event() ) dmsg.
set_event( *
d.get_event() );
757 template <
typename T>
759 typedef typename T::memory_object_type mem_obj_t;
760 mem_obj_t mem_obj = t.memory_object();
762 mem_obj.send( device, dmsg );
765 template <
typename T>
769 template <
typename T,
typename Factory>
771 const T &t = dmsg.
data(
false );
772 typedef typename T::memory_object_type mem_obj_t;
773 mem_obj_t mem_obj = t.memory_object();
776 mem_obj.receive(
d );
777 if (
d.get_event() ) dmsg.
set_event( *
d.get_event() );
780 template <
typename T>
788 template <
typename G = std::initializer_list<
int>,
typename L = std::initializer_list<
int>,
789 typename =
typename std::enable_if<!std::is_same<
typename std::decay<G>::type, opencl_range>::value>::type>
790 opencl_range(G&& global_work = std::initializer_list<int>({ 0 }), L&& local_work = std::initializer_list<int>({ 0, 0, 0 })) {
791 auto g_it = global_work.begin();
792 auto l_it = local_work.begin();
795 for (
int s = 0;
s < 3 && g_it != global_work.end(); ++g_it, ++l_it, ++
s) {
796 __TBB_ASSERT(l_it != local_work.end(),
"global_work & local_work must have same size");
810 template <
typename DeviceFilter>
822 std::vector<char> kernel_name;
823 for (
size_t curr_size = 32;; curr_size <<= 1 ) {
824 kernel_name.resize( curr_size <<= 1 );
825 enforce_cl_retcode( clGetKernelInfo( k.
my_cl_kernel, CL_KERNEL_FUNCTION_NAME, curr_size, kernel_name.data(), &ret_size ),
"Failed to get kernel info" );
826 if ( ret_size < curr_size )
break;
849 template <
typename DeviceFilter_>
852 template <
typename Factory>
866 enforce_cl_retcode( clReleaseCommandQueue( (*d).my_cl_command_queue ),
"Failed to release a command queue" );
883 template <
typename Factory>
889 e1 == NULL ? 0 : 1, e1, &e2, &err );
891 dmsg.
data(
false ) = ptr;
897 template <
typename Factory>
903 "Failed to unmap a buffer" );
909 template <
size_t NUM_ARGS,
typename T>
912 enforce_cl_retcode( clSetKernelArg(kernel.my_cl_kernel, place++,
sizeof(
p), &
p),
"Failed to set a kernel argument" );
915 template <
size_t NUM_ARGS,
typename T,
typename F>
917 __TBB_ASSERT((
static_cast<typename std::array<cl_event, NUM_ARGS>::size_type
>(num_events) < events.size()), NULL);
919 const cl_event *
const e = msg.
get_event();
921 events[num_events++] = *e;
927 template <
size_t NUM_ARGS,
typename T,
typename ...Rest>
928 void process_arg_list(
const kernel_type& kernel, std::array<cl_event, NUM_ARGS>& events,
int& num_events,
int& place,
const T& t,
const Rest&... args ) {
933 template <
size_t NUM_ARGS>
936 template <
typename T>
939 template <
typename T,
typename F>
944 template <
typename T,
typename ...Rest>
953 template <
typename ...Args>
955 std::array<cl_event,
sizeof...(Args)> events;
960 const cl_event e =
send_kernel_impl( device, kernel.my_cl_kernel, work_size, num_events, events.data() );
969 template <
typename T,
typename ...Rest>
980 const range_type& work_size, cl_uint num_events, cl_event* event_list ) {
985 for (
s = 1;
s < 3 && g_size[
s] != size_t(-1); ++
s) {}
989 g_offset.data(), g_size.data(), l_size[0] ? l_size.data() : NULL, num_events, num_events ? event_list : NULL, &
event ),
990 "Failed to enqueue a kernel" );
995 template <
typename T>
1000 template <
typename T,
typename F>
1002 cl_event
const *e_ptr = msg.
get_event();
1004 if ( e_ptr != NULL ) {
1012 template <
typename T,
typename ...Rest>
1031 template<
typename Fn>
1040 __TBB_ASSERT(event_command_exec_status == CL_COMPLETE, NULL);
1042 finalize_fn *
const fn_ptr = static_cast<finalize_fn*>(
data);
1043 __TBB_ASSERT(fn_ptr != NULL,
"Invalid finalize function pointer");
1050 template <
typename FinalizeFn,
typename ...Args>
1056 new finalize_fn_leaf<FinalizeFn>(
fn) ),
"Failed to set a callback" );
1094 enforce_cl_retcode(it->platform_id() == platform_id ? CL_SUCCESS : CL_INVALID_PLATFORM,
"All devices should be in the same platform");
1096 std::vector<cl_device_id> cl_device_ids;
1098 cl_device_ids.push_back((*d).my_cl_device_id);
1101 cl_context_properties context_properties[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id, (cl_context_properties)NULL };
1103 cl_context ctx = clCreateContext(context_properties,
1104 (cl_uint)cl_device_ids.size(),
1105 cl_device_ids.data(),
1110 size_t device_counter = 0;
1112 (*d).my_device_id = device_counter++;
1114 cl_command_queue cq;
1116 if ((*d).major_version() >= 2) {
1117 if ((*d).out_of_order_exec_mode_on_host_present()) {
1118 cl_queue_properties props[] = { CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0 };
1119 cq = clCreateCommandQueueWithProperties(ctx, (*d).my_cl_device_id, props, &err2);
1121 cl_queue_properties props[] = { 0 };
1122 cq = clCreateCommandQueueWithProperties(ctx, (*d).my_cl_device_id, props, &err2);
1127 cl_command_queue_properties props = (*d).out_of_order_exec_mode_on_host_present() ? CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE : 0;
1129 #if __TBB_GCC_WARNING_SUPPRESSION_PRESENT 1130 #pragma GCC diagnostic push 1131 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 1133 #if _MSC_VER || __INTEL_COMPILER 1134 #pragma warning( push ) 1135 #if __INTEL_COMPILER 1136 #pragma warning (disable: 1478) 1138 #pragma warning (disable: 4996) 1141 cq = clCreateCommandQueue(ctx, (*d).my_cl_device_id, props, &err2);
1142 #if _MSC_VER || __INTEL_COMPILER 1143 #pragma warning( pop ) 1145 #if __TBB_GCC_WARNING_SUPPRESSION_PRESENT 1146 #pragma GCC diagnostic pop 1150 (*d).my_cl_command_queue = cq;
1160 template <
typename Factory>
1162 template <
typename Factory>
1164 template <
typename Factory>
1169 namespace opencl_info {
1173 template <
typename Factory>
1176 __TBB_ASSERT(!f.devices().empty(),
"No available devices");
1177 return *(f.devices().begin());
1184 cl_platform_id platform_id = devices.
begin()->platform_id();
1186 if (it->platform_id() == platform_id) {
1211 template <
typename T,
typename Factory>
1221 template <
typename Factory = opencl_info::default_opencl_factory>
1253 cl_kernel kernel = clCreateKernel(
my_cl_program, k.c_str(), &err );
1261 std::ifstream file_descriptor( filepath, std::ifstream::binary );
1262 if ( !file_descriptor.is_open() ) {
1263 std::string str = std::string(
"Could not open file: " ) + filepath;
1264 std::cerr << str << std::endl;
1267 file_descriptor.seekg( 0, file_descriptor.end );
1268 size_t length = size_t( file_descriptor.tellg() );
1269 file_descriptor.seekg( 0, file_descriptor.beg );
1273 file_descriptor.close();
1285 cl_uint num_devices, cl_device_id* device_list,
1288 cl_int err = clBuildProgram( program, num_devices, device_list, options,
1290 if( err == CL_SUCCESS )
1292 std::string str = std::string(
"Failed to build program: " ) +
name;
1293 if ( err == CL_BUILD_PROGRAM_FAILURE ) {
1295 for (
auto d = devices.
begin();
d != devices.
end(); ++
d ) {
1296 std::cerr <<
"Build log for device: " << (*d).name() << std::endl;
1298 cl_int query_err = clGetProgramBuildInfo(
1299 program, (*d).my_cl_device_id, CL_PROGRAM_BUILD_LOG, 0, NULL,
1303 std::vector<char> output;
1304 output.resize( log_size );
1305 query_err = clGetProgramBuildInfo(
1306 program, (*d).my_cl_device_id, CL_PROGRAM_BUILD_LOG,
1307 output.size(), output.data(), NULL );
1309 std::cerr << output.data() << std::endl;
1311 std::cerr <<
"No build log available" << std::endl;
1321 template<
typename Filter>
1323 Filter
filter,
const char* message ) {
1324 for ( cl_uint i = 0; i < num_devices; ++i )
1325 if (
filter(device_list[i]) ) {
1326 device_list[i--] = device_list[--num_devices];
1333 void init(
const std::string& )
const {
1334 cl_uint num_devices;
1336 "Failed to get OpenCL context info" );
1339 cl_device_id *device_list = (cl_device_id *)alloca( num_devices*
sizeof( cl_device_id ) );
1340 enforce_cl_retcode( clGetContextInfo(
my_factory.context(), CL_CONTEXT_DEVICES, num_devices*
sizeof( cl_device_id ), device_list, NULL ),
1341 "Failed to get OpenCL context info" );
1342 const char *options = NULL;
1346 const char *
s[] = { fr.
content() };
1347 const size_t l[] = { fr.
length() };
1352 num_devices, device_list,
1354 return !
d.compiler_available() || !
d.linker_available();
1355 },
"No one device supports building program from sources" );
1358 options, NULL, NULL );
1362 options =
"-x spir";
1365 std::vector<const unsigned char*>
s(
1366 num_devices, reinterpret_cast<const unsigned char*>(fr.
content()) );
1367 std::vector<size_t> l( num_devices, fr.
length() );
1368 std::vector<cl_int> bin_statuses( num_devices, -1 );
1371 device_list, l.data(),
s.data(),
1372 bin_statuses.data(), &err );
1373 if( err != CL_SUCCESS ) {
1374 std::string statuses_str;
1375 for (
auto st = bin_statuses.begin(); st != bin_statuses.end(); ++st) {
1376 statuses_str += std::to_string((*st));
1380 std::string(
", binary_statuses = " ) + statuses_str );
1384 options, NULL, NULL );
1398 template <
typename DeviceFilter>
1401 template <
typename DeviceFilter>
1405 template<typename... Args>
1408 template<typename JP, typename Factory, typename... Ports>
1415 :
base_type( g, kernel, opencl_info::default_device_selector< opencl_info::default_opencl_factory >(), opencl_info::
default_factory() )
1421 :
base_type( g, kernel, opencl_info::default_device_selector <Factory >(), f )
1426 template <
typename DeviceSelector>
1434 template<
typename JP,
typename... Ports>
1441 :
base_type( g, kernel, opencl_info::default_device_selector< opencl_info::default_opencl_factory >(), opencl_info::
default_factory() )
1444 template <
typename DeviceSelector>
1450 template<
typename... Ports>
1451 class opencl_node< tuple<Ports...> > :
public opencl_node < tuple<Ports...>, queueing, opencl_info::default_opencl_factory > {
1457 :
base_type( g, kernel, opencl_info::default_device_selector< opencl_info::default_opencl_factory >(), opencl_info::
default_factory() )
1460 template <
typename DeviceSelector>
1468 using interface10::opencl_node;
1472 using interface10::opencl_buffer;
1473 using interface10::opencl_subbuffer;
1474 using interface10::opencl_device;
1475 using interface10::opencl_device_list;
1476 using interface10::opencl_program;
1478 using interface10::opencl_async_msg;
1479 using interface10::opencl_factory;
1480 using interface10::opencl_range;
1486 #endif // __TBB_flow_graph_opencl_node_H bool get_event_from_one_arg(cl_event &, const T &)
opencl_node(graph &g, const kernel_type &kernel, Factory &f)
opencl_range(G &&global_work=std::initializer_list< int >({ 0 }), L &&local_work=std::initializer_list< int >({ 0, 0, 0 }))
opencl_device(cl_device_id cl_d_id, device_id_type device_id)
nd_range_type my_global_work_size
void map_memory(opencl_device device, opencl_async_msg< void *, Factory > &dmsg) __TBB_override
opencl_node(graph &g, const kernel_type &kernel)
opencl_node(graph &g, const kernel_type &kernel, DeviceSelector d)
std::enable_if< is_memory_object_type< T >::value >::type send_if_memory_object(opencl_device device, opencl_async_msg< T, Factory > &dmsg)
opencl_program(const std::string &program_name)
cl_mem native_object() const
void receive(const opencl_async_msg< opencl_buffer, Factory > &dependency) const
bool extension_available(const std::string &ext) const
default_opencl_factory()=default
std::string extensions() const
Factory opencl_factory_type
opencl_program(Factory &factory, const std::string &program_name)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type size_t void ITT_FORMAT p const __itt_domain __itt_id __itt_string_handle const wchar_t size_t ITT_FORMAT lu const __itt_domain __itt_id __itt_relation __itt_id ITT_FORMAT p const wchar_t int ITT_FORMAT __itt_group_mark d __itt_event event
iterator< a > end() const
#define __TBB_STATIC_ASSERT(condition, msg)
tbb::atomic< opencl_device::device_id_type > my_curr_device_id
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
friend bool operator==(opencl_device d1, opencl_device d2)
cl_device_id device_id() const
opencl_node< tuple< Ports... >, JP, opencl_info::default_opencl_factory > base_type
cl_bool compiler_available() const
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type size_t void ITT_FORMAT p const __itt_domain __itt_id __itt_string_handle const wchar_t size_t ITT_FORMAT lu const __itt_domain __itt_id __itt_relation __itt_id ITT_FORMAT p const wchar_t int ITT_FORMAT __itt_group_mark d __itt_event ITT_FORMAT __itt_group_mark d void const wchar_t const wchar_t int ITT_FORMAT __itt_group_sync __itt_group_fsync x void const wchar_t int const wchar_t int int ITT_FORMAT __itt_group_sync __itt_group_fsync x void ITT_FORMAT __itt_group_sync __itt_group_fsync p void ITT_FORMAT __itt_group_sync __itt_group_fsync p void size_t ITT_FORMAT lu no args __itt_obj_prop_t __itt_obj_state_t ITT_FORMAT d const char ITT_FORMAT s __itt_frame ITT_FORMAT p const char const char ITT_FORMAT s __itt_counter ITT_FORMAT p __itt_counter unsigned long long ITT_FORMAT lu const wchar_t ITT_FORMAT S __itt_mark_type const wchar_t ITT_FORMAT S __itt_mark_type const char ITT_FORMAT s __itt_mark_type ITT_FORMAT d __itt_caller ITT_FORMAT p __itt_caller ITT_FORMAT p no args const __itt_domain __itt_clock_domain unsigned long long __itt_id ITT_FORMAT lu const __itt_domain __itt_clock_domain unsigned long long __itt_id __itt_id void * fn
void finalize() const __TBB_override
T device_info(cl_device_id d, cl_device_info i)
void process_arg_list(const kernel_type &kernel, std::array< cl_event, NUM_ARGS > &events, int &num_events, int &place, const T &t, const Rest &... args)
file_reader(const std::string &filepath)
base_type::kernel_type kernel_type
cl_event send_kernel_impl(opencl_device device, const cl_kernel &kernel, const range_type &work_size, cl_uint num_events, cl_event *event_list)
opencl_device_list my_devices
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp begin
void update_one_arg(cl_event, T &)
device_id_type my_device_id
void suppress_unused_warning(const T1 &)
Utility template function to prevent "unused" warnings by various compilers.
std::string platform_extensions() const
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d
Factory::kernel_type kernel_type
opencl_device_list operator()(const opencl_device_list &devices)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type type
opencl_program(Factory &factory, cl_program program)
Base class for types that should not be copied or assigned.
opencl_async_msg< void *, Factory > receive(const cl_event *e)
K key_from_message(const T &t)
bool get_event_from_args(cl_event &)
cl_event my_sending_event
factory_type & my_factory
std::array< size_t, 3 > max_work_item_sizes() const
opencl_node(graph &g, const kernel_type &kernel, DeviceSelector d)
opencl_buffer_impl(cl_mem m, size_t index, size_t size, Factory &f)
opencl_async_msg(const T &data, cl_event event)
void process_one_arg(const kernel_type &kernel, std::array< cl_event, NUM_ARGS > &events, int &num_events, int &place, const opencl_async_msg< T, F > &msg)
cl_bool available() const
void register_callback(Callback c) const
opencl_program(opencl_program_type type)
void enqueue_map_buffer(opencl_device device, opencl_buffer_impl< Factory > &buffer, opencl_async_msg< void *, Factory > &dmsg)
T platform_info(cl_platform_id p, cl_platform_info i)
bool out_of_order_exec_mode_on_device_present() const
void add(opencl_device d)
tbb::spin_mutex my_devices_mutex
opencl_async_msg(const T &data)
bool init(const opencl_device_list &device_list)
const nd_range_type & local_range() const
static void CL_CALLBACK finalize_callback(cl_event, cl_int event_command_exec_status, void *data)
opencl_program(Factory &factory, const char *program_name)
is_typedef(native_object_type)
void const char const char int ITT_FORMAT __itt_group_sync p
cl_device_id my_cl_device_id
A lock that occupies a single byte.
const opencl_buffer & memory_object() const
bool is_same_context(opencl_device::device_id_type d1, opencl_device::device_id_type d2)
Base class for types that should not be assigned.
bool get_event_from_args(cl_event &e, const T &t, const Rest &... args)
opencl_factory< DeviceFilter > factory_type
default_opencl_factory & default_factory()
std::enable_if< is_native_object_type< T >::value, typename T::native_object_type >::type get_native_object(const T &t)
cl_uint address_bits() const
void process_one_arg(const kernel_type &kernel, std::array< cl_event, NUM_ARGS > &, int &, int &place, const T &t)
friend default_opencl_factory & default_factory()
opencl_program_type my_type
iterator< a > access() const
cl_platform_id platform_id() const
opencl_program(const opencl_program &src)
void info(cl_device_info i, T &t) const
opencl_subbuffer(const opencl_buffer< T, Factory > &owner, size_t index, size_t size)
kernel_type get_kernel(const std::string &k) const
void update_one_arg(cl_event e, opencl_async_msg< T, F > &msg)
virtual void operator()()
int minor_version() const
void enqueue_unmap_buffer(opencl_device device, opencl_memory< Factory > &memory, opencl_async_msg< void *, Factory > &dmsg)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void * lock
void send_data(opencl_device device, T &t, Rest &... args)
opencl_device_list find_available_devices()
opencl_async_msg(opencl_async_msg &&dmsg)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type size_t void * data
void set_command_queue(cl_command_queue cmd_queue)
void process_arg_list(const kernel_type &, std::array< cl_event, NUM_ARGS > &, int &, int &)
std::string platform_profile() const
const_iterator cbegin() const
cl_command_queue my_cl_command_queue
base_type::kernel_type kernel_type
cl_command_queue command_queue() const
container_type::const_iterator const_iterator
opencl_node(graph &g, const kernel_type &kernel)
static void fgt_multiinput_multioutput_node(string_index, void *, void *)
std::once_flag my_do_once_flag
void set_event(cl_event e) const
streaming_node< tuple< Ports... >, JP, Factory > base_type
void init(const std::string &) const
const_iterator end() const
void enforce_cl_retcode(cl_int err, std::string msg)
bool built_in_kernel_available(const std::string &k) const
opencl_buffer_impl< Factory > impl_type
bool out_of_order_exec_mode_on_host_present() const
Represents acquisition of a mutex.
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
opencl_program(Factory &factory, opencl_program_type type, const std::string &program_name)
bool get_event_from_one_arg(cl_event &e, const opencl_async_msg< T, F > &msg)
container_type my_container
int major_version() const
std::string platform_version() const
cl_kernel get_cl_kernel(const std::string &k) const
std::string version() const
opencl_node(graph &g, const kernel_type &kernel)
opencl_device operator()(Factory &f)
static void CL_CALLBACK register_callback_func(cl_event, cl_int event_command_exec_status, void *data)
const_iterator begin() const
opencl_memory(Factory &f)
bool my_sending_event_present
base_type::kernel_type kernel_type
cl_mem get_cl_mem() const
opencl_node(graph &g, const kernel_type &kernel, DeviceSelector d, Factory &f)
K key_from_message(const opencl_async_msg< T, Factory > &dmsg)
void move(tbb_thread &t1, tbb_thread &t2)
std::vector< opencl_device > container_type
const opencl_device_list & available_devices()
virtual void map_memory(opencl_device, opencl_async_msg< void *, Factory > &)=0
void call() __TBB_override
Primary template for atomic.
void const char const char int ITT_FORMAT __itt_group_sync s
opencl_device device_type
T event_info(cl_event e, cl_event_info i)
const nd_range_type & global_range() const
void operator()() __TBB_override
void update_arg_list(cl_event e, T &t, Rest &... args)
std::shared_ptr< impl_type > my_impl
cl_mem native_object_type
void send_kernel(opencl_device device, const kernel_type &kernel, const range_type &work_size, Args &... args)
Factory * factory() const
std::string built_in_kernels() const
void send(opencl_device device, opencl_async_msg< opencl_buffer, Factory > &dependency) const
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t size
T & operator[](ptrdiff_t k)
nd_range_type my_local_work_size
iterator< a > begin() const
opencl_subbuffer< T, Factory > subbuffer(size_t index, size_t size) const
void finalize(opencl_device device, FinalizeFn fn, Args &... args)
void(CL_CALLBACK * cl_callback_type)(cl_program, void *)
std::string platform_vendor() const
opencl_program(const char *program_name)
tbb::spin_mutex my_sending_lock
callback(Callback c, const T &t)
std::string vendor() const
std::shared_ptr< tbb::atomic< bool > > my_callback_flag_ptr
opencl_async_msg< void *, Factory > send(opencl_device device, const cl_event *e)
The graph related classes and functions.
opencl_program(opencl_program_type type, const std::string &program_name)
opencl_buffer_impl(size_t size, Factory &f)
const_iterator cend() const
opencl_buffer(Factory &f, size_t size)
opencl_async_msg(const opencl_async_msg &dmsg)
size_t max_work_group_size() const
opencl_device_list(std::initializer_list< opencl_device > il)
opencl_async_msg & operator=(const opencl_async_msg &dmsg)
std::enable_if< is_memory_object_type< T >::value >::type receive_if_memory_object(const opencl_async_msg< T, Factory > &dmsg)
friend bool operator==(const opencl_buffer< T, Factory > &lhs, const opencl_buffer< T, Factory > &rhs)
opencl_factory & operator=(const opencl_factory &)
void store(value_type value)
std::once_flag my_once_flag
container_type::size_type size_type
const opencl_device_list & devices()
const T & data(bool wait=true) const
std::string platform_name() const
void const char const char int ITT_FORMAT __itt_group_sync x void const char * name
opencl_buffer(Factory &f, cl_mem m, size_t index, size_t size)
container_type::iterator iterator
cl_bool linker_available() const
opencl_program_builder(Factory &f, const std::string &name, cl_program program, cl_uint num_devices, cl_device_id *device_list, const char *options, cl_callback_type callback, void *user_data)
void send_data(opencl_device)
void update_arg_list(cl_event)
kernel(const cl_kernel &k, factory_type &f)
opencl_buffer memory_object_type
opencl_node< tuple< Ports... >, queueing, opencl_info::default_opencl_factory > base_type
cl_event const * get_event() const
opencl_device(cl_device_id d_id)
std::array< range_index_type, 3 > nd_range_type
opencl_device_filter(cl_uint &num_devices, cl_device_id *device_list, Filter filter, const char *message)
cl_device_type type() const
opencl_buffer< T, Factory > my_owner