C++ Allocator::allocate方法代码示例

 AllocatorBlock allocate(size_t n) {
     if (n > max) {
         return {nullptr, 0};
     } if ( (n - min) % step == 0) {
         return parent_.allocate(n);
     } else {
         auto delta = (n - min)/step + 1;
         return parent_.allocate(min + delta * step);
     }
 }

 static std::pair<pointer, bool>
    allocation_command(Allocator &a, allocation_type command,
                       size_type, size_type preferred_size,
                       size_type &received_size, const pointer &)
 {
    std::pair<pointer, bool> ret(pointer(), false);
    if(!(command & allocate_new)){
       if(!(command & nothrow_allocation)){
          throw_logic_error("version 1 allocator without allocate_new flag");
       }
    }
    else{
       received_size = preferred_size;
       BOOST_TRY{
          ret.first = a.allocate(received_size);
       }
       BOOST_CATCH(...){
          if(!(command & nothrow_allocation)){
             BOOST_RETHROW
          }
       }
       BOOST_CATCH_END
    }
    return ret;
 }

int main (int argc, char **argv)
{
   bool check = true;
   Allocator allocator;

   for ( int  n = 0; n < TIMES; n++ ) {
      for ( unsigned int i = 0; i < (sizeof( sizes )/sizeof(int)); i++ ) {

         int *ptr = (int *) allocator.allocate( sizes[i] * sizeof(int) );
         if ( ptr == NULL ) check = false;

         for ( int j = 0; j < sizes[i]; j++ ) ptr[j] = CHECK_VALUE; // INI
         for ( int j = 0; j < sizes[i]; j++ ) ptr[j]++; // INC
         for ( int j = 0; j < sizes[i]; j++ ) ptr[j]--; // DEC

         // Check result
         for ( int j = 0; j < sizes[i]; j++ ) {
            if ( ptr[j] != CHECK_VALUE ) exit(-1);
         }

         Allocator::deallocate( ptr );
      }
   }

   if (check) { return 0; } else { return -1; }
}

			void expand()
			{
				size_t size = (this->mask + 1) << 1;
				size_t mask = size - 1;

				Table table = allocator.allocate(size);
				
				if(!Allocator::null_references)
					for(size_t i = 0; i < size; ++i)
						table[i] = T::invalid_value();
				
				V *end = this->table + (this->mask + 1);
				
				for(V *slot = this->table; slot != end; ++slot)
				{
					V entry = *slot;

					while(T::valid_value(entry))
					{
						T::verify_value(entry);

						V next = T::get_value_next(entry);
						
						store(table, mask, T::get_key(entry), entry);
						
						entry = next;
					}
				}

				allocator.free(this->table);

				this->mask = mask;
				this->table = table;
			}

 /// construct a stack with 0 elements and an initial capacity of 128
 Stack() :
   mData( NULL ),
   mSize( 0 ),
   mCapacity( kInitialSize ),
   mAlloc() {
   mData = mAlloc.allocate( kInitialSize );
 }

PoolAllocator::PoolAllocator(Allocator& backing, uint32_t num_blocks, uint32_t block_size, uint32_t block_align)
	: _backing(backing)
	, _start(NULL)
	, _freelist(NULL)
	, _block_size(block_size)
	, _block_align(block_align)
	, _num_allocations(0)
	, _allocated_size(0)
{
	CE_ASSERT(num_blocks > 0, "Unsupported number of blocks");
	CE_ASSERT(block_size > 0, "Unsupported block size");
	CE_ASSERT(block_align > 0, "Unsupported block alignment");

	uint32_t actual_block_size = block_size + block_align;
	uint32_t pool_size = num_blocks * actual_block_size;

	char* mem = (char*) backing.allocate(pool_size, block_align);

	// Initialize intrusive freelist
	char* cur = mem;
	for (uint32_t bb = 0; bb < num_blocks - 1; bb++)
	{
		uintptr_t* next = (uintptr_t*) cur;
		*next = (uintptr_t) cur + actual_block_size;
		cur += actual_block_size;
	}

	uintptr_t* end = (uintptr_t*) cur;
	*end = (uintptr_t) NULL;

	_start = mem;
	_freelist = mem;
}

 explicit Stack(int n) : capacity_(n), index_(0)
   {
     Allocator alloc;
     data_ = alloc.allocate(capacity_);
     for (int i = 0; i < capacity_; ++i) {
       alloc.construct(data_ + i);
     }
   }

 static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m)
 {
    allocate_individual_rollback rollback(a, m);
    while(n--){
       m.push_front(a.allocate(1));
    }
    rollback.release();
 }

//-----------------------------------------------------------------------------
LinearAllocator::LinearAllocator(Allocator& backing, size_t size)
    : m_backing(&backing)
    , m_physical_start(NULL)
    , m_total_size(size)
    , m_offset(0)
{
    m_physical_start = backing.allocate(size);
}

LinearAllocator::LinearAllocator(Allocator& backing, uint32_t size)
	: _backing(&backing)
	, _physical_start(NULL)
	, _total_size(size)
	, _offset(0)
{
	_physical_start = backing.allocate(size);
}

    void init()
    {
        m_table = m_allocator.allocate( m_buckets * ItemSize );
        m_end_marker = m_table + m_buckets;
        m_end_it = iterator( this, m_end_marker );

        initialize_memory();
    }

        /*!
         * \brief Primary constructor.
         *
         * Constructs an empty cache object and sets a maximum size for it. It is the only way to set size for a cache and it can't be changed later.
         * You could also  pass optional comparator object, compatible with Compare.
         *
         * \param <size> Maximum number of entries, allowed in the cache.
         * \param <comp> Comparator object, compatible with Compare type. Defaults to Compare()
         *
         */
        explicit cache(const size_type size, const Compare& comp = Compare()) {
            this->_storage=storageType(comp, Allocator<pair<const Key, Data> >());
            this->_maxEntries=size;
            this->_currEntries=0;

            policy_type localPolicy(size);
            this->_policy = policyAlloc.allocate(1);
            policyAlloc.construct(this->_policy,localPolicy);
        }

  void Simple()
  {
    Allocator<DummyClass> allocator;

    DummyClass* p = allocator.allocate(1);
    allocator.construct(p, DummyClass());
    allocator.destroy(p);
    allocator.deallocate(p, 1);
  }

/// Set value.
void unmanaged_string::set(UnmanagedString& s, StringRef value, Allocator& a) {
	unmanaged_string::clear(s, a);
	if (value.empty()) {
		return;
	}
	s.size = value.size;
	s.data = static_cast<char*>(a.allocate(s.size + 1));
	string::copy(s.data, s.size + 1, value);
}

 /// Reserve enough space for n elements
 void reserve( size_type n ) {
   if ( mCapacity < n ) {
     size_type oldCapacity = mCapacity;
     pointer oldData = mData;
     mCapacity = n;
     mData = mAlloc.allocate( mCapacity );
     std::uninitialized_copy( oldData, oldData + mSize, mData );
     mAlloc.deallocate( oldData, oldCapacity );
   }
 }