#
#include <taskflow/cuda/cuda_memory.hpp>
template<typename T>
tf::cudaUSMAllocator class

class to create a unified shared memory (USM) allocator

Template parameters
T | element type

A cudaUSMAllocator enables using unified shared memory (USM) allocation for standard library containers. It is typically passed as template parameter when declaring standard library containers (e.g. std::vector).

## Public types

template<typename U>
struct rebind
  its member type `U` is the equivalent allocator type to allocate elements of type U
using value_type = T
  element type
using pointer = T*
  element pointer type
using reference = T&
  element reference type
using const_pointer = const T*
  const element pointer type
using const_reference = const T&
  constant element reference type
using size_type = std::size_t
  size type
using difference_type = std::ptrdiff_t
  pointer difference type

## Constructors, destructors, conversion operators

cudaUSMAllocator() noexcept
  Constructs a device allocator object.
cudaUSMAllocator(const cudaUSMAllocator&) noexcept
  Constructs a device allocator object from another device allocator object.
template<typename U>
cudaUSMAllocator(const cudaUSMAllocator<U>&) noexcept
  Constructs a device allocator object from another device allocator object with a different element type.
~cudaUSMAllocator() noexcept
  Destructs the device allocator object.

## Public functions

auto address( reference x) -> pointer
  Returns the address of x.
auto address( const_reference x) const -> const_pointer
  Returns the address of x.
auto allocate( size_type n, const void* = 0) -> pointer
  allocates block of storage.
void deallocate( pointer ptr, size_type)
  Releases a block of storage previously allocated with member allocate and not yet released.
auto max_size() const -> size_type noexcept
  returns the maximum number of elements that could potentially be allocated by this allocator
void construct( pointer ptr, const_reference val)
  Constructs an element object on the location pointed by ptr.
void destroy( pointer ptr)
  destroys in-place the object pointed by `ptr`
template<typename U>
auto operator==(const cudaUSMAllocator<U>&) const -> bool noexcept
  compares two allocator of different types using `==`
template<typename U>
auto operator!=(const cudaUSMAllocator<U>&) const -> bool noexcept
  compares two allocator of different types using `!=`

## Function documentation

###
template<typename T>
pointer tf::cudaUSMAllocator<T>:: address( reference x)

Returns the address of x.

Parameters
x | reference to an object
Returns | a pointer to the object

This effectively means returning &x.

###
template<typename T>
const_pointer tf::cudaUSMAllocator<T>:: address( const_reference x) const

Returns the address of x.

Parameters
x | reference to an object
Returns | a pointer to the object

This effectively means returning &x.

###
template<typename T>
pointer tf::cudaUSMAllocator<T>:: allocate( size_type n, const void* = 0)

allocates block of storage.

Parameters
n | number of elements (each of size sizeof(value_type)) to be allocated
Returns | a pointer to the initial element in the block of storage.

Attempts to allocate a block of storage with a size large enough to contain `n` elements of member type, `value_type`, and returns a pointer to the first element.

The storage is aligned appropriately for object of type `value_type`, but they are not constructed.

The block of storage is allocated using cudaMalloc and throws std::bad_alloc if it cannot allocate the total amount of storage requested.

###
template<typename T>
void tf::cudaUSMAllocator<T>:: deallocate( pointer ptr, size_type)

Releases a block of storage previously allocated with member allocate and not yet released.

Parameters
ptr | pointer to a block of storage previously allocated with allocate

The elements in the array are not destroyed by a call to this member function.

###
template<typename T>
size_type tf::cudaUSMAllocator<T>:: max_size() const noexcept

returns the maximum number of elements that could potentially be allocated by this allocator

Returns | the number of elements that might be allocated as maximum by a call to member allocate

A call to member allocate with the value returned by this function can still fail to allocate the requested storage.

###
template<typename T>
void tf::cudaUSMAllocator<T>:: construct( pointer ptr, const_reference val)

Constructs an element object on the location pointed by ptr.

Parameters
ptr | pointer to a location with enough storage soace to contain an element of type `value_type`
val | value to initialize the constructed element to

###
template<typename T>
void tf::cudaUSMAllocator<T>:: destroy( pointer ptr)

destroys in-place the object pointed by `ptr`

Parameters
ptr | pointer to the object to be destroye

Notice that this does not deallocate the storage for the element but calls its destructor.

###
template<typename T> template<typename U>
bool tf::cudaUSMAllocator<T>:: operator==(const cudaUSMAllocator<U>&) const noexcept

compares two allocator of different types using `==`

USM allocators of different types are always equal to each other because the storage allocated by the allocator `a1` can be deallocated through `a2`.

###
template<typename T> template<typename U>
bool tf::cudaUSMAllocator<T>:: operator!=(const cudaUSMAllocator<U>&) const noexcept

compares two allocator of different types using `!=`

USM allocators of different types are always equal to each other because the storage allocated by the allocator `a1` can be deallocated through `a2`.

Tab / T to search, Esc to close
…

Search for symbols, directories, files, pages or modules. You can omit any prefix from the symbol or file path; adding a `:` or `/` suffix lists all members of given symbol or directory.

Use ↓ / ↑ to navigate through the list, Enter to go. Tab autocompletes common prefix, you can copy a link to the result using ⌘ L while ⌘ M produces a Markdown link.

Sorry, nothing was found.