Files

394 lines
10 KiB
C++

/**
* @file include/ActivMiddleware/Misc/PooledBuffer.h
*
* @brief Boost::pool helper.
*/
#if (!defined ACTIV_MISC_POOLED_BUFFER_H)
#define ACTIV_MISC_POOLED_BUFFER_H
#include "ActivMiddleware/ActivMiddleware.h"
#include ACTIV_BOOST_INCLUDE(smart_ptr/intrusive_ptr.hpp)
#include ACTIV_BOOST_INCLUDE(smart_ptr/intrusive_ref_counter.hpp)
#include ACTIV_BOOST_INCLUDE(pool/pool.hpp)
//! Activ namespace.
namespace Activ
{
/**
* @brief Pooled buffer helper.
*
* POOL is a Boost::pool class.
* ADD_INTRUSIVE_REFCOUNT whether to add a Boost::intrusive_ptr reference count to the buffer class.
*
* This class can be used to allocate buffers from a Boost::pool, or with malloc/free if the Boost::pool buffer
* size is not sufficient.
*
* Provides Pointer and ConstPointer types. Will be intrusive if ADD_INTRUSIVE_REFCOUNT.
*/
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
class PooledBuffer : public Boost::mpl::if_c<ADD_INTRUSIVE_REFCOUNT,
Boost::intrusive_ref_counter<PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>, Boost::thread_unsafe_counter>, Empty>::type
{
public:
typedef POOL Pool;
typedef typename Boost::mpl::if_c<
ADD_INTRUSIVE_REFCOUNT,
Boost::intrusive_ptr<PooledBuffer>,
PooledBuffer *
>::type Pointer;
typedef typename Boost::mpl::if_c<
ADD_INTRUSIVE_REFCOUNT,
Boost::intrusive_ptr<const PooledBuffer>,
const PooledBuffer *
>::type ConstPointer;
/**
* @brief Constructor.
*
* No buffer is allocated from the pool.
*
* @param pool to be used for future allocations.
*/
PooledBuffer(Pool &pool);
/**
* @brief Constructor.
*
* @param pool
* @param bufferLength initial buffer size to allocate. If <= the pool's buffer size, allocate from pool, else malloc.
*
* @throw std::bad_alloc on memory allocation failure.
*/
PooledBuffer(Pool &pool, const size_t bufferLength);
/**
* @brief Destructor.
*/
~PooledBuffer();
/**
* @brief Allocate a buffer.
*
* If a buffer is already allocated, and it is of sufficient size to hold @a bufferLength, it is reused.
*
* @param bufferLength buffer size to allocate. If <= the pool's buffer size, allocate from pool, else malloc.
*/
bool Allocate(const size_t bufferLength);
/**
* @brief Copy data in to the start of the buffer.
*
* A buffer is allocated as required.
*
* @param pData
* @param dataLength
*
* @return Boolean as to whether the copy was successful.
*/
bool Copy(const void *pData, const size_t dataLength);
/**
* @brief Get the pool.
*
* @return Pool reference.
*/
Pool &GetPool();
/**
* @brief Get const pointer to underlying buffer.
*
* @return Pointer to buffer.
*/
const void *GetBuffer() const;
/**
* @brief Get pointer to underlying buffer.
*
* @return Pointer to buffer.
*/
void *GetBuffer();
/**
* @brief Get size of underlying buffer.
*
* @return Buffer size.
*/
size_t GetBufferSize() const;
/**
* @brief Get amount of buffer in use.
*
* @return Buffer length in use.
*/
size_t GetLength() const;
/**
* @brief Set the amount of the buffer in use.
*
* @param dataLength cannot be larger than the underlying buffer size.
*/
void SetLength(const size_t dataLength);
/**
* @brief Assignment operator.
*
* This object's buffer (if any) is freed, and this object takes ownership of @a rhs's buffer. rhs will
* no longer have a buffer.
*
* The pool used by @a rhs must be the same as this pool.
*
* @param rhs
*/
PooledBuffer &operator=(PooledBuffer &rhs);
private:
// No copy ctor. We'd need a proxy class to be able to do a non-const copy constructor anyway.
PooledBuffer(const PooledBuffer &);
/**
* Allocate buffer from pool or malloc.
*
* @param bufferLength
*/
bool InternalAllocate(const size_t bufferLength);
/**
* @brief Return buffer to pool or free().
*/
void Free();
Pool & m_pool;
void * m_pBuffer;
size_t m_bufferSize;
size_t m_dataLength; ///< Buffer length actually in use.
};
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::PooledBuffer(Pool &pool) :
m_pool(pool),
m_pBuffer(0),
m_bufferSize(0),
m_dataLength(0)
{
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::PooledBuffer(Pool &pool, const size_t bufferLength) :
m_pool(pool),
m_pBuffer(0),
m_bufferSize(0),
m_dataLength(0)
{
if (bufferLength > 0)
{
if (!InternalAllocate(bufferLength))
throw std::bad_alloc();
}
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::~PooledBuffer()
{
if (0 != m_pBuffer)
Free();
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline bool PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::Allocate(const size_t bufferLength)
{
if (ACTIV_UNLIKELY(0 == bufferLength))
{
if (0 != m_bufferSize)
{
Free();
m_dataLength = 0;
}
return true;
}
if (0 != m_bufferSize)
{
if (bufferLength <= m_bufferSize)
{
// Just reuse existing buffer.
m_dataLength = 0;
return true;
}
Free();
}
return InternalAllocate(bufferLength);
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline bool PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::Copy(const void *pData, const size_t dataLength)
{
if (ACTIV_LIKELY(0 != pData))
{
// There's actual data to copy in. Allocate a buffer if necessary.
if (ACTIV_UNLIKELY(!Allocate(dataLength)))
return false;
std::memcpy(m_pBuffer, pData, dataLength);
}
else
{
// Setting NULL pointer, just free up an existing buffer.
assert(0 == dataLength);
if (0 != m_pBuffer)
Free();
}
m_dataLength = dataLength;
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline POOL &PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::GetPool()
{
return m_pool;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline const void *PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::GetBuffer() const
{
return m_pBuffer;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline void *PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::GetBuffer()
{
return m_pBuffer;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline size_t PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::GetBufferSize() const
{
return m_bufferSize;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline size_t PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::GetLength() const
{
return m_dataLength;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline void PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::SetLength(const size_t dataLength)
{
if (ACTIV_UNLIKELY(dataLength > m_bufferSize))
{
// Whoops. We're trying to set the length beyond the buffer size. Not allowed - this API
// is just for truncating a buffer to the "built" size of a datagram.
assert(false);
return;
}
m_dataLength = dataLength;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT> &PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::operator=(PooledBuffer &rhs)
{
if (ACTIV_UNLIKELY(&rhs == this))
return *this;
assert(&m_pool == &rhs.m_pool);
// Transfer ownership of rhs's buffer to this.
if (0 != m_pBuffer)
Free();
m_pBuffer = rhs.m_pBuffer;
m_bufferSize = rhs.m_bufferSize;
m_dataLength = rhs.m_dataLength;
rhs.m_pBuffer = 0;
rhs.m_bufferSize = 0;
rhs.m_dataLength = 0;
return *this;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline bool PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::InternalAllocate(const size_t bufferLength)
{
assert(0 == m_pBuffer);
void *pBuffer;
size_t actualBufferLength = m_pool.get_requested_size();
if (bufferLength <= actualBufferLength)
{
pBuffer = m_pool.malloc();
}
else
{
actualBufferLength = bufferLength;
pBuffer = std::malloc(actualBufferLength);
}
if (0 == pBuffer)
return false;
m_pBuffer = pBuffer;
m_bufferSize = actualBufferLength;
m_dataLength = 0;
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename POOL, bool ADD_INTRUSIVE_REFCOUNT>
inline void PooledBuffer<POOL, ADD_INTRUSIVE_REFCOUNT>::Free()
{
assert(0 != m_pBuffer);
if (m_bufferSize <= m_pool.get_requested_size())
m_pool.free(m_pBuffer);
else
std::free(m_pBuffer);
m_pBuffer = 0;
m_bufferSize = 0;
}
} // namespace Activ
#endif // (!defined ACTIV_MISC_POOLED_BUFFER_H)