#include <flow_graph_opencl_node.h>

Inheritance diagram for tbb::flow::interface11::opencl_memory< Factory >:

Collaboration diagram for tbb::flow::interface11::opencl_memory< Factory >:

Public Member Functions
	opencl_memory ()

	opencl_memory (Factory &f)

virtual	~opencl_memory ()

cl_mem	get_cl_mem () const

void *	get_host_ptr ()

Factory *	factory () const

opencl_async_msg< void *, Factory >	receive (const cl_event *e)

opencl_async_msg< void *, Factory >	send (opencl_device device, const cl_event *e)

virtual void	map_memory (opencl_device, opencl_async_msg< void *, Factory > &)=0

Protected Attributes
cl_mem	my_cl_mem

tbb::atomic< opencl_device::device_id_type >	my_curr_device_id

void *	my_host_ptr

Factory *	my_factory

tbb::spin_mutex	my_sending_lock

bool	my_sending_event_present

cl_event	my_sending_event

Detailed Description

template<typename Factory>
class tbb::flow::interface11::opencl_memory< Factory >

Definition at line 514 of file flow_graph_opencl_node.h.

Constructor & Destructor Documentation

◆ opencl_memory() [1/2]

template<typename Factory>

tbb::flow::interface11::opencl_memory< Factory >::opencl_memory ( )

inline

Definition at line 516 of file flow_graph_opencl_node.h.

516 {}

◆ opencl_memory() [2/2]

template<typename Factory>

tbb::flow::interface11::opencl_memory< Factory >::opencl_memory ( Factory & f )

inline

Definition at line 517 of file flow_graph_opencl_node.h.

                                 : my_host_ptr( NULL ), my_factory( &f ), my_sending_event_present( false ) {
         my_curr_device_id = my_factory->devices().begin()->my_device_id;
     }

References tbb::flow::interface11::opencl_memory< Factory >::my_curr_device_id, and tbb::flow::interface11::opencl_memory< Factory >::my_factory.

◆ ~opencl_memory()

template<typename Factory>

virtual tbb::flow::interface11::opencl_memory< Factory >::~opencl_memory ( )

inlinevirtual

Definition at line 521 of file flow_graph_opencl_node.h.

                              {
         if ( my_sending_event_present ) enforce_cl_retcode( clReleaseEvent( my_sending_event ), "Failed to release an event for the OpenCL buffer" );
         enforce_cl_retcode( clReleaseMemObject( my_cl_mem ), "Failed to release an memory object" );
     }

References tbb::flow::interface11::enforce_cl_retcode(), tbb::flow::interface11::opencl_memory< Factory >::my_cl_mem, tbb::flow::interface11::opencl_memory< Factory >::my_sending_event, and tbb::flow::interface11::opencl_memory< Factory >::my_sending_event_present.

Here is the call graph for this function:

Member Function Documentation

◆ factory()

template<typename Factory>

Factory* tbb::flow::interface11::opencl_memory< Factory >::factory ( ) const

inline

Definition at line 539 of file flow_graph_opencl_node.h.

539 { return my_factory; }

tbb::flow::interface11::opencl_memory::my_factory

Factory * my_factory

Definition: flow_graph_opencl_node.h:594

References tbb::flow::interface11::opencl_memory< Factory >::my_factory.

◆ get_cl_mem()

template<typename Factory>

cl_mem tbb::flow::interface11::opencl_memory< Factory >::get_cl_mem ( ) const

inline

Definition at line 526 of file flow_graph_opencl_node.h.

                               {
         return my_cl_mem;
     }

References tbb::flow::interface11::opencl_memory< Factory >::my_cl_mem.

Referenced by tbb::flow::interface11::opencl_factory< default_device_filter >::enqueue_map_buffer(), and tbb::flow::interface11::opencl_factory< default_device_filter >::enqueue_unmap_buffer().

Here is the caller graph for this function:

◆ get_host_ptr()

template<typename Factory>

void* tbb::flow::interface11::opencl_memory< Factory >::get_host_ptr ( )

inline

Definition at line 530 of file flow_graph_opencl_node.h.

                          {
         if ( !my_host_ptr ) {
             opencl_async_msg<void*, Factory> d = receive( NULL );
             d.data();
             __TBB_ASSERT( d.data() == my_host_ptr, NULL );
         }
         return my_host_ptr;
     }

