memory_pool_allocator

memory_pool_allocator#

Note

To enable this feature, set the TBB_PREVIEW_MEMORY_POOL macro to 1.

A class template that provides a memory pool with a C++ allocator interface.

Description#

memory_pool_allocator meets the allocator requirements from the [allocator.requirements] ISO C++ Standard section It also provides a constructor to allocate and deallocate memory. This constructor is linked with an instance of either the memory_pool or the fixed_pool class. The class is mainly intended for enabling memory pools within STL containers.

API#

Synopsis#

namespace oneapi {
    namespace tbb {
        template<typename T>
        class memory_pool_allocator {
        public:
            using value_type = T;
            using pointer = value_type*;
            using const_pointer = const value_type*;
            using reference = value_type&;
            using const_reference = const value_type&;
            using size_type = size_t;
            using difference_type = ptrdiff_t;
            template<typename U> struct rebind {
                using other = memory_pool_allocator<U>;
            };
            explicit memory_pool_allocator(memory_pool &pool) throw();
            explicit memory_pool_allocator(fixed_pool &pool) throw();
            memory_pool_allocator(const memory_pool_allocator& src) throw();
            template<typename U>
            memory_pool_allocator(const memory_pool_allocator<U,P>& src) throw();
            pointer address(reference x) const;
            const_pointer address(const_reference x) const;
            pointer allocate(size_type n, const void* hint=0);
            void deallocate(pointer p, size_type);
            size_type max_size() const throw();
            void construct(pointer p, const T& value);
            void destroy(pointer p);
        };

        template<>
        class memory_pool_allocator<void> {
        public:
            using pointer = void*;
            using const_pointer = const void*;
            using value_type = void;
            template<typename U> struct rebind {
                using other = memory_pool_allocator<U>;
            };
            memory_pool_allocator(memory_pool &pool) throw();
            memory_pool_allocator(fixed_pool &pool) throw();
            memory_pool_allocator(const memory_pool_allocator& src) throw();
            template<typename U>
            memory_pool_allocator(const memory_pool_allocator<U>& src) throw();
        };
    } // namespace tbb
} // namespace oneapi

template<typename T, typename U>
inline bool operator==( const memory_pool_allocator<T>& a,
                       const memory_pool_allocator<U>& b);
template<typename T, typename U>
inline bool operator!=( const memory_pool_allocator<T>& a,
                        const memory_pool_allocator<U>& b);

Member Functions#

explicit memory_pool_allocator(memory_pool &pool)#

Effects: Constructs a memory pool allocator serviced by memory_pool instance pool.

explicit memory_pool_allocator(fixed_pool &pool)#

Effects: Constructs a memory pool allocator serviced by fixed_pool instance pool.

Examples#

The code below provides a simple example of container construction with the use of a memory pool.

#define TBB_PREVIEW_MEMORY_POOL 1
#include "oneapi/tbb/memory_pool.h"
...
typedef oneapi::tbb::memory_pool_allocator<int>
pool_allocator_t;
std::list<int, pool_allocator_t> my_list(pool_allocator_t( my_pool ));