#include <std_alloc.h>

Classes
struct	rebind

Public Types
typedef T	value_type

typedef T *	pointer

typedef const T *	const_pointer

typedef T &	reference

typedef const T &	const_reference

typedef std::size_t	size_type

typedef std::ptrdiff_t	difference_type

Public Member Functions
pointer	address (reference value) const

const_pointer	address (const_reference value) const

	SimdAlloc () throw ()

	SimdAlloc (const SimdAlloc &) throw ()

template<class U >
	SimdAlloc (const SimdAlloc< U > &) throw ()

	~SimdAlloc () throw ()

size_type	max_size () const throw ()

pointer	allocate (size_type num, const void *=0)

void	construct (pointer p, const T &value)

void	destroy (pointer p)

void	deallocate (pointer p, size_type num)

void *	operator new (size_t size, void *ptr)

void *	operator new[] (size_t size, void *ptr)

void *	operator new (size_t size)

void *	operator new[] (size_t size)

void	operator delete (void *ptr, size_t)

void	operator delete[] (void *ptr, size_t)

Detailed Description

template<class T>
class nsL1::SimdAlloc< T >

Definition at line 16 of file std_alloc.h.

Member Typedef Documentation

template<class T>

typedef const T* nsL1::SimdAlloc< T >::const_pointer

Definition at line 21 of file std_alloc.h.

template<class T>

typedef const T& nsL1::SimdAlloc< T >::const_reference

Definition at line 23 of file std_alloc.h.

template<class T>

typedef std::ptrdiff_t nsL1::SimdAlloc< T >::difference_type

Definition at line 25 of file std_alloc.h.

template<class T>

typedef T* nsL1::SimdAlloc< T >::pointer

Definition at line 20 of file std_alloc.h.

template<class T>

typedef T& nsL1::SimdAlloc< T >::reference

Definition at line 22 of file std_alloc.h.

template<class T>

typedef std::size_t nsL1::SimdAlloc< T >::size_type

Definition at line 24 of file std_alloc.h.

template<class T>

typedef T nsL1::SimdAlloc< T >::value_type

Definition at line 19 of file std_alloc.h.

Constructor & Destructor Documentation

template<class T>

nsL1::SimdAlloc< T >::SimdAlloc	(	)
throw	(
	)

inline

Definition at line 44 of file std_alloc.h.

44 {

45 }

template<class T>

nsL1::SimdAlloc< T >::SimdAlloc	(	const SimdAlloc< T > &	)
throw	(
	)

inline

Definition at line 46 of file std_alloc.h.

46 {

47 }

template<class T>

template<class U >

nsL1::SimdAlloc< T >::SimdAlloc	(	const SimdAlloc< U > &	)
throw	(
	)

inline

Definition at line 49 of file std_alloc.h.

49 {

50 }

template<class T>

nsL1::SimdAlloc< T >::~SimdAlloc	(	)
throw	(
	)

inline

Definition at line 51 of file std_alloc.h.

51 {

52 }

Member Function Documentation

template<class T>

pointer nsL1::SimdAlloc< T >::address ( reference value ) const

inline

Definition at line 34 of file std_alloc.h.

                                                       {
                 return &value;
               }

template<class T>

const_pointer nsL1::SimdAlloc< T >::address ( const_reference value ) const

inline

Definition at line 37 of file std_alloc.h.

                                                                   {
                 return &value;
               }

template<class T>

pointer nsL1::SimdAlloc< T >::allocate	(	size_type	num,
		const void *	= `0`
	)

inline

Definition at line 60 of file std_alloc.h.

References T.

                                                                     {
 //               print message and allocate memory with global new
 #ifdef DEBUG_nsL1
                     std::cerr << "Allocator: allocate " << num << " element(s)"
                         << " of size " << sizeof(T) << std::endl;
 #endif // DEBUG_nsL1
                     pointer ret = reinterpret_cast<pointer>( /*T::*/operator new(num*sizeof(T)) );
 #ifdef DEBUG_nsL1
                     std::cerr << " allocated at: " << (void*)ret << std::endl;
 #endif // DEBUG_nsL1
                     return ret;
                   }