References __TBB_ASSERT, d, tbb::flow::interface11::opencl_memory< Factory >::my_host_ptr, and tbb::flow::interface11::opencl_memory< Factory >::receive().

Referenced by tbb::flow::interface11::opencl_factory< default_device_filter >::enqueue_unmap_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ map_memory()

template<typename Factory>

virtual void tbb::flow::interface11::opencl_memory< Factory >::map_memory	(	opencl_device	,
		opencl_async_msg< void *, Factory > &
	)

pure virtual

Implemented in tbb::flow::interface11::opencl_buffer_impl< Factory >.

Referenced by tbb::flow::interface11::opencl_memory< Factory >::receive().

Here is the caller graph for this function:

◆ receive()

template<typename Factory>

opencl_async_msg<void*, Factory> tbb::flow::interface11::opencl_memory< Factory >::receive ( const cl_event * e )

inline

Definition at line 541 of file flow_graph_opencl_node.h.

                                                                 {
         opencl_async_msg<void*, Factory> d;
         if (e) {
             d = opencl_async_msg<void*, Factory>(my_host_ptr, *e);
         } else {
             d = opencl_async_msg<void*, Factory>(my_host_ptr);
         }
 
         // Concurrent receives are prohibited so we do not worry about synchronization.
         if (my_curr_device_id.load<tbb::relaxed>() != opencl_device::host) {
             map_memory(*my_factory->devices().begin(), d);
             my_curr_device_id.store<tbb::relaxed>(opencl_device::host);
             my_host_ptr = d.data(false);
         }
         // Release the sending event
         if (my_sending_event_present) {
             enforce_cl_retcode(clReleaseEvent(my_sending_event), "Failed to release an event");
             my_sending_event_present = false;
         }
         return d;
     }

References d, tbb::flow::interface11::enforce_cl_retcode(), tbb::flow::interface11::opencl_device::host, tbb::flow::interface11::opencl_memory< Factory >::map_memory(), tbb::flow::interface11::opencl_memory< Factory >::my_curr_device_id, tbb::flow::interface11::opencl_memory< Factory >::my_factory, tbb::flow::interface11::opencl_memory< Factory >::my_host_ptr, tbb::flow::interface11::opencl_memory< Factory >::my_sending_event, tbb::flow::interface11::opencl_memory< Factory >::my_sending_event_present, and tbb::relaxed.

Referenced by tbb::flow::interface11::opencl_memory< Factory >::get_host_ptr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send()

template<typename Factory>

opencl_async_msg<void*, Factory> tbb::flow::interface11::opencl_memory< Factory >::send	(	opencl_device	device,
		const cl_event *	e
	)

inline

Definition at line 563 of file flow_graph_opencl_node.h.

                                                                                    {
         opencl_device::device_id_type device_id = device.my_device_id;
         if (!my_factory->is_same_context(my_curr_device_id.load<tbb::acquire>(), device_id)) {
             {
                 tbb::spin_mutex::scoped_lock lock(my_sending_lock);
                 if (!my_factory->is_same_context(my_curr_device_id.load<tbb::relaxed>(), device_id)) {
                     __TBB_ASSERT(my_host_ptr, "The buffer has not been mapped");
                     opencl_async_msg<void*, Factory> d(my_host_ptr);
                     my_factory->enqueue_unmap_buffer(device, *this, d);
                     my_sending_event = *d.get_event();
                     my_sending_event_present = true;
                     enforce_cl_retcode(clRetainEvent(my_sending_event), "Failed to retain an event");
                     my_host_ptr = NULL;
                     my_curr_device_id.store<tbb::release>(device_id);
                 }
             }
             __TBB_ASSERT(my_sending_event_present, NULL);
         }
 
         // !e means that buffer has come from the host
         if (!e && my_sending_event_present) e = &my_sending_event;
 
         __TBB_ASSERT(!my_host_ptr, "The buffer has not been unmapped");
         return e ? opencl_async_msg<void*, Factory>(NULL, *e) : opencl_async_msg<void*, Factory>(NULL);
     }