#include <taskflow/cuda/cuda_memory.hpp>
          template<typename T>
          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::
Public types
- 
              template<typename U>struct rebind
- its member type Uis 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>
              
              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::
            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::
              
                template<typename T>
              
              void tf::
            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_
            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::
            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>
                template<typename U>
              
              bool tf::
            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::
            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.