grad::GradientAllocator< T > Class Template Reference

#include <gradient.h>

Inheritance diagram for grad::GradientAllocator< T >:

Collaboration diagram for grad::GradientAllocator< T >:

Classes
struct	rebind

Public Types
typedef std::allocator< T > ::pointer	pointer
typedef std::allocator< T > ::size_type	size_type
typedef std::allocator< T > ::difference_type	difference_type
typedef std::allocator< T > ::const_pointer	const_pointer
typedef std::allocator< T > ::reference	reference
typedef std::allocator< T > ::const_reference	const_reference
typedef std::allocator< T > ::value_type	value_type

Public Member Functions
	GradientAllocator () throw ()
	GradientAllocator (const GradientAllocator &a) throw ()
template<typename U >
	GradientAllocator (const GradientAllocator< U > &a) throw ()
pointer	allocate (size_type n, const void *p=0)
void	deallocate (pointer p, size_type n)

Static Public Member Functions
static T *	allocate_aligned (size_type alignment, size_t n, size_type extra_bytes=0u)
static void	deallocate_aligned (pointer p, size_type n)

Detailed Description

template<typename T>
class grad::GradientAllocator< T >

Definition at line 148 of file gradient.h.

Member Typedef Documentation

template<typename T>

typedef std::allocator<T>::const_pointer grad::GradientAllocator< T >::const_pointer

Definition at line 154 of file gradient.h.

template<typename T>

typedef std::allocator<T>::const_reference grad::GradientAllocator< T >::const_reference

Definition at line 156 of file gradient.h.

template<typename T>

typedef std::allocator<T>::difference_type grad::GradientAllocator< T >::difference_type

Definition at line 153 of file gradient.h.

template<typename T>

typedef std::allocator<T>::pointer grad::GradientAllocator< T >::pointer

Definition at line 150 of file gradient.h.

template<typename T>

typedef std::allocator<T>::reference grad::GradientAllocator< T >::reference

Definition at line 155 of file gradient.h.

template<typename T>

typedef std::allocator<T>::size_type grad::GradientAllocator< T >::size_type

Definition at line 151 of file gradient.h.

template<typename T>

typedef std::allocator<T>::value_type grad::GradientAllocator< T >::value_type

Definition at line 157 of file gradient.h.

Constructor & Destructor Documentation

template<typename T>

grad::GradientAllocator< T >::GradientAllocator ( ) throw ( )

inline

Definition at line 164 of file gradient.h.

{ }

template<typename T>

grad::GradientAllocator< T >::GradientAllocator ( const GradientAllocator< T > &  a ) throw ( )

inline

Definition at line 166 of file gradient.h.

            :std::allocator<T>(a) {
        }

template<typename T>

template<typename U >

grad::GradientAllocator< T >::GradientAllocator ( const GradientAllocator< U > &  a ) throw ( )

inline

Definition at line 171 of file gradient.h.

            :std::allocator<T>(a) {
        }

Member Function Documentation

template<typename T>

pointer grad::GradientAllocator< T >::allocate ( size_type  n, const void *  p = 0  )

inline

Definition at line 176 of file gradient.h.

                                               {
#if GRADIENT_MEMORY_STAT > 0
        sMemUsage.Inc(n);
#endif

            const pointer pMem = std::allocator<T>::allocate(n, p);

#if GRADIENT_DEBUG > 0
            std::memset(pMem, 0xFF, n);
#endif      
            return pMem;
    }

template<typename T>

static T* grad::GradientAllocator< T >::allocate_aligned ( size_type  alignment, size_t  n, size_type  extra_bytes = 0u  )

inlinestatic

Definition at line 198 of file gradient.h.

References GRADIENT_ASSERT.

Referenced by grad::RangeVector< T, 0 >::ReserveMem().

                                                                                              {
#if GRADIENT_MEMORY_STAT > 0
        sMemUsage.Inc(n);
#endif
        void* p;

        const size_type byte_size = sizeof(T) * n + extra_bytes;

        GRADIENT_ASSERT(alignment % sizeof(void*) == 0);

#if defined(HAVE_POSIX_MEMALIGN)
            if (0 != posix_memalign(&p, alignment, byte_size)) {
                p = 0;
        }
#elif defined(HAVE_MEMALIGN)
        p = memalign(alignment, byte_size);
#elif defined(HAVE_ALIGNED_MALLOC)
        p = _aligned_malloc(byte_size, alignment);
#else
        p = malloc(byte_size);
#endif
            if (p == 0) {
                throw std::bad_alloc();
        }

#if GRADIENT_DEBUG > 0
            const ptrdiff_t alignment_curr = (reinterpret_cast<const char*>(p) - reinterpret_cast<const char*>(0)) % sizeof(alignment);
        
            if (alignment_curr != 0) {
                silent_cout("address " << p << " has invalid alignment " << alignment_curr << std::endl);
            }

            GRADIENT_ASSERT(alignment_curr == 0);

            std::memset(p, 0xFF, byte_size);
#endif        
        return reinterpret_cast<T*>(p);
    }

template<typename T>

void grad::GradientAllocator< T >::deallocate ( pointer  p, size_type  n  )

inline

Definition at line 190 of file gradient.h.

                                           {
        std::allocator<T>::deallocate(p, n);

#if GRADIENT_MEMORY_STAT > 0
        sMemUsage.Dec(n);
#endif
    }

template<typename T>

static void grad::GradientAllocator< T >::deallocate_aligned ( pointer  p, size_type  n  )

inlinestatic

Definition at line 239 of file gradient.h.

Referenced by grad::RangeVector< T, 0 >::FreeMem().

                                                   {
#if defined(HAVE_ALIGNED_MALLOC)
        _aligned_free(p);
#else
        free(p);
#endif

#if GRADIENT_MEMORY_STAT > 0
        sMemUsage.Dec(n);
#endif
    }

---

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

• gradient.h