/*

 *

 * Copyright (c) 1994

 * Hewlett-Packard Company

 *

 * Copyright (c) 1996,1997

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1997

 * Moscow Center for SPARC Technology

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

#ifndef _STLP_PTHREAD_ALLOC_H

#define _STLP_PTHREAD_ALLOC_H

/*

 * Pthread-specific node allocator.

 * This is similar to the default allocator, except that free-list

 * information is kept separately for each thread, avoiding locking.

 * This should be reasonably fast even in the presence of threads.

 * The down side is that storage may not be well-utilized.

 * It is not an error to allocate memory in thread A and deallocate

 * it in thread B.  But this effectively transfers ownership of the memory,

 * so that it can only be reallocated by thread B.  Thus this can effectively

 * result in a storage leak if it's done on a regular basis.

 * It can also result in frequent sharing of

 * cache lines among processors, with potentially serious performance

 * consequences.

 */

#if !defined (_STLP_PTHREADS)

#  error POSIX specific allocator implementation. Your system do not seems to \

have this interface so please comment the _STLP_USE_PERTHREAD_ALLOC macro \

or report to the STLport forum.

#endif

#if defined (_STLP_USE_NO_IOSTREAMS)

#  error You cannot use per thread allocator implementation without building \

STLport libraries.

#endif

#ifndef _STLP_INTERNAL_ALLOC_H

#  include <stl/_alloc.h>

#endif

_STLP_BEGIN_NAMESPACE

_STLP_MOVE_TO_PRIV_NAMESPACE

struct _Pthread_alloc_per_thread_state;

// Pthread-specific allocator.

class _STLP_CLASS_DECLSPEC _Pthread_alloc {

public: // but only for internal use:

  typedef _Pthread_alloc_per_thread_state __state_type;

  typedef char value_type;

public:

  // Return a recycled or new per thread state.

  static __state_type * _STLP_CALL _S_get_per_thread_state();

  /* n must be > 0      */

  static void * _STLP_CALL allocate(size_t& __n);

  /* p may not be 0 */

  static void _STLP_CALL deallocate(void *__p, size_t __n);

  // boris : versions for per_thread_allocator

  /* n must be > 0      */

  static void * _STLP_CALL allocate(size_t& __n, __state_type* __a);

  /* p may not be 0 */

  static void _STLP_CALL deallocate(void *__p, size_t __n, __state_type* __a);

  static void * _STLP_CALL reallocate(void *__p, size_t __old_sz, size_t& __new_sz);

};

_STLP_MOVE_TO_STD_NAMESPACE

typedef _STLP_PRIV _Pthread_alloc __pthread_alloc;

typedef __pthread_alloc pthread_alloc;

template <class _Tp>

class pthread_allocator : public __stlport_class<pthread_allocator<_Tp> > {

  typedef pthread_alloc _S_Alloc;          // The underlying allocator.

public:

  typedef size_t     size_type;

  typedef ptrdiff_t  difference_type;

  typedef _Tp*       pointer;

  typedef const _Tp* const_pointer;

  typedef _Tp&       reference;

  typedef const _Tp& const_reference;

  typedef _Tp        value_type;

#ifdef _STLP_MEMBER_TEMPLATE_CLASSES

  template <class _NewType> struct rebind {

    typedef pthread_allocator<_NewType> other;

  };

#endif

  pthread_allocator() _STLP_NOTHROW {}

  pthread_allocator(const pthread_allocator<_Tp>& a) _STLP_NOTHROW {}

#if defined (_STLP_MEMBER_TEMPLATES) /* && defined (_STLP_FUNCTION_PARTIAL_ORDER) */

  template <class _OtherType> pthread_allocator(const pthread_allocator<_OtherType>&)

    _STLP_NOTHROW {}

#endif

  ~pthread_allocator() _STLP_NOTHROW {}

  pointer address(reference __x) const { return &__x; }

  const_pointer address(const_reference __x) const { return &__x; }

  // __n is permitted to be 0.  The C++ standard says nothing about what

  // the return value is when __n == 0.

