77#ifndef NANOVDB_HOSTBUFFER_H_HAS_BEEN_INCLUDED 
   78#define NANOVDB_HOSTBUFFER_H_HAS_BEEN_INCLUDED 
   86#include <unordered_set> 
   91#define checkPtr(ptr, msg) \ 
   93        ptrAssert((ptr), (msg), __FILE__, __LINE__); \ 
 
   98template<
typename BufferT>
 
  117    std::shared_ptr<Pool> mPool;
 
  121#if defined(DEBUG) || defined(_DEBUG) 
  122    static inline void ptrAssert(
void* ptr, 
const char* msg, 
const char* file, 
int line, 
bool abort = 
true)
 
  124        if (ptr == 
nullptr) {
 
  125            fprintf(stderr, 
"NULL pointer error: %s %s %d\n", msg, file, line);
 
  130            fprintf(stderr, 
"Alignment pointer error: %s %s %d\n", msg, file, line);
 
  136    static inline void ptrAssert(
void*, 
const char*, 
const char*, 
int, 
bool = 
true)
 
  191    const void* 
data()
 const { 
return mData; }
 
  210    bool isEmpty()
 const { 
return !mPool || mSize == 0 || mData == 
nullptr; }
 
 
  273            if (
mData == 
nullptr) 
throw std::runtime_error(
"Pool::Pool malloc failed");
 
  277            throw std::runtime_error(
"Pool::Pool: external memory buffer is not aligned to " +
 
  279                                     " bytes.\nHint: use nanovdb::alignPtr or std::aligned_alloc (C++17 only)");
 
 
  312            std::stringstream ss;
 
  313            ss << 
"HostBuffer::Pool: insufficient memory\n" 
  315               << 
"-bytes alignment from a pool with " 
  317               << 
" bytes are used by " << 
mRegister.size() << 
" other buffer(s). " 
  318               << 
"Pool is " << (
mManaged ? 
"internally" : 
"externally") << 
" managed.\n";
 
  320            throw std::runtime_error(ss.str());
 
  322        buffer->mSize = 
size;
 
  323        const std::lock_guard<std::mutex> lock(
mMutex);
 
  325        buffer->mData = alignedFree;
 
 
  332        const std::lock_guard<std::mutex> lock(
mMutex);
 
 
  339        const std::lock_guard<std::mutex> lock(
mMutex);
 
 
  348            buffer->mPool.reset();
 
  350            buffer->mData = 
nullptr;
 
 
  360        const uint64_t memUsage = this->
usage();
 
  362        const bool managed = (
data == 
nullptr);
 
  365            throw std::runtime_error(
"Pool::resize: external memory buffer is not aligned to " +
 
  369        if (memUsage > 
size) {
 
  370            throw std::runtime_error(
"Pool::resize: insufficient memory");
 
  373        uint64_t padding = 0;
 
  382        if (
data == 
nullptr) {
 
  383            throw std::runtime_error(
"Pool::resize: allocation failed");
 
 
  415    static void* alloc(uint64_t 
size)
 
  425    static void* realloc(
void* 
const origData,
 
  427                         uint64_t    desiredSize,
 
  433        if (
data != 
nullptr && 
data != origData) {
 
  436            if (newPadding != padding) {
 
  440                             math::Min(origSize, desiredSize));
 
  441                padding = newPadding;
 
 
  455        mPool = std::make_shared<Pool>(
size);
 
  456        mData = mPool->mFree;
 
  457        mPool->mRegister.insert(
this);
 
 
  464    if (mPool && mSize != 0) {
 
  465        mPool->replace(&other, 
this);
 
  469    other.mData = 
nullptr;
 
 
  475        throw std::runtime_error(
"HostBuffer: invalid buffer size");
 
 
  494    if (mPool && mSize != 0) {
 
  495        mPool->replace(&other, 
this);
 
  499    other.mData = 
nullptr;
 
 
  505    return mPool ? mPool->mSize : 0u;
 
 
  510    return mPool ? mPool->usage(): 0u;
 
 
  515    return mPool ? mPool->mManaged : 
false;
 
 
  520    return mPool ? mPool->isFull() : 
false;
 
 
  526        throw std::runtime_error(
"HostBuffer: invalid pool size");
 
  532    buffer.mData = 
nullptr;
 
 
  539        throw std::runtime_error(
"HostBuffer: invalid buffer size");
 
 
  550    if (pool == 
nullptr || !pool->mPool) {
 
  551        buffer.mPool = std::make_shared<Pool>(
bufferSize);
 
  553       buffer.mPool = pool->mPool;
 
 
  571    if (this->
size()>0) {
 
  572        throw std::runtime_error(
"HostBuffer: only empty buffers can call reset");
 
  575        throw std::runtime_error(
"HostBuffer: this buffer contains no pool to reset");
 
 
  583        throw std::runtime_error(
"HostBuffer: this buffer contains no pool to resize");
 
 
Implements a light-weight self-contained VDB data-structure in a single file! In other words,...
#define NANOVDB_DATA_ALIGNMENT
Definition NanoVDB.h:126
This is a buffer that contains a shared or private pool to either externally or internally managed ho...
Definition HostBuffer.h:115
void * data()
Definition HostBuffer.h:192
~HostBuffer()
Custom descructor.
Definition HostBuffer.h:149
HostBuffer(const HostBuffer &)=delete
Disallow copy-construction.
const void * data() const
Retuns a pointer to the raw memory buffer managed by this allocator.
Definition HostBuffer.h:191
HostBuffer(uint64_t bufferSize=0)
Return a full buffer or an empty buffer.
Definition HostBuffer.h:452
HostBuffer & operator=(HostBuffer &&other)
Move copy assignment operation.
Definition HostBuffer.h:486
uint64_t bufferSize() const
Returns the size in bytes associated with this buffer.
Definition HostBuffer.h:197
bool empty() const
Definition HostBuffer.h:211
static HostBuffer createFull(uint64_t bufferSize, void *data=nullptr)
Return a full buffer which satisfies: buffer.size == bufferSize, buffer.poolSize() == bufferSize,...
Definition HostBuffer.h:536
uint64_t poolSize() const
Returns the size in bytes of the memory pool shared with this instance.
Definition HostBuffer.h:503
uint64_t size() const
Definition HostBuffer.h:198
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 allocat...
Definition HostBuffer.h:472
HostBuffer & operator=(const HostBuffer &)=delete
Disallow copy assignment operation.
uint64_t poolUsage() const
Total number of bytes from the pool currently in use by buffers.
Definition HostBuffer.h:508
bool isPool() const
Return true if this is a pool, i.e. an empty buffer with a nonempty internal pool,...
Definition HostBuffer.h:216
bool isManaged() const
Return true if memory is managed (using std::malloc and std:free) by the shared pool in this buffer....
Definition HostBuffer.h:513
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,...
Definition HostBuffer.h:547
void clear()
Clear this buffer so it is empty.
Definition HostBuffer.h:559
bool isEmpty() const
Returns true if this buffer has no memory associated with it.
Definition HostBuffer.h:210
void reset()
Clears all existing buffers that are registered against the memory pool and resets the pool so it can...
Definition HostBuffer.h:569
bool isFull() const
Return true if the pool exists, is nonempty but has no more available memory.
Definition HostBuffer.h:518
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 c...
Definition HostBuffer.h:580
static HostBuffer createPool(uint64_t poolSize, void *data=nullptr)
Return a pool buffer which satisfies: buffer.size == 0, buffer.poolSize() == poolSize,...
Definition HostBuffer.h:523
static DstT * PtrAdd(void *p, int64_t offset)
Adds a byte offset to a non-const pointer to produce another non-const pointer.
Definition Util.h:478
static int64_t PtrDiff(const void *p, const void *q)
Compute the distance, in bytes, between two pointers, dist = p - q.
Definition Util.h:464
Definition GridHandle.h:27
static __hostdev__ uint64_t alignmentPadding(const void *p)
return the smallest number of bytes that when added to the specified pointer results in a 32 byte ali...
Definition NanoVDB.h:550
Definition HostBuffer.h:100
static constexpr bool hasDeviceDual
Definition HostBuffer.h:101
Definition HostBuffer.h:255
std::unordered_set< HostBuffer * > HashTableT
Definition HostBuffer.h:256
void resize(uint64_t size, void *data=nullptr)
Resize this Pool and update registered buffers as needed. If data is no NULL it is used as externally...
Definition HostBuffer.h:358
uint64_t usage() const
Return the total number of bytes used from this Pool by buffers.
Definition HostBuffer.h:304
void replace(HostBuffer *buffer1, HostBuffer *buffer2)
Replaces buffer1 with buffer2 in the register.
Definition HostBuffer.h:337
Pool(uint64_t size=0, void *data=nullptr)
External memory ctor.
Definition HostBuffer.h:264
uint64_t mSize
Definition HostBuffer.h:260
void * mData
Definition HostBuffer.h:259
Pool(const Pool &)=delete
Disallow copy-construction.
void add(HostBuffer *buffer, uint64_t size)
Allocate a buffer of the specified size and add it to the register.
Definition HostBuffer.h:307
void remove(HostBuffer *buffer)
Remove the specified buffer from the register.
Definition HostBuffer.h:330
void * mFree
Definition HostBuffer.h:259
Pool & operator=(const Pool &&)=delete
Disallow move assignment operation.
std::mutex mMutex
Definition HostBuffer.h:257
Pool(const Pool &&)=delete
Disallow move-construction.
HashTableT mRegister
Definition HostBuffer.h:258
uint64_t mPadding
Definition HostBuffer.h:260
Pool & operator=(const Pool &)=delete
Disallow copy assignment operation.
void reset()
Reset the register and all its buffers.
Definition HostBuffer.h:345
~Pool()
Custom destructor.
Definition HostBuffer.h:285
bool isFull() const
Return true is all the memory in this pool is in use.
Definition HostBuffer.h:407
bool mManaged
Definition HostBuffer.h:261