lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT > Class Template Reference

A thread-safe memory block allocator that uses a Bitset to track which blocks (out of a fixed size pool of blocks) are in-use/free. More...

#include <ChunkManagerImpl.h>

Inheritance diagram for lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >:

Public Member Functions
	BlockAllocator (unsigned char const *const ref, std::size_t const offset)
std::size_t	allocate ()
void	allocate (std::size_t *const blockOffsets, int const n)
void	free (std::size_t const *const blockOffsets, int const n)

Private Types
typedef Bitset < boost::uint64_t, TraitsT::NUM_BLOCKS >	Allocator

Private Member Functions
	BOOST_STATIC_ASSERT (TraitsT::ENTRIES_PER_BLOCK_LOG2 >=9)

Private Attributes
MutexT	_mutex
Allocator	_allocator
std::size_t const	_offset

Static Private Attributes
static std::size_t const	BLOCK_SIZE

Detailed Description

template<typename MutexT, typename DataT, typename TraitsT = DataTraits<DataT>>
class lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >

A thread-safe memory block allocator that uses a Bitset to track which blocks (out of a fixed size pool of blocks) are in-use/free.

The allocator never returns raw pointers - instead, blocks are identified by an offset in bytes relative to the address of the allocator instance.

This scheme allows an allocator instance, the memory blocks it manages, and offsets referencing them to be stored in shared memory. Clients then map these offsets to an actual block address simply by adding the offsets to the (process-specific) block allocator address.

Definition at line 149 of file ChunkManagerImpl.h.

Member Typedef Documentation

template<typename MutexT , typename DataT , typename TraitsT = DataTraits<DataT>>

typedef Bitset<boost::uint64_t, TraitsT::NUM_BLOCKS> lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::Allocator

private

Definition at line 158 of file ChunkManagerImpl.h.

Constructor & Destructor Documentation

template<typename MutexT , typename DataT , typename TraitsT >

lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::BlockAllocator	(	unsigned char const *const	reference,
		std::size_t const	offset
	)

Creates a new BlockAllocator instance. The memory blocks to be tracked by the allocator are located in contiguous memory, starting offset bytes after the given reference address.

Parameters

[in]	reference	The address relative to which offset is specified.
[in]	offset	The location of the first memory block in the pool of contiguous blocks to be managed by this allocator instance, specified as an offset in bytes relative to the reference address.

Definition at line 252 of file ChunkManagerImpl.cc.

  :
    _mutex(),
    _allocator(),
    _offset(static_cast<std::size_t>((reference + offset) - reinterpret_cast<unsigned char * >(this)))
{
    _allocator.reset();
}

Member Function Documentation

template<typename MutexT , typename DataT , typename TraitsT >

std::size_t lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::allocate

(

)

Allocates a single memory block.

Returns

The offset (in bytes relative to the address of this allocator instance) of the newly allocated block.

Exceptions

lsst::pex::exceptions:::MemoryError

Thrown if there was no free block available.

Definition at line 274 of file ChunkManagerImpl.cc.

                                                           {
    int i[1];
    ScopedLock<MutexT> lock(_mutex);
    if (!_allocator.set(i, 1)) {
        throw LSST_EXCEPT(lsst::pex::exceptions::MemoryError, "no free blocks remain");
    }
    return _offset + i[0]*BLOCK_SIZE;
}

template<typename MutexT , typename DataT , typename TraitsT >

void lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::allocate	(	std::size_t *const	blockOffsets,
		int const	n
	)

Allocates n memory blocks, storing their offsets in the given array.

Parameters

[out]	blockOffsets	The array in which the offsets (relative to this allocator instance) of allocated memory blocks are stored. Assumed to be of length at least n.
[in]	n	The number of memory blocks to allocate.

Exceptions

lsst::pex::exceptions:::MemoryError	Thrown if there were less than n free blocks available.
lsst::pex::exceptions:::RangeError	Thrown if the number of blocks to allocate is negative or too large.

Definition at line 297 of file ChunkManagerImpl.cc.

  {
    if (n < 0 || n > TraitsT::MAX_BLOCKS_PER_CHUNK) {
        throw LSST_EXCEPT(lsst::pex::exceptions::RangeError,
            "invalid number of memory blocks in allocation request");
    }
    int i[TraitsT::MAX_BLOCKS_PER_CHUNK];

    ScopedLock<MutexT> lock(_mutex);
    if (!_allocator.set(i, n)) {
        throw LSST_EXCEPT(lsst::pex::exceptions::MemoryError,
            "number of free blocks too small to satisfy allocation request");
    }
    for (int j = 0; j < n; ++j) {
        blockOffsets[j] = _offset + i[j]*BLOCK_SIZE;
    }
}

template<typename MutexT , typename DataT , typename TraitsT = DataTraits<DataT>>

lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::BOOST_STATIC_ASSERT ( TraitsT::ENTRIES_PER_BLOCK_LOG2 >=  9 )

private

template<typename MutexT , typename DataT , typename TraitsT >

void lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::free	(	std::size_t const *const	blockOffsets,
		int const	n
	)

Frees n memory blocks, identified by offsets stored in the given array. Never throws.

Parameters

[in]	blockOffsets	The array in which the offsets (relative to this allocator instance) of the memory blocks to free are stored. Assumed to be of length at least n.
[in]	n	The number of memory blocks to free.

Definition at line 327 of file ChunkManagerImpl.cc.

  {
    assert(n >= 0 && n <= TraitsT::MAX_BLOCKS_PER_CHUNK &&
        "invalid number of memory blocks in free request");

    // translate block offsets to block indexes
    int i[TraitsT::MAX_BLOCKS_PER_CHUNK];
    for (int j = 0; j < n; ++j) {
        std::size_t off = blockOffsets[j] - _offset;
        assert(off < TraitsT::NUM_BLOCKS*BLOCK_SIZE &&
               "block was not allocated by this allocator");
        assert(off % BLOCK_SIZE == 0 && "invalid block address");
        i[j] = static_cast<int>(off/BLOCK_SIZE);
    }

    // clear bit corresponding to each block to free
    ScopedLock<MutexT> lock(_mutex);
    _allocator.reset(i, n);
}

Member Data Documentation

template<typename MutexT , typename DataT , typename TraitsT = DataTraits<DataT>>

Allocator lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::_allocator

private

Definition at line 166 of file ChunkManagerImpl.h.

template<typename MutexT , typename DataT , typename TraitsT = DataTraits<DataT>>

MutexT lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::_mutex

private

Definition at line 165 of file ChunkManagerImpl.h.

template<typename MutexT , typename DataT , typename TraitsT = DataTraits<DataT>>

std::size_t const lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::_offset

private

Definition at line 167 of file ChunkManagerImpl.h.

template<typename MutexT , typename DataT , typename TraitsT = DataTraits<DataT>>

std::size_t const lsst::ap::detail::BlockAllocator< MutexT, DataT, TraitsT >::BLOCK_SIZE

staticprivate

Initial value:

=
        (sizeof(DataT) + sizeof(ChunkEntryFlag)) << TraitsT::ENTRIES_PER_BLOCK_LOG2

Definition at line 162 of file ChunkManagerImpl.h.

---

The documentation for this class was generated from the following files:

• /lsst/home/lsstsw/stack/Linux64/ap/master-g60f1e072bb+1/include/lsst/ap/ChunkManagerImpl.h
• /lsst/home/lsstsw/stack/Linux64/ap/master-g60f1e072bb+1/include/lsst/ap/ChunkManagerImpl.cc