OpenVDB 13.0.0

Loading...
Searching...
No Matches
HostBuffer Class Reference

This is a buffer that contains a shared or private pool to either externally or internally managed host memory. More...

`#include <nanovdb/HostBuffer.h>`

## Classes
struct | Pool

## Public Member Functions
| HostBuffer (uint64_t bufferSize=0)
| Return a full buffer or an empty buffer.
| HostBuffer (HostBuffer &&other)
| Move copy-constructor.
| ~HostBuffer ()
| Custom descructor.
HostBuffer & | operator= (HostBuffer &&other)
| Move copy assignment operation.
| HostBuffer (const HostBuffer &)=delete
| Disallow copy-construction.
HostBuffer & | operator= (const HostBuffer &)=delete
| Disallow copy assignment operation.
void | init (uint64_t bufferSize, void *data=nullptr)
| Initialize as a full buffer with the specified size. If data is NULL the memory is internally allocated.
const void * | data () const
| Retuns a pointer to the raw memory buffer managed by this allocator.
void * | data ()
template<typename T>
T * | data (ptrdiff_t count=0) const
| Returns an offset pointer of a specific type from the allocated host memory.
uint64_t | bufferSize () const
| Returns the size in bytes associated with this buffer.
uint64_t | size () const
uint64_t | poolSize () const
| Returns the size in bytes of the memory pool shared with this instance.
bool | isManaged () const
| Return true if memory is managed (using std::malloc and std:free) by the shared pool in this buffer. Else memory is assumed to be managed externally.
bool | isEmpty () const
| Returns true if this buffer has no memory associated with it.
bool | empty () const
bool | isPool () const
| Return true if this is a pool, i.e. an empty buffer with a nonempty internal pool, i.e. this->size() == 0 and this->poolSize() != 0.
bool | isFull () const
| Return true if the pool exists, is nonempty but has no more available memory.
void | clear ()
| Clear this buffer so it is empty.
void | reset ()
| Clears all existing buffers that are registered against the memory pool and resets the pool so it can be reused to create new buffers.
uint64_t | poolUsage () const
| Total number of bytes from the pool currently in use by buffers.
void | resizePool (uint64_t poolSize, void *data=nullptr)
| resize the pool size. It will attempt to resize the existing memory block, but if that fails a deep copy is performed. If `data` is not NULL it will be used as new externally managed memory for the pool. All registered buffers are updated so GridHandle::grid might return a new address (if deep copy was performed).

## Static Public Member Functions
static HostBuffer | createPool (uint64_t poolSize, void *data=nullptr)
| Return a pool buffer which satisfies: buffer.size == 0, buffer.poolSize() == poolSize, and buffer.data() == nullptr. If data==nullptr, memory for the pool will be allocated.
static HostBuffer | createFull (uint64_t bufferSize, void *data=nullptr)
| Return a full buffer which satisfies: buffer.size == bufferSize, buffer.poolSize() == bufferSize, and buffer.data() == data. If data==nullptr, memory for the pool will be allocated.
static HostBuffer | create (uint64_t bufferSize, const HostBuffer *pool=nullptr)
| Return a buffer with `bufferSize` bytes managed by the specified memory `pool`. If none is provided, i.e. `pool` == nullptr or `pool->poolSize()` == 0, one is created with size `bufferSize`, i.e. a full buffer is returned.

## Detailed Description

This is a buffer that contains a shared or private pool to either externally or internally managed host memory.

Note
  Terminology: Pool: 0 = buffer.size() < buffer.poolSize() Buffer: 0 < buffer.size() < buffer.poolSize() Full: 0 < buffer.size() = buffer.poolSize() Empty: 0 = buffer.size() = buffer.poolSize()

## Constructor & Destructor Documentation

## ◆ HostBuffer() [1/3]

HostBuffer | ( | uint64_t | bufferSize = 0 | ) |
| inline

Return a full buffer or an empty buffer.

## ◆ HostBuffer() [2/3]

HostBuffer | ( | HostBuffer && | other | ) |
| inline

Move copy-constructor.

## ◆ ~HostBuffer()

~HostBuffer | ( |  | ) |
| inline

Custom descructor.

## ◆ HostBuffer() [3/3]

HostBuffer | ( | const HostBuffer & |  | ) |
| delete

Disallow copy-construction.

## Member Function Documentation

## ◆ bufferSize()

uint64_t bufferSize | ( |  | ) | const
| inline

Returns the size in bytes associated with this buffer.

## ◆ clear()

void clear | ( |  | ) |
| inline

Clear this buffer so it is empty.

## ◆ create()

HostBuffer create | ( | uint64_t | bufferSize,
|  | const HostBuffer * | pool = nullptr )
| inline static

Return a buffer with `bufferSize` bytes managed by the specified memory `pool`. If none is provided, i.e. `pool` == nullptr or `pool->poolSize()` == 0, one is created with size `bufferSize`, i.e. a full buffer is returned.

Exceptions

  If | the specified `pool` has insufficient memory for the requested buffer size.

## ◆ createFull()

HostBuffer createFull | ( | uint64_t | bufferSize,
|  | void * | data = nullptr )
| inline static

Return a full buffer which satisfies: buffer.size == bufferSize, buffer.poolSize() == bufferSize, and buffer.data() == data. If data==nullptr, memory for the pool will be allocated.

Exceptions

  If | bufferSize is zero.

## ◆ createPool()

HostBuffer createPool | ( | uint64_t | poolSize,
|  | void * | data = nullptr )
| inline static

Return a pool buffer which satisfies: buffer.size == 0, buffer.poolSize() == poolSize, and buffer.data() == nullptr. If data==nullptr, memory for the pool will be allocated.

Exceptions

  If | poolSize is zero.

## ◆ data() [1/3]

void * data | ( |  | ) |
| inline

## ◆ data() [2/3]

const void * data | ( |  | ) | const
| inline

Retuns a pointer to the raw memory buffer managed by this allocator.

Warning
  Note that the pointer can be NULL if the allocator was not initialized!

## ◆ data() [3/3]

template<typename T>

T * data | ( | ptrdiff_t | count = 0 | ) | const
| inline

Returns an offset pointer of a specific type from the allocated host memory.

Template Parameters

  T | Type of the pointer returned

Parameters

  count | Numbers of elements of `parameter` type T to skip

Warning
  might return NULL

## ◆ empty()

bool empty | ( |  | ) | const
| inline

## ◆ init()

void init | ( | uint64_t | bufferSize,
|  | void * | data = nullptr )
| inline

Initialize as a full buffer with the specified size. If data is NULL the memory is internally allocated.

## ◆ isEmpty()

bool isEmpty | ( |  | ) | const
| inline

Returns true if this buffer has no memory associated with it.

## ◆ isFull()

bool isFull | ( |  | ) | const
| inline

Return true if the pool exists, is nonempty but has no more available memory.

## ◆ isManaged()

bool isManaged | ( |  | ) | const
| inline

Return true if memory is managed (using std::malloc and std:free) by the shared pool in this buffer. Else memory is assumed to be managed externally.

## ◆ isPool()

bool isPool | ( |  | ) | const
| inline

Return true if this is a pool, i.e. an empty buffer with a nonempty internal pool, i.e. this->size() == 0 and this->poolSize() != 0.

## ◆ operator=() [1/2]

HostBuffer & operator= | ( | const HostBuffer & |  | ) |
| delete

Disallow copy assignment operation.

## ◆ operator=() [2/2]

HostBuffer & operator= | ( | HostBuffer && | other | ) |
| inline

Move copy assignment operation.

## ◆ poolSize()

uint64_t poolSize | ( |  | ) | const
| inline

Returns the size in bytes of the memory pool shared with this instance.

## ◆ poolUsage()

uint64_t poolUsage | ( |  | ) | const
| inline

Total number of bytes from the pool currently in use by buffers.

## ◆ reset()

void reset | ( |  | ) |
| inline

Clears all existing buffers that are registered against the memory pool and resets the pool so it can be reused to create new buffers.

Exceptions

  If | this instance is not empty or contains no pool.

Warning
  This method is not thread-safe!

## ◆ resizePool()

void resizePool | ( | uint64_t | poolSize,
|  | void * | data = nullptr )
| inline

resize the pool size. It will attempt to resize the existing memory block, but if that fails a deep copy is performed. If `data` is not NULL it will be used as new externally managed memory for the pool. All registered buffers are updated so GridHandle::grid might return a new address (if deep copy was performed).

Note
  This method can be use to resize the memory pool and even change it from internally to externally managed memory or vice versa.

Exceptions

  if | `poolSize` is less than this->poolUsage() the used memory or allocations fail.

## ◆ size()

uint64_t size | ( |  | ) | const
| inline