/*

 *

 * 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_C

#define _STLP_PTHREAD_ALLOC_C

#ifdef __WATCOMC__

#pragma warning 13 9

#pragma warning 367 9

#pragma warning 368 9

#endif

#ifndef _STLP_PTHREAD_ALLOC_H

# include <stl/_pthread_alloc.h>

#endif

# if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)

# include <cerrno>

_STLP_BEGIN_NAMESPACE

template <size_t _Max_size>

void _Pthread_alloc<_Max_size>::_S_destructor(void * __instance)

{

    _M_lock __lock_instance;	// Need to acquire lock here.

    _Pthread_alloc_per_thread_state<_Max_size>* __s =

        (_Pthread_alloc_per_thread_state<_Max_size> *)__instance;

    __s -> __next = _S_free_per_thread_states;

    _S_free_per_thread_states = __s;

}

template <size_t _Max_size>

_Pthread_alloc_per_thread_state<_Max_size> *

_Pthread_alloc<_Max_size>::_S_new_per_thread_state()

{    

    /* lock already held here.	*/

    if (0 != _S_free_per_thread_states) {

        _Pthread_alloc_per_thread_state<_Max_size> *__result =

					_S_free_per_thread_states;

        _S_free_per_thread_states = _S_free_per_thread_states -> __next;

        return __result;

    } else {

        return (_Pthread_alloc_per_thread_state<_Max_size>*) \

                _STLP_PLACEMENT_NEW (_Pthread_alloc_per_thread_state<_Max_size>);

    }

}

template <size_t _Max_size>

_Pthread_alloc_per_thread_state<_Max_size> *

_Pthread_alloc<_Max_size>::_S_get_per_thread_state()

{

    int __ret_code;

    __state_type* __result;

    if (_S_key_initialized && (__result = (__state_type*) pthread_getspecific(_S_key)))

      return __result;

    /*REFERENCED*/

    _M_lock __lock_instance;	// Need to acquire lock here.

    if (!_S_key_initialized) {

      if (pthread_key_create(&_S_key, _S_destructor)) {

	__THROW_BAD_ALLOC;  // failed

      }

      _S_key_initialized = true;

    }

    __result = _S_new_per_thread_state();

    __ret_code = pthread_setspecific(_S_key, __result);

    if (__ret_code) {

      if (__ret_code == ENOMEM) {

	__THROW_BAD_ALLOC;

      } else {

	// EINVAL

	_STLP_ABORT();

      }

    }

    return __result;

}

/* We allocate memory in large chunks in order to avoid fragmenting     */

/* the malloc heap too much.                                            */

/* We assume that size is properly aligned.                             */

template <size_t _Max_size>

char *_Pthread_alloc<_Max_size>

::_S_chunk_alloc(size_t __p_size, size_t &__nobjs)

{

  {

    char * __result;

    size_t __total_bytes;

    size_t __bytes_left;

    /*REFERENCED*/

    _M_lock __lock_instance;         // Acquire lock for this routine

    __total_bytes = __p_size * __nobjs;

    __bytes_left = _S_end_free - _S_start_free;

    if (__bytes_left >= __total_bytes) {

        __result = _S_start_free;

        _S_start_free += __total_bytes;

        return(__result);

    } else if (__bytes_left >= __p_size) {

        __nobjs = __bytes_left/__p_size;

        __total_bytes = __p_size * __nobjs;

        __result = _S_start_free;

        _S_start_free += __total_bytes;

        return(__result);

    } else {

        size_t __bytes_to_get =

		2 * __total_bytes + _S_round_up(_S_heap_size >> 4);

        // Try to make use of the left-over piece.

        if (__bytes_left > 0) {

            _Pthread_alloc_per_thread_state<_Max_size>* __a = 

                (_Pthread_alloc_per_thread_state<_Max_size>*)

			pthread_getspecific(_S_key);

            __obj * volatile * __my_free_list =

                        __a->__free_list + _S_freelist_index(__bytes_left);

            ((__obj *)_S_start_free) -> __free_list_link = *__my_free_list;

            *__my_free_list = (__obj *)_S_start_free;

        }

#       ifdef _SGI_SOURCE

          // Try to get memory that's aligned on something like a

          // cache line boundary, so as to avoid parceling out

          // parts of the same line to different threads and thus

          // possibly different processors.

          {

            const int __cache_line_size = 128;  // probable upper bound

            __bytes_to_get &= ~(__cache_line_size-1);

            _S_start_free = (char *)memalign(__cache_line_size, __bytes_to_get); 

            if (0 == _S_start_free) {

              _S_start_free = (char *)__malloc_alloc<0>::allocate(__bytes_to_get);

            }

          }

#       else  /* !SGI_SOURCE */

          _S_start_free = (char *)__malloc_alloc<0>::allocate(__bytes_to_get);

#       endif

        _S_heap_size += __bytes_to_get;

        _S_end_free = _S_start_free + __bytes_to_get;

    }

  }

  // lock is released here

  return(_S_chunk_alloc(__p_size, __nobjs));

}