template<class T>

void nsL1::SimdAlloc< T >::construct	(	pointer	p,
		const T &	value
	)

inline

Definition at line 74 of file std_alloc.h.

References p, and T.

                                                              {
                  // initialize memory with placement new
 #ifdef DEBUG_nsL1
                     std::cerr << "Allocator: construct " << p /*<< " " << value*/ << std::endl;
 #endif // DEBUG_nsL1
                     new(p) T(value);
 //                     p = reinterpret_cast<pointer>( operator new(sizeof(T), p) );
 //                     *p = value;
 #ifdef DEBUG_nsL1
                     std::cerr << "done." << std::endl;
 #endif // DEBUG_nsL1
                   }

template<class T>

void nsL1::SimdAlloc< T >::deallocate	(	pointer	p,
		size_type	num
	)

inline

Definition at line 100 of file std_alloc.h.

References p, and T.

                                                              {
                   // print message and deallocate memory with global delete
 #ifdef DEBUG_nsL1
                     std::cerr << "Allocator: deallocate " << num << " element(s)"
                         << " of size " << sizeof(T)
                         << " at: " << static_cast<void*>(p) << std::endl;
 #endif // DEBUG_nsL1
                     /*T::*/operator delete(static_cast<void*>(p), num*sizeof(T));
 #ifdef DEBUG_nsL1
                            std::cerr << "done." << std::endl;
 #endif // DEBUG_nsL1
                   }

template<class T>

void nsL1::SimdAlloc< T >::destroy ( pointer p )

inline

Definition at line 88 of file std_alloc.h.

                                            {
                  // destroy objects by calling their destructor
 #ifdef DEBUG_nsL1
                     std::cerr << "Allocator: destroy " << p << std::endl;
 #endif // DEBUG_nsL1
                     p->~T();
 #ifdef DEBUG_nsL1
                     std::cerr << "done." << std::endl;
 #endif // DEBUG_nsL1
                   }

template<class T>

size_type nsL1::SimdAlloc< T >::max_size	(	)	const
throw	(
	)

inline

Definition at line 55 of file std_alloc.h.

References max(), and T.

                                                       {
                     return std::numeric_limits<std::size_t>::max() / sizeof(T);
                   }

template<class T>

void nsL1::SimdAlloc< T >::operator delete	(	void *	ptr,
		size_t
	)

inline

Definition at line 118 of file std_alloc.h.

118 { _mm_free(ptr); }

template<class T>

void nsL1::SimdAlloc< T >::operator delete[]	(	void *	ptr,
		size_t
	)

inline

Definition at line 119 of file std_alloc.h.

119 { _mm_free(ptr); }

template<class T>

void* nsL1::SimdAlloc< T >::operator new	(	size_t	size,
		void *	ptr
	)

inline

Definition at line 114 of file std_alloc.h.

114 { return ::operator new(size, ptr);}

template<class T>

void* nsL1::SimdAlloc< T >::operator new ( size_t size )

inline

Definition at line 116 of file std_alloc.h.

116 { return _mm_malloc(size, 16); }

template<class T>

void* nsL1::SimdAlloc< T >::operator new[]	(	size_t	size,
		void *	ptr
	)

inline

Definition at line 115 of file std_alloc.h.

115 { return ::operator new(size, ptr);}

template<class T>

void* nsL1::SimdAlloc< T >::operator new[] ( size_t size )

inline

Definition at line 117 of file std_alloc.h.

117 { return _mm_malloc(size, 16); }

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

std_alloc.h

Classes

Public Types

Public Member Functions

Detailed Description

template<class T> class nsL1::SimdAlloc< T >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

template<class T>
class nsL1::SimdAlloc< T >