  _Tp* allocate(size_type __n, const void* = 0) {

    if (__n > max_size()) {

      __THROW_BAD_ALLOC;

    }

    if (__n != 0) {

      size_type __buf_size = __n * sizeof(value_type);

      _Tp* __ret = __REINTERPRET_CAST(value_type*, _S_Alloc::allocate(__buf_size));

#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)

      if (__ret != 0) {

        memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);

      }

#endif

      return __ret;

    }

    else

      return 0;

  }

  void deallocate(pointer __p, size_type __n) {

    _STLP_ASSERT( (__p == 0) == (__n == 0) )

    if (__p != 0) {

#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)

      memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type));

#endif

      _S_Alloc::deallocate(__p, __n * sizeof(value_type));

    }

  }

  size_type max_size() const _STLP_NOTHROW

  { return size_t(-1) / sizeof(_Tp); }

  void construct(pointer __p, const _Tp& __val) { _STLP_PLACEMENT_NEW (__p) _Tp(__val); }

  void destroy(pointer _p) { _p->~_Tp(); }

#if defined (_STLP_NO_EXTENSIONS)

  /* STLport extension giving rounded size of an allocated memory buffer

   * This method do not have to be part of a user defined allocator implementation

   * and won't even be called if such a function was granted.

   */

protected:

#endif

  _Tp* allocate(size_type __n, size_type& __allocated_n) {

    if (__n > max_size()) {

      __THROW_BAD_ALLOC;

    }

    if (__n != 0) {

      size_type __buf_size = __n * sizeof(value_type);

      _Tp* __ret = __REINTERPRET_CAST(value_type*, _S_Alloc::allocate(__buf_size));

#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)

      if (__ret != 0) {

        memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);

      }

#endif

      __allocated_n = __buf_size / sizeof(value_type);

      return __ret;

    }

    else

      return 0;

  }

};

_STLP_TEMPLATE_NULL

class _STLP_CLASS_DECLSPEC pthread_allocator<void> {

public:

  typedef size_t      size_type;

  typedef ptrdiff_t   difference_type;

  typedef void*       pointer;

  typedef const void* const_pointer;

  typedef void        value_type;

#ifdef _STLP_MEMBER_TEMPLATE_CLASSES

  template <class _NewType> struct rebind {

    typedef pthread_allocator<_NewType> other;

  };

#endif

};

template <class _T1, class _T2>

inline bool operator==(const pthread_allocator<_T1>&,

                       const pthread_allocator<_T2>& a2)

{ return true; }

#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER

template <class _T1, class _T2>

inline bool operator!=(const pthread_allocator<_T1>&,

                       const pthread_allocator<_T2>&)

{ return false; }

#endif

#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

#  if defined (_STLP_USE_RAW_SGI_ALLOCATORS)

template <class _Tp>

struct _Alloc_traits<_Tp, _Pthread_alloc>

{ typedef __allocator<_Tp, _Pthread_alloc> allocator_type; };

#  endif

template <class _Tp, class _Atype>

struct _Alloc_traits<_Tp, pthread_allocator<_Atype> >

{ typedef pthread_allocator<_Tp> allocator_type; };

#endif

#if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)

template <class _Tp1, class _Tp2>

inline pthread_allocator<_Tp2>&

__stl_alloc_rebind(pthread_allocator<_Tp1>& __x, const _Tp2*)

{ return (pthread_allocator<_Tp2>&)__x; }

template <class _Tp1, class _Tp2>

inline pthread_allocator<_Tp2>

__stl_alloc_create(pthread_allocator<_Tp1>&, const _Tp2*)

{ return pthread_allocator<_Tp2>(); }

#endif

_STLP_MOVE_TO_PRIV_NAMESPACE

template <class _Tp>

struct __pthread_alloc_type_traits {

  typedef typename _IsSTLportClass<pthread_allocator<_Tp> >::_Ret _STLportAlloc;

  //The default allocator implementation which is recognize thanks to the

  //__stlport_class inheritance is a stateless object so:

  typedef _STLportAlloc has_trivial_default_constructor;