/* Returns an object of size n, and optionally adds to size n free list.*/

/* We assume that n is properly aligned.                                */

/* We hold the allocation lock.                                         */

template <size_t _Max_size>

void *_Pthread_alloc_per_thread_state<_Max_size>

::_M_refill(size_t __n)

{

    size_t __nobjs = 128;

    char * __chunk =

	_Pthread_alloc<_Max_size>::_S_chunk_alloc(__n, __nobjs);

    __obj * volatile * __my_free_list;

    __obj * __result;

    __obj * __current_obj, * __next_obj;

    int __i;

    if (1 == __nobjs)  {

        return(__chunk);

    }

    __my_free_list = __free_list

		 + _Pthread_alloc<_Max_size>::_S_freelist_index(__n);

    /* Build free list in chunk */

      __result = (__obj *)__chunk;

      *__my_free_list = __next_obj = (__obj *)(__chunk + __n);

      for (__i = 1; ; __i++) {

        __current_obj = __next_obj;

        __next_obj = (__obj *)((char *)__next_obj + __n);

        if (__nobjs - 1 == __i) {

            __current_obj -> __free_list_link = 0;

            break;

        } else {

            __current_obj -> __free_list_link = __next_obj;

        }

      }

    return(__result);

}

template <size_t _Max_size>

void *_Pthread_alloc<_Max_size>

::reallocate(void *__p, size_t __old_sz, size_t __new_sz)

{

    void * __result;

    size_t __copy_sz;

    if (__old_sz > _Max_size

	&& __new_sz > _Max_size) {

        return(realloc(__p, __new_sz));

    }

    if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return(__p);

    __result = allocate(__new_sz);

    __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;

    memcpy(__result, __p, __copy_sz);

    deallocate(__p, __old_sz);

    return(__result);

}

#if defined (_STLP_STATIC_TEMPLATE_DATA) && (_STLP_STATIC_TEMPLATE_DATA > 0)

template <size_t _Max_size>

_Pthread_alloc_per_thread_state<_Max_size> * _Pthread_alloc<_Max_size>::_S_free_per_thread_states = 0;

template <size_t _Max_size>

pthread_key_t _Pthread_alloc<_Max_size>::_S_key =0;

template <size_t _Max_size>

bool _Pthread_alloc<_Max_size>::_S_key_initialized = false;

template <size_t _Max_size>

_STLP_mutex_base _Pthread_alloc<_Max_size>::_S_chunk_allocator_lock _STLP_MUTEX_INITIALIZER;

template <size_t _Max_size>

char *_Pthread_alloc<_Max_size>::_S_start_free = 0;

template <size_t _Max_size>

char *_Pthread_alloc<_Max_size>::_S_end_free = 0;

template <size_t _Max_size>

size_t _Pthread_alloc<_Max_size>::_S_heap_size = 0;

 # else

 __DECLARE_INSTANCE(template <size_t _Max_size> _Pthread_alloc_per_thread_state<_Max_size> *, _Pthread_alloc<_Max_size>::_S_free_per_thread_states, = 0);

 __DECLARE_INSTANCE(template <size_t _Max_size> pthread_key_t, _Pthread_alloc<_Max_size>::_S_key, = 0);

 __DECLARE_INSTANCE(template <size_t _Max_size> bool, _Pthread_alloc<_Max_size>::_S_key_initialized, = false);

 __DECLARE_INSTANCE(template <size_t _Max_size> char *, _Pthread_alloc<_Max_size>::_S_start_free, = 0);

 __DECLARE_INSTANCE(template <size_t _Max_size> char *, _Pthread_alloc<_Max_size>::_S_end_free, = 0);

 __DECLARE_INSTANCE(template <size_t _Max_size> size_t, _Pthread_alloc<_Max_size>::_S_heap_size, = 0);

# endif

_STLP_END_NAMESPACE

# endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */

#endif /*  _STLP_PTHREAD_ALLOC_C */

// Local Variables:

// mode:C++

// End: