__node_alloc_impl Class Reference

Static Public Member Functions
static void *	_M_allocate (size_t &__n)
static void	_M_deallocate (void *__p, size_t __n)

Private Types
typedef _Node_alloc_obj	_Obj
typedef _Obj *_STLP_VOLATILE	_Freelist
typedef _Obj *	_ChunkList

Static Private Member Functions
static size_t _STLP_CALL	_S_round_up (size_t __bytes)
static _Obj *	_S_refill (size_t __n)
static char *	_S_chunk_alloc (size_t __p_size, int &__nobjs)

Static Private Attributes
static _Freelist	_S_free_list [_STLP_NFREELISTS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
static size_t	_S_heap_size = 0
static char *	_S_start_free = 0
static char *	_S_end_free = 0

Detailed Description

Definition at line 246 of file allocators.cpp.

Member Typedef Documentation

_ChunkList

typedef _Obj* __node_alloc_impl::_ChunkList

private

Definition at line 263 of file allocators.cpp.

_Freelist

typedef _Obj* _STLP_VOLATILE __node_alloc_impl::_Freelist

private

Definition at line 262 of file allocators.cpp.

_Obj

typedef _Node_alloc_obj __node_alloc_impl::_Obj

private

Definition at line 261 of file allocators.cpp.

Member Function Documentation

_M_allocate()

void * __node_alloc_impl::_M_allocate ( size_t &  __n )

static

Definition at line 318 of file allocators.cpp.

                                                {
  __n = _S_round_up(__n);
  _Obj * _STLP_VOLATILE * __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
  _Obj *__r;
 
  // Acquire the lock here with a constructor call.
  // This ensures that it is released in exit or during stack
  // unwinding.
  _Node_Alloc_Lock __lock_instance;
 
  if ( (__r  = *__my_free_list) != 0 ) {
    *__my_free_list = __r->_M_next;
  } else {
    __r = _S_refill(__n);
  }
#  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
  _S_alloc_call();
#  endif
  // lock is released here
  return __r;
}

Referenced by __node_alloc::_M_allocate().

_M_deallocate()

void __node_alloc_impl::_M_deallocate ( void *  __p, size_t  __n  )

static

Definition at line 340 of file allocators.cpp.

                                                           {
  _Obj * _STLP_VOLATILE * __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
  _Obj * __pobj = __STATIC_CAST(_Obj*, __p);
 
  // acquire lock
  _Node_Alloc_Lock __lock_instance;
  __pobj->_M_next = *__my_free_list;
  *__my_free_list = __pobj;
 
#  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
  _S_dealloc_call();
#  endif
  // lock is released here
}

Referenced by __node_alloc::_M_deallocate().

_S_chunk_alloc()

char * __node_alloc_impl::_S_chunk_alloc ( size_t  __p_size, int &  __nobjs  )

staticprivate

Definition at line 365 of file allocators.cpp.

                                                                    {
  char* __result;
  size_t __total_bytes = _p_size * __nobjs;
  size_t __bytes_left = _S_end_free - _S_start_free;
 
  if (__bytes_left > 0) {
    if (__bytes_left >= __total_bytes) {
      __result = _S_start_free;
      _S_start_free += __total_bytes;
      return __result;
    }
 
    if (__bytes_left >= _p_size) {
      __nobjs = (int)(__bytes_left / _p_size);
      __total_bytes = _p_size * __nobjs;
      __result = _S_start_free;
      _S_start_free += __total_bytes;
      return __result;
    }
 
    // Try to make use of the left-over piece.
    _Obj* _STLP_VOLATILE* __my_free_list = _S_free_list + _S_FREELIST_INDEX(__bytes_left);
    __REINTERPRET_CAST(_Obj*, _S_start_free)->_M_next = *__my_free_list;
    *__my_free_list = __REINTERPRET_CAST(_Obj*, _S_start_free);
    _S_start_free = _S_end_free = 0;
  }
 
  size_t __bytes_to_get = 2 * __total_bytes + _S_round_up(_S_heap_size) + _STLP_OFFSET;
 
  _STLP_TRY {
    _S_start_free = __stlp_new_chunk(__bytes_to_get);
  }
#if defined (_STLP_USE_EXCEPTIONS)
  catch (const _STLP_STD::bad_alloc&) {
    _Obj* _STLP_VOLATILE* __my_free_list;
    _Obj* __p;
    // Try to do with what we have.  That can't hurt.
    // We do not try smaller requests, since that tends
    // to result in disaster on multi-process machines.
    for (size_t __i = _p_size; __i <= (size_t)_MAX_BYTES; __i += (size_t)_ALIGN) {
      __my_free_list = _S_free_list + _S_FREELIST_INDEX(__i);
      __p = *__my_free_list;
      if (0 != __p) {
        *__my_free_list = __p -> _M_next;
        _S_start_free = __REINTERPRET_CAST(char*, __p);
        _S_end_free = _S_start_free + __i;
        return _S_chunk_alloc(_p_size, __nobjs);
        // Any leftover piece will eventually make it to the
        // right free list.
      }
    }
    __bytes_to_get = __total_bytes + _STLP_OFFSET;
    _S_start_free = __stlp_new_chunk(__bytes_to_get);
  }
#endif
 
  _S_heap_size += __bytes_to_get >> 4;
#  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
  __REINTERPRET_CAST(_Obj*, _S_start_free)->_M_next = _S_chunks;
  _S_chunks = __REINTERPRET_CAST(_Obj*, _S_start_free);
#  endif
  _S_end_free = _S_start_free + __bytes_to_get;
  _S_start_free += _STLP_OFFSET;
  return _S_chunk_alloc(_p_size, __nobjs);
}

Referenced by _S_chunk_alloc(), and _S_refill().

_S_refill()

_Node_alloc_obj * __node_alloc_impl::_S_refill ( size_t  __n )

staticprivate

Definition at line 434 of file allocators.cpp.

                                                        {
  int __nobjs = 20;
  char* __chunk = _S_chunk_alloc(__n, __nobjs);
 
  if (1 == __nobjs) return __REINTERPRET_CAST(_Obj*, __chunk);
 
  _Obj* _STLP_VOLATILE* __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
  _Obj* __result;
  _Obj* __current_obj;
  _Obj* __next_obj;
 
  /* Build free list in chunk */
  __result = __REINTERPRET_CAST(_Obj*, __chunk);
  *__my_free_list = __next_obj = __REINTERPRET_CAST(_Obj*, __chunk + __n);
  for (--__nobjs; --__nobjs; ) {
    __current_obj = __next_obj;
    __next_obj = __REINTERPRET_CAST(_Obj*, __REINTERPRET_CAST(char*, __next_obj) + __n);
    __current_obj->_M_next = __next_obj;
  }
  __next_obj->_M_next = 0;
  return __result;
}

Referenced by _M_allocate().

_S_round_up()

static size_t _STLP_CALL __node_alloc_impl::_S_round_up ( size_t  __bytes )

inlinestaticprivate

Definition at line 247 of file allocators.cpp.

  { return (((__bytes) + (size_t)_ALIGN-1) & ~((size_t)_ALIGN - 1)); }

Referenced by _M_allocate(), and _S_chunk_alloc().

Member Data Documentation

_S_end_free

char * __node_alloc_impl::_S_end_free = 0

staticprivate

Definition at line 288 of file allocators.cpp.

Referenced by _S_chunk_alloc().

_S_free_list

_Node_alloc_obj *_STLP_VOLATILE __node_alloc_impl::_S_free_list = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

staticprivate

Definition at line 273 of file allocators.cpp.

Referenced by _M_allocate(), _M_deallocate(), _S_chunk_alloc(), and _S_refill().

_S_heap_size

size_t __node_alloc_impl::_S_heap_size = 0

staticprivate

Definition at line 278 of file allocators.cpp.

Referenced by _S_chunk_alloc().

_S_start_free

char * __node_alloc_impl::_S_start_free = 0

staticprivate

Definition at line 286 of file allocators.cpp.

Referenced by _S_chunk_alloc().

---

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

• sdk/lib/3rdparty/stlport/src/allocators.cpp