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__); \ 98 template<
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)
165 static HostBuffer createPool(uint64_t poolSize,
void *data =
nullptr);
172 static HostBuffer createFull(uint64_t bufferSize,
void *data =
nullptr);
185 void init(uint64_t bufferSize,
void *data =
nullptr);
191 const uint8_t*
data()
const {
return mData; }
192 uint8_t*
data() {
return mData; }
198 uint64_t
size()
const {
return this->bufferSize(); }
202 uint64_t poolSize()
const;
206 bool isManaged()
const;
210 bool isEmpty()
const {
return !mPool || mSize == 0 || mData ==
nullptr; }
211 bool empty()
const {
return this->isEmpty(); }
216 bool isPool()
const {
return mSize == 0 && this->poolSize() > 0; }
233 uint64_t poolUsage()
const;
247 void resizePool(uint64_t poolSize,
void *data =
nullptr);
266 Pool(uint64_t size = 0,
void* data =
nullptr)
267 : mData((uint8_t*)data)
271 , mManaged(data == nullptr)
274 mData =
static_cast<uint8_t*
>(Pool::alloc(mSize));
275 if (mData ==
nullptr) {
276 throw std::runtime_error(
"Pool::Pool malloc failed");
280 if (!mManaged && mPadding != 0) {
281 throw std::runtime_error(
"Pool::Pool: external memory buffer is not aligned to " +
283 " bytes.\nHint: use nanovdb::alignPtr or std::aligned_alloc (C++17 only)");
285 mFree = mData + mPadding;
291 assert(mRegister.empty());
304 Pool& operator=(
const Pool&) =
delete;
307 Pool& operator=(
const Pool&&) =
delete;
310 uint64_t
usage()
const {
return static_cast<uint64_t
>(mFree - mData) - mPadding; }
317 if (alignedFree + size > mData + mPadding + mSize) {
318 std::stringstream ss;
319 ss <<
"HostBuffer::Pool: insufficient memory\n" 321 <<
"-bytes alignment from a pool with " 322 << mSize <<
" bytes of which\n\t" << (alignedFree - mData - mPadding)
323 <<
" bytes are used by " << mRegister.size() <<
" other buffer(s). " 324 <<
"Pool is " << (mManaged ?
"internally" :
"externally") <<
" managed.\n";
326 throw std::runtime_error(ss.str());
328 buffer->mSize = size;
329 const std::lock_guard<std::mutex> lock(mMutex);
330 mRegister.insert(buffer);
331 buffer->mData = alignedFree;
332 mFree = alignedFree + size;
338 const std::lock_guard<std::mutex> lock(mMutex);
339 mRegister.erase(buffer);
345 const std::lock_guard<std::mutex> lock(mMutex);
346 mRegister.erase( buffer1);
347 mRegister.insert(buffer2);
354 buffer->mPool.reset();
356 buffer->mData =
nullptr;
359 mFree = mData + mPadding;
364 void resize(uint64_t size,
void *data =
nullptr)
366 const uint64_t
memUsage = this->usage();
368 const bool managed = (data ==
nullptr);
371 throw std::runtime_error(
"Pool::resize: external memory buffer is not aligned to " +
375 if (memUsage > size) {
376 throw std::runtime_error(
"Pool::resize: insufficient memory");
379 uint64_t padding = 0;
380 if (mManaged && managed && size != mSize) {
382 data = Pool::realloc(mData, memUsage, size, padding);
383 }
else if (!mManaged && managed) {
384 data = Pool::alloc(size);
388 if (data ==
nullptr) {
389 throw std::runtime_error(
"Pool::resize: allocation failed");
390 }
else if (data != mData) {
391 auto* paddedData =
static_cast<uint8_t*
>(data) + padding;
393 if (!(mManaged && managed)) {
394 memcpy(paddedData, mData + mPadding, memUsage);
398 buffer->mData = paddedData + ptrdiff_t(buffer->mData - (mData + mPadding));
401 if (mManaged && !managed) {
405 mData =
static_cast<uint8_t*
>(data);
414 assert(mFree <= mData + mPadding + mSize);
415 return mSize > 0 ? mFree == mData + mPadding + mSize :
false;
420 static void* alloc(uint64_t size)
430 static void* realloc(
void*
const origData,
432 uint64_t desiredSize,
438 if (data !=
nullptr && data != origData) {
441 if (newPadding != padding) {
443 std::memmove(static_cast<uint8_t*>(data) + newPadding,
444 static_cast<uint8_t*>(data) + padding,
445 Min(origSize, desiredSize));
446 padding = newPadding;
460 mPool = std::make_shared<Pool>(
size);
461 mData = mPool->mFree;
462 mPool->mRegister.insert(
this);
463 mPool->mFree +=
size;
469 if (mPool && mSize != 0) {
470 mPool->replace(&other,
this);
474 other.mData =
nullptr;
479 if (bufferSize == 0) {
480 throw std::runtime_error(
"HostBuffer: invalid buffer size");
485 if (!mPool || mPool->mSize != bufferSize) {
488 mPool->add(
this, bufferSize);
499 if (mPool && mSize != 0) {
500 mPool->replace(&other,
this);
504 other.mData =
nullptr;
510 return mPool ? mPool->mSize : 0u;
515 return mPool ? mPool->usage(): 0u;
520 return mPool ? mPool->mManaged :
false;
525 return mPool ? mPool->isFull() :
false;
531 throw std::runtime_error(
"HostBuffer: invalid pool size");
537 buffer.mData =
nullptr;
543 if (bufferSize == 0) {
544 throw std::runtime_error(
"HostBuffer: invalid buffer size");
548 buffer.mPool->add(&buffer, bufferSize);
555 if (pool ==
nullptr || !pool->mPool) {
556 buffer.mPool = std::make_shared<Pool>(
bufferSize);
558 buffer.mPool = pool->mPool;
560 buffer.mPool->add(&buffer, bufferSize);
576 if (this->
size()>0) {
577 throw std::runtime_error(
"HostBuffer: only empty buffers can call reset");
580 throw std::runtime_error(
"HostBuffer: this buffer contains no pool to reset");
588 throw std::runtime_error(
"HostBuffer: this buffer contains no pool to resize");
590 mPool->resize(size, data);
595 #endif // end of NANOVDB_HOSTBUFFER_H_HAS_BEEN_INCLUDED static uint64_t alignmentPadding(const void *p)
return the smallest number of bytes that when added to the specified pointer results in an aligned po...
Definition: NanoVDB.h:749
Definition: HostBuffer.h:99
void reset()
Reset the register and all its buffers.
Definition: HostBuffer.h:351
void replace(HostBuffer *buffer1, HostBuffer *buffer2)
Replaces buffer1 with buffer2 in the register.
Definition: HostBuffer.h:343
void add(HostBuffer *buffer, uint64_t size)
Allocate a buffer of the specified size and add it to the register.
Definition: HostBuffer.h:313
HashTableT mRegister
Definition: HostBuffer.h:258
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:364
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.
Definition: HostBuffer.h:528
~HostBuffer()
Custom descructor.
Definition: HostBuffer.h:149
uint64_t poolSize() const
Returns the size in bytes of the memory pool shared with this instance.
Definition: HostBuffer.h:508
Type Min(Type a, Type b)
Definition: NanoVDB.h:1089
#define NANOVDB_DATA_ALIGNMENT
Definition: NanoVDB.h:154
std::mutex mMutex
Definition: HostBuffer.h:257
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:477
Implements a light-weight self-contained VDB data-structure in a single file! In other words...
bool isFull() const
Return true is all the memory in this pool is in use.
Definition: HostBuffer.h:412
Definition: NanoVDB.h:247
Pool(uint64_t size=0, void *data=nullptr)
External memory ctor.
Definition: HostBuffer.h:266
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.
Definition: HostBuffer.h:216
static constexpr bool hasDeviceDual
Definition: HostBuffer.h:101
Definition: HostBuffer.h:254
void clear()
Clear this buffer so it is empty.
Definition: HostBuffer.h:564
static HostBuffer createFull(uint64_t bufferSize, void *data=nullptr)
Return a full buffer which satisfies: buffer.size == bufferSize, buffer.poolSize() == bufferSize...
Definition: HostBuffer.h:541
HostBuffer & operator=(HostBuffer &&other)
Move copy assignment operation.
Definition: HostBuffer.h:491
uint64_t mPadding
Definition: HostBuffer.h:262
uint64_t poolUsage() const
Total number of bytes from the pool currently in use by buffers.
Definition: HostBuffer.h:513
uint8_t * mData
Definition: HostBuffer.h:259
This is a buffer that contains a shared or private pool to either externally or internally managed ho...
Definition: HostBuffer.h:114
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:518
uint64_t size() const
Returns the size in bytes associated with this buffer.
Definition: HostBuffer.h:198
bool mManaged
Definition: HostBuffer.h:263
uint8_t * mFree
Definition: HostBuffer.h:260
void reset()
Clears all existing buffers that are registered against the memory pool and resets the pool so it can...
Definition: HostBuffer.h:574
const uint8_t * data() const
Retuns a pointer to the raw memory buffer managed by this allocator.
Definition: HostBuffer.h:191
uint64_t bufferSize() const
Returns the size in bytes associated with this buffer.
Definition: HostBuffer.h:197
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:585
uint8_t * data()
Retuns a pointer to the raw memory buffer managed by this allocator.
Definition: HostBuffer.h:192
uint64_t usage() const
Return the total number of bytes used from this Pool by buffers.
Definition: HostBuffer.h:310
bool empty() const
Returns true if this buffer has no memory associated with it.
Definition: HostBuffer.h:211
HostBuffer(uint64_t bufferSize=0)
Return a full buffer or an empty buffer.
Definition: HostBuffer.h:457
bool isFull() const
Return true if the pool exists, is nonempty but has no more available memory.
Definition: HostBuffer.h:523
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:552
~Pool()
Custom destructor.
Definition: HostBuffer.h:289
std::unordered_set< HostBuffer * > HashTableT
Definition: HostBuffer.h:256
uint64_t mSize
Definition: HostBuffer.h:261
bool isEmpty() const
Returns true if this buffer has no memory associated with it.
Definition: HostBuffer.h:210