cuda::experimental::stf::logical_data#

template<class T>
class logical_data : public cuda::experimental::stf::logical_data_untyped#

Represents typed logical data.

Template Parameters:

T – The type of the underlying data.

Execution place getter

inline const shape_t &shape() const#

Instance getter for a given instance or the default instance

inline decltype(auto) instance(instance_id_t instance_id)#
inline decltype(auto) instance(task &tp)#

Assign a symbolic name for this object

inline logical_data &set_symbol(::std::string str)#

Select a custom allocator for this logical data

inline logical_data &set_allocator(
block_allocator_untyped custom_allocator,
)#

Get hash value

inline size_t hash() const#

Return a task_dep<T> object for reading and/or writing this logical data.

tparam Pack:

Additional parameter types for task_dep<T>’s constructor, if any

param pack:

Additional arguments for task_dep<T>’s constructor, if any

return:

task_dep<T> The object encapsulating access

template<typename ...Pack>
inline auto read(Pack&&... pack) const#
template<typename ...Pack>
inline auto write(Pack&&... pack)#
template<typename ...Pack>
inline auto rw(Pack&&... pack)#
template<typename ...Pack>
inline auto relaxed(Pack&&... pack)#
template<typename Op, typename ...Pack>
inline auto reduce(
Op,
no_init,
Pack&&... pack,
)#
template<typename Op, typename ...Pack>
inline auto reduce(
Op,
Pack&&... pack,
)#

Symbol getter/setter

inline const ::std::string &get_symbol() const#

Data interface getter

inline const data_interface &get_data_interface() const#

Get common data associated with this object. The type must be user-specified and is checked dynamically.

tparam T:

the type of common data, must be user-specified

template<typename T>
inline const T &common() const#

Retrieves the physical data from this logical data for a given instance id

template<typename T>
inline decltype(auto) instance(
instance_id_t instance_id,
) const#

Retrieves the physical data from this logical data for the default instance

template<typename T>
inline decltype(auto) instance(task &tp) const#

Get the data pace associated with a given instance

inline const data_instance &get_data_instance(
instance_id_t instance_id,
) const#
inline data_instance &get_data_instance(instance_id_t instance_id)#

Reference count query and manipulation

inline bool has_ref() const#
inline void add_ref()#
inline void remove_ref()#

Returns a dependency object for read/write/read and write access to this logical data.

return:

task_dep_untyped The dependency object corresponding to this logical data

inline task_dep_untyped read(data_place dp = data_place::affine())#
inline task_dep_untyped write(data_place dp = data_place::affine())#
inline task_dep_untyped rw(data_place dp = data_place::affine())#
inline task_dep_untyped relaxed(
::std::shared_ptr<reduction_operator_base> op,
data_place dp = data_place::affine(),
)#

Public Types

using element_type = T#

Alias for T

using shape_t = shape_of<T>#

Alias for shape_of<T>

Public Functions

logical_data() = default#

Default constructor.

inline logical_data(logical_data_untyped &&u)#

Constructor from an untyped logical data.

Warning : no checks are done to ensure the type used to create the untyped logical data matches, it is the responsibility of the caller to ensure this is a valid conversion

template<typename U>
inline logical_data(
backend_ctx_untyped ctx,
::std::shared_ptr<U> instance,
data_place dp,
)#

Constructor.

Template Parameters:

U – Backend type

Parameters:

  • ctx – Backend context

  • instance – Reference instance used for initializing this logical data

  • dp – Data place

  • data_prereq –

inline void freeze(
access_mode freeze_mode,
data_place place = data_place::invalid(),
)#
template<typename T>
inline ::std::pair<T, event_list> get_frozen(
task &fake_task,
const data_place &dplace,
access_mode m,
)#
inline void unfreeze(
task &fake_task,
event_list prereqs = event_list(),
)#
inline void set_automatic_unfreeze(
task &unfreeze_fake_task_,
bool flag,
)#
inline ::std::pair<bool, access_mode> is_frozen() const#

Indicates whether a logical data is frozen or not, and what is the corresponding mode.

inline void allocate(
const data_place &memory_node,
instance_id_t instance_id,
::std::ptrdiff_t &s,
void **extra_args,
event_list &prereqs,
)#

Allocate memory for this logical data.

Parameters:

  • ctx –

  • memory_node –

  • instance_id –

  • s –

  • extra_args –

  • prereqs –

inline void deallocate(
const data_place &memory_node,
instance_id_t instance_id,
void *extra_args,
event_list &prereqs,
)#

Deallocate memory previously allocated with allocate

Parameters:

  • ctx –

  • memory_node –

  • instance_id –

  • extra_args –

  • prereqs –

inline void data_copy(
const data_place &dst_node,
instance_id_t dst_instance_id,
const data_place &src_node,
instance_id_t src_instance_id,
event_list &prereqs,
)#

Copy data.

Parameters:

  • ctx –

  • dst_node –

  • dst_instance_id –

  • src_node –

  • src_instance_id –

  • arg –

  • prereqs –

inline void write_back(
const data_place &src_node,
instance_id_t instance_id,
event_list &prereqs,
)#

Writes back data.

Parameters:

  • ctx –

  • src_node –

  • instance_id –

  • prereqs –

inline instance_id_t find_unused_instance_id(
const data_place &dplace,
)#

Get the index of the first available instance_id.

Parameters:

dplace –

Returns:

The found instance_id

inline instance_id_t find_instance_id(const data_place &dplace)#

Get the index of the first used instance_id that matches the data place, or get a new one.

Parameters:

dplace –

Returns:

The found instance_id

inline void release_instance_id(instance_id_t instance_id)#

Make it possible to reuse an id.

Parameters:

instance_id –

inline const data_place &get_instance_dplace(
instance_id_t instance_id,
) const#

Get the data pace associated with a given instance.

Parameters:

instance_id –

Returns:

const data_place&

inline bool has_interface() const#

Returns true if the data interface of this object has been set.

inline bool is_void_interface() const#

Returns true if the data is a void data interface.

inline void apply_redux_op(
const data_place &memory_node,
const exec_place &e_place,
instance_id_t inout_instance_id,
instance_id_t in_instance_id,
event_list &prereqs,
)#
inline void apply_redux_on_node(
const data_place &memory_node,
const exec_place &e_place,
::std::vector<instance_id_t> &ids,
event_list &prereqs,
)#
inline void reconstruct_after_redux(
backend_ctx_untyped &bctx,
instance_id_t instance_id,
const exec_place &e_place,
event_list &prereqs,
)#
inline size_t get_data_instance_count() const#
inline void enforce_msi_protocol(
instance_id_t instance_id,
access_mode mode,
event_list &prereqs,
)#
inline instance_id_t find_source_instance_id(
instance_id_t dst_instance_id,
)#
inline void set_write_back(bool flag)#
inline void set_auto_dump(bool flag)#
inline bool get_auto_dump() const#
inline reserved::logical_data_state &get_state()#
inline auto &get_ctx() const#
inline bool is_initialized() const#
inline bool operator==(const logical_data_untyped &other) const#
inline auto &get_mutex()#