simd.h

Go to the documentation of this file.

#ifndef CPPAPE_SIMD_H
#define CPPAPE_SIMD_H
 
#include <complex>
#include <climits>
#include "misc.h"
#include <vector>
 
namespace ape
{
#ifndef __CPPAPE_NATIVE_VECTOR_BIT_WIDTH__
#define __CPPAPE_NATIVE_VECTOR_BIT_WIDTH__ 128
#endif
 
#define __CPPAPE_NATIVE_VECTOR_BYTES__ (__CPPAPE_NATIVE_VECTOR_BIT_WIDTH__ / CHAR_BIT)
 
    template<typename T>
    using vector_register = T __attribute__((ext_vector_type(__CPPAPE_NATIVE_VECTOR_BYTES__ / sizeof(T))));
 
    template<typename V>
    struct vector_traits
    {
        typedef decltype(V()[0]) value_type;
        static constexpr std::size_t lanes = sizeof(V) / sizeof(value_type);
    };
 
    template<typename T>
    inline std::complex<vector_register<T>> operator * (std::complex<vector_register<T>> a, std::complex<vector_register<T>> b)
    {
        return { a.real() * b.real() - a.imag() * b.imag(), a.real() * b.imag() + a.imag() * b.real() };
    }
 
    template<typename T>
    inline uarray<vector_register<T>> as_vectors(uarray<T> input)
    {
        constexpr auto mask = __CPPAPE_NATIVE_VECTOR_BYTES__ - 1;
 
        assert((static_cast<std::uintptr_t>(input.data()) & mask) == 0 && "Input array not sufficiently aligned");
        assert(input.size() * sizeof(T) % sizeof(vector_register<T>) == 0 && "Whole number of machine vector registers does not fit in array");
 
        return { reinterpret_cast<vector_register<T>>(input.data(), (sizeof(T) * input.size()) / sizeof(vector_register<T>)) };
    }
 
    template<typename T>
    inline uarray<std::complex<vector_register<T>>> as_vectors(uarray<std::complex<T>> input)
    {
        constexpr auto mask = __CPPAPE_NATIVE_VECTOR_BYTES__ - 1;
 
        assert((reinterpret_cast<std::uintptr_t>(input.data()) & mask) == 0 && "Input array not sufficiently aligned");
        assert(input.size() * sizeof(T) % sizeof(std::complex<vector_register<T>>) == 0 && "Whole number of machine vector registers does not fit in array");
 
        return { reinterpret_cast<std::complex<vector_register<T>>*>(input.data()), (sizeof(std::complex<T>) * input.size()) / sizeof(std::complex<vector_register<T>>) };
    }
 
    template<typename T>
    inline uarray<vector_register<T>> as_vectors(std::vector<T>& input)
    {
        return as_vectors(as_uarray(input));
    }
 
    template<typename T>
    inline uarray<std::complex<vector_register<T>>> as_vectors(std::vector<std::complex<T>>& input)
    {
        return as_vectors(as_uarray(input));
    }
}
 
#endif