ich wollte mein Programm etwas mit SSE optimieren. In meinem Programm muss ich eine Zahl zu vielen Elementen in einem Vektor addieren. Also eine typische Aufgabe für SSE. Mein Problem: Der Vektor ist ein STL Vektor (also std::vector). Das wäre ja im Prinzip noch kein Problem. Allerdings verlangt SSE, dass die Daten auf Adressen liegen, die ein Vielfaches von 16 sind. Und wenn jetzt std::vector einen Vektor erstellt, dann erfüllt der nicht unbedingt diese Bedingung => Absturz.

Gibt es eine Möglichkeit meinen Compiler [VS 2005] so einzustellen, dass er den new Operator dazu zwingt, den Vektor auf einer duch 16 teilbaren Adresse zu erstellen?

Hier mein Code:

//add_sse
//adds to the first four elements of vector add_value.
//just testing nonsense ;)

void add_sse(INT_VECTOR& vector,int add_value)
{
	__m128i* p_sse_source;
	__m128i  sse_add_value;

	p_sse_source = (__m128i*) &(vector.front());
	sse_add_value = _mm_set1_epi32(add_value);

	*p_sse_source = _mm_add_epi32(*p_sse_source, sse_add_value); //crash, because &(vector.front())%16 != 0 [SSE needs this], so what now :(
}

#if (defined(__ICL) || defined(_MSC_VER) || defined(__ICC))
#include <fvec.h>
inline void *aligned_malloc (size_t size, size_t align) { return _mm_malloc(size+align,align); }
inline void aligned_free (void *p) { return _mm_free(p); }
#elif defined (__CYGWIN__)
#include <xmmintrin.h>
inline void *aligned_malloc (size_t size, size_t align) { return _mm_malloc(size+align,align); }
inline void aligned_free (void *p) { return _mm_free(p); }
#elif defined(__MINGW32__)
#include <malloc.h>
inline void *aligned_malloc (size_t size, size_t align) { return __mingw_aligned_malloc(size+align,align); }
inline void aligned_free (void *p) { return __mingw_aligned_free(p); }
#elif defined(__FreeBSD__)
#include <stdlib.h>
inline void* aligned_malloc (size_t size, size_t align) { return malloc(size); }
inline void aligned_free (void *p) { return free(p); }
#else
#include <malloc.h>
inline void* aligned_malloc (size_t size, size_t align) { return memalign(align,size+align); }
inline void aligned_free (void *p) { return free(p); }
#endif

template<class T, int N=16> class alignment_allocator
{
public:
typedef T value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;

typedef T* pointer;
typedef const T* const_pointer;

typedef T& reference;
typedef const T& const_reference;

public:
inline alignment_allocator() throw() {}
template <class T2> inline alignment_allocator(const alignment_allocator<T2,N>&) throw() {}

inline ~alignment_allocator() throw() {}

inline pointer address(reference r) { return &r; }
inline const_pointer address(const_reference r) const { return &r; }

inline pointer allocate(size_type n) { return (pointer)aligned_malloc(n*sizeof(value_type),N); }
inline void deallocate(pointer p, size_type) { aligned_free(p); }

inline void construct (pointer p,const value_type& wert) { new (p) value_type(wert); }
inline void destroy (pointer p ) { p->~value_type(); }

inline size_type max_size() const throw() { return size_type(-1)/sizeof(value_type); }

template<class T2> struct rebind { typedef alignment_allocator<T2,N> other; };
};

Achja, das ist doch einer der Gründe C++ zu lieben, welche andere Sprache bietet schon solche Features