std_alloc.h

Go to the documentation of this file.

#ifndef STD_ALLOC_H
#define STD_ALLOC_H
// ---------------------- Allocator for using STL ------------------------
 
#include "xmmintrin.h"
 
#include <limits>
#include <vector>
 
namespace nsL1
{
 
// #define DEBUG_nsL1
 
template<class T>
class SimdAlloc
{
  public:
    // type definitions
    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;
 
    // rebind allocator to type U
    template<class U>
    struct rebind
    {
        typedef SimdAlloc<U> other;
    };
 
    // return address of values
    pointer address(reference value) const { return &value; }
    const_pointer address(const_reference value) const { return &value; }
 
    /* constructors and destructor
     * - nothing to do because the allocator has no state
     */
    SimdAlloc() throw() {}
    SimdAlloc(const SimdAlloc&) throw() {}
    template<class U>
    SimdAlloc(const SimdAlloc<U>&) throw()
    {}
    ~SimdAlloc() throw() {}
 
    // return maximum number of elements that can be allocated
    size_type max_size() const throw() { return std::numeric_limits<std::size_t>::max() / sizeof(T); }
 
    // allocate but don't initialize num elements of type T
    pointer allocate(size_type num, const void* = 0)
    {
//               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;
    }
 
    // initialize elements of allocated storage p with value value
    void construct(pointer p, const T& value)
    {
        // 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
    }
 
    // destroy elements of initialized storage p
    void destroy(pointer p)
    {
        // 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
    }
 
    // deallocate storage p of deleted elements
    void deallocate(pointer p, size_type num)
    {
        // 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
    }
 
    void* operator new(size_t size, void* ptr) { return ::operator new(size, ptr); }
    void* operator new[](size_t size, void* ptr) { return ::operator new(size, ptr); }
    void* operator new(size_t size) { return _mm_malloc(size, 16); }
    void* operator new[](size_t size) { return _mm_malloc(size, 16); }
    void operator delete(void* ptr, size_t) { _mm_free(ptr); }
    void operator delete[](void* ptr, size_t) { _mm_free(ptr); }
};   // SimdAlloc
 
// return that all specializations of this allocator are interchangeable
template<class T1, class T2>
bool operator==(const SimdAlloc<T1>&, const SimdAlloc<T2>&) throw()
{
    return true;
};
template<class T1, class T2>
bool operator!=(const SimdAlloc<T1>&, const SimdAlloc<T2>&) throw()
{
    return false;
};
 
template<typename T>
struct vector
{
    vector() {};
    virtual ~vector() {};
 
    typedef std::vector<T> TStd;
    //         typedef std::vector<T > TSimd;
    typedef std::vector<T, SimdAlloc<T>> TSimd;
};
 
typedef nsL1::vector<fvec>::TSimd vector_fvec;
};   // namespace nsL1
 
template<typename T>
struct nsL1vector : public nsL1::vector<T>   // just for use std::vector simultaniosly
{};
 
#endif