#include <vector_device.h>
|  | 
|  | vector_device () | 
|  | 
|  | vector_device (const Size n) | 
|  | 
|  | vector_device (const vector_device< T, MemoryManager, DataTypeInfoManager > &v) | 
|  | 
|  | vector_device (const std::initializer_list< T > &t) | 
|  | 
| bool | isHostValid () const | 
|  | 
| bool | isDeviceValid (unsigned gpu) const | 
|  | 
| void | clear () | 
|  | 
| void | operator= (const vector_device< T, MemoryManager, DataTypeInfoManager > &v) | 
|  | 
|  | ~vector_device () | 
|  | 
| Size | size () const | 
|  | 
| Size | capacity () const | 
|  | 
| bool | empty () const | 
|  | 
| void | reserve (Size s, Size WARP_SIZE=MemoryManager::BSIZE) | 
|  | 
| void | fastResize (Size s, Size WARP_SIZE=MemoryManager::BSIZE) | 
|  | resize the vector without calling constructors or destructors, and without synchronizing the device and host copy  More... 
 | 
|  | 
| void | recreate (Size s, Size WARP_SIZE=MemoryManager::BSIZE) | 
|  | resize the vector discarding any old values, without calling constructors or destructors, and without synchronizing the device and host copy  More... 
 | 
|  | 
| void | invalidateDevice () | 
|  | 
| void | invalidateHost () | 
|  | 
| void | memsetDevice (int v=0) | 
|  | 
| void | memsetHost (int v=0) | 
|  | 
| void | resize (Size s, Size WARP_SIZE=MemoryManager::BSIZE) | 
|  | 
| void | swap (vector_device< T, MemoryManager, DataTypeInfoManager > &v) | 
|  | 
| const device_pointer | deviceReadAt (int i, int gpu=MemoryManager::getBufferDevice()) const | 
|  | 
| const device_pointer | deviceRead (int gpu=MemoryManager::getBufferDevice()) const | 
|  | 
| device_pointer | deviceWriteAt (int i, int gpu=MemoryManager::getBufferDevice()) | 
|  | 
| device_pointer | deviceWrite (int gpu=MemoryManager::getBufferDevice()) | 
|  | 
| const T * | hostRead () const | 
|  | 
| T * | hostWrite () | 
|  | 
| const T * | hostReadAt (int i) const | 
|  | 
| T * | hostWriteAt (int i) | 
|  | 
| buffer_id_type | bufferRead (bool create=false) | 
|  | Get the Buffer Object ID for reading.  More... 
 | 
|  | 
| buffer_id_type | bufferWrite (bool create=false) | 
|  | Get the Buffer Object ID for writing.  More... 
 | 
|  | 
| void | push_back (const T &t) | 
|  | 
| void | pop_back () | 
|  | 
| const T & | operator[] (Size i) const | 
|  | 
| T & | operator[] (Size i) | 
|  | 
| const T * | data () const | 
|  | 
| T * | data () | 
|  | 
| const T & | getCached (Size i) const | 
|  | 
| const T & | getSingle (Size i) const | 
|  | 
| const_iterator | begin () const | 
|  | 
| const_iterator | end () const | 
|  | 
| iterator | begin () | 
|  | 
| iterator | end () | 
|  | 
| iterator | erase (iterator position) | 
|  | 
| iterator | insert (iterator position, const T &x) | 
|  | 
◆ allocSize
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ bufferIsRegistered
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
True if the buffer is registered with CUDA. 
 
 
◆ bufferObject
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
Optional associated buffer ID. 
 
 
◆ clearSize
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
when initializing missing device data, up to where entries should be set to zero ? 
 
 
◆ cptid
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ deviceAllocSize
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
Allocated size on each device. 
 
 
◆ deviceIsValid
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
True if the data on the GPU is currently valid (up to the given deviceVectorSize of each device, i.e. additional space may need to be allocated and/or initialized) 
 
 
◆ devicePointer
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
Pointer to the data on the GPU side. 
 
 
◆ deviceVectorSize
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
Initialized size on each device. 
 
 
◆ hostIsValid
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
True if the data on the CPU is currently valid. 
 
 
◆ hostPointer
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
Pointer to the data on the CPU side. 
 
 
◆ vectorSize
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
Current size of the vector. 
 
 
◆ vector_device() [1/4]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ vector_device() [2/4]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ vector_device() [3/4]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ vector_device() [4/4]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ ~vector_device()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ allocate()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ begin() [1/2]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ begin() [2/2]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ bufferRead()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
Get the Buffer Object ID for reading. 
 
 
◆ bufferWrite()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
Get the Buffer Object ID for writing. 
 
 
◆ capacity()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ checkIndex()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ clear()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ copyToDevice()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ copyToHost()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ copyToHostSingle()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ createBuffer()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ data() [1/2]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ data() [2/2]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ deviceRead()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ deviceReadAt()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ deviceWrite()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ deviceWriteAt()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ empty()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ end() [1/2]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ end() [2/2]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ erase()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ fastResize()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
resize the vector without calling constructors or destructors, and without synchronizing the device and host copy 
 
 
◆ getCached()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ getSingle()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ hostRead()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ hostReadAt()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ hostWrite()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ hostWriteAt()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ insert()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ invalidateDevice()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ invalidateHost()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ isDeviceValid()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ isHostValid()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ mapBuffer()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ memsetDevice()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ memsetHost()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ operator=()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ operator[]() [1/2]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ operator[]() [2/2]
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ pop_back()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ push_back()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ recreate()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
resize the vector discarding any old values, without calling constructors or destructors, and without synchronizing the device and host copy 
 
 
◆ registerBuffer()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ reserve()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ resize()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ size()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ swap()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ unmapBuffer()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ unregisterBuffer()
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ anonymous enum
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
| Enumerator | 
|---|
| ALL_DEVICE_VALID |  | 
 
 
◆ operator<<
template<class T , class MemoryManager , class DataTypeInfoManager > 
 
 
◆ operator>>
template<class T , class MemoryManager , class DataTypeInfoManager >