  typedef _STLportAlloc has_trivial_copy_constructor;

  typedef _STLportAlloc has_trivial_assignment_operator;

  typedef _STLportAlloc has_trivial_destructor;

  typedef _STLportAlloc is_POD_type;

};

_STLP_MOVE_TO_STD_NAMESPACE

#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

template <class _Tp>

struct __type_traits<pthread_allocator<_Tp> > : _STLP_PRIV __pthread_alloc_type_traits<_Tp> {};

#else

_STLP_TEMPLATE_NULL

struct __type_traits<pthread_allocator<char> > : _STLP_PRIV __pthread_alloc_type_traits<char> {};

#  if defined (_STLP_HAS_WCHAR_T)

_STLP_TEMPLATE_NULL

struct __type_traits<pthread_allocator<wchar_t> > : _STLP_PRIV __pthread_alloc_type_traits<wchar_t> {};

#  endif

#  if defined (_STLP_USE_PTR_SPECIALIZATIONS)

_STLP_TEMPLATE_NULL

struct __type_traits<pthread_allocator<void*> > : _STLP_PRIV __pthread_alloc_type_traits<void*> {};

#  endif

#endif

//

// per_thread_allocator<> : this allocator always return memory to the same thread

// it was allocated from.

//

template <class _Tp>

class per_thread_allocator {

  typedef pthread_alloc _S_Alloc;          // The underlying allocator.

  typedef pthread_alloc::__state_type __state_type;

public:

  typedef size_t     size_type;

  typedef ptrdiff_t  difference_type;

  typedef _Tp*       pointer;

  typedef const _Tp* const_pointer;

  typedef _Tp&       reference;

  typedef const _Tp& const_reference;

  typedef _Tp        value_type;

#ifdef _STLP_MEMBER_TEMPLATE_CLASSES

  template <class _NewType> struct rebind {

    typedef per_thread_allocator<_NewType> other;

  };

#endif

  per_thread_allocator() _STLP_NOTHROW {

    _M_state = _S_Alloc::_S_get_per_thread_state();

  }

  per_thread_allocator(const per_thread_allocator<_Tp>& __a) _STLP_NOTHROW : _M_state(__a._M_state){}

#if defined (_STLP_MEMBER_TEMPLATES) /* && defined (_STLP_FUNCTION_PARTIAL_ORDER) */

  template <class _OtherType> per_thread_allocator(const per_thread_allocator<_OtherType>& __a)

    _STLP_NOTHROW : _M_state(__a._M_state) {}

#endif

  ~per_thread_allocator() _STLP_NOTHROW {}

  pointer address(reference __x) const { return &__x; }

  const_pointer address(const_reference __x) const { return &__x; }

  // __n is permitted to be 0.  The C++ standard says nothing about what

  // the return value is when __n == 0.

  _Tp* allocate(size_type __n, const void* = 0) {

    if (__n > max_size()) {

      __THROW_BAD_ALLOC;

    }

    if (__n != 0) {

      size_type __buf_size = __n * sizeof(value_type);

      _Tp* __ret = __REINTERPRET_CAST(_Tp*, _S_Alloc::allocate(__buf_size, _M_state));

#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)

      if (__ret != 0) {

        memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);

      }

#endif

      return __ret;

    }

    else

      return 0;

  }

  void deallocate(pointer __p, size_type __n) {

    _STLP_ASSERT( (__p == 0) == (__n == 0) )

    if (__p != 0) {

#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)

      memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type));

#endif

      _S_Alloc::deallocate(__p, __n * sizeof(value_type), _M_state);

    }

  }

  size_type max_size() const _STLP_NOTHROW

  { return size_t(-1) / sizeof(_Tp); }

  void construct(pointer __p, const _Tp& __val) { _STLP_PLACEMENT_NEW (__p) _Tp(__val); }

  void destroy(pointer _p) { _p->~_Tp(); }

  // state is being kept here

  __state_type* _M_state;

#if defined (_STLP_NO_EXTENSIONS)

  /* STLport extension giving rounded size of an allocated memory buffer

   * This method do not have to be part of a user defined allocator implementation

   * and won't even be called if such a function was granted.

   */

protected:

#endif

  _Tp* allocate(size_type __n, size_type& __allocated_n) {

    if (__n > max_size()) {

      __THROW_BAD_ALLOC;

    }

    if (__n != 0) {

      size_type __buf_size = __n * sizeof(value_type);

      _Tp* __ret = __REINTERPRET_CAST(value_type*, _S_Alloc::allocate(__buf_size, _M_state));

#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)

      if (__ret != 0) {

        memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);

      }

#endif

      __allocated_n = __buf_size / sizeof(value_type);

      return __ret;

    }

    else

      return 0;

  }

};

_STLP_TEMPLATE_NULL

class _STLP_CLASS_DECLSPEC per_thread_allocator<void> {

public:

  typedef size_t      size_type;

  typedef ptrdiff_t   difference_type;

  typedef void*       pointer;

  typedef const void* const_pointer;

  typedef void        value_type;

#ifdef _STLP_MEMBER_TEMPLATE_CLASSES

  template <class _NewType> struct rebind {

    typedef per_thread_allocator<_NewType> other;

  };

#endif

};

template <class _T1, class _T2>

inline bool operator==(const per_thread_allocator<_T1>& __a1,

                       const per_thread_allocator<_T2>& __a2)

{ return __a1._M_state == __a2._M_state; }

#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER

template <class _T1, class _T2>

inline bool operator!=(const per_thread_allocator<_T1>& __a1,

                       const per_thread_allocator<_T2>& __a2)

{ return __a1._M_state != __a2._M_state; }

#endif

#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

template <class _Tp, class _Atype>

struct _Alloc_traits<_Tp, per_thread_allocator<_Atype> >

{ typedef per_thread_allocator<_Tp> allocator_type; };

#endif

#if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)

template <class _Tp1, class _Tp2>

inline per_thread_allocator<_Tp2>&

__stl_alloc_rebind(per_thread_allocator<_Tp1>& __x, const _Tp2*)

{ return (per_thread_allocator<_Tp2>&)__x; }

template <class _Tp1, class _Tp2>

inline per_thread_allocator<_Tp2>

__stl_alloc_create(per_thread_allocator<_Tp1>&, const _Tp2*)

{ return per_thread_allocator<_Tp2>(); }

#endif /* _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE */

_STLP_MOVE_TO_PRIV_NAMESPACE

template <class _Tp>

struct __perthread_alloc_type_traits {

  typedef typename _IsSTLportClass<per_thread_allocator<_Tp> >::_Ret _STLportAlloc;

  //The default allocator implementation which is recognize thanks to the

  //__stlport_class inheritance is a stateless object so:

  typedef __false_type has_trivial_default_constructor;

  typedef _STLportAlloc has_trivial_copy_constructor;

  typedef _STLportAlloc has_trivial_assignment_operator;

  typedef _STLportAlloc has_trivial_destructor;

  typedef __false_type is_POD_type;

};

_STLP_MOVE_TO_STD_NAMESPACE

#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

template <class _Tp>

struct __type_traits<per_thread_allocator<_Tp> > : _STLP_PRIV __perthread_alloc_type_traits<_Tp> {};

#else

_STLP_TEMPLATE_NULL

struct __type_traits<per_thread_allocator<char> > : _STLP_PRIV __perthread_alloc_type_traits<char> {};

#  if defined (_STLP_HAS_WCHAR_T)

_STLP_TEMPLATE_NULL

struct __type_traits<per_thread_allocator<wchar_t> > : _STLP_PRIV __perthread_alloc_type_traits<wchar_t> {};

#  endif

#  if defined (_STLP_USE_PTR_SPECIALIZATIONS)

_STLP_TEMPLATE_NULL

struct __type_traits<per_thread_allocator<void*> > : _STLP_PRIV __perthread_alloc_type_traits<void*> {};

#  endif

#endif

_STLP_END_NAMESPACE

#endif /* _STLP_PTHREAD_ALLOC */

// Local Variables:

// mode:C++

// End: