libcruft-util/coord/simd_sse.hpp

272 lines
7.4 KiB
C++
Raw Normal View History

2018-03-16 11:10:44 +11:00
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Copyright 2018 Danny Robson <danny@nerdcruft.net>
*/
#ifndef CRUFT_UTIL_COORD_SIMD_SSE_HPP
#define CRUFT_UTIL_COORD_SIMD_SSE_HPP
2018-03-20 13:30:05 +11:00
#ifndef __SSE3__
#error "SSE3 is required"
2018-03-16 11:10:44 +11:00
#endif
#include <xmmintrin.h>
#include <pmmintrin.h>
#include <immintrin.h>
#include <array>
2018-03-22 16:10:06 +11:00
#include <iosfwd>
2018-03-16 11:10:44 +11:00
namespace util::coord {
///////////////////////////////////////////////////////////////////////////
namespace detail {
}
constexpr int alignment = 16;
struct alignas (16) simd {
///////////////////////////////////////////////////////////////////////
simd (float a, float b, float c, float d):
data (_mm_setr_ps (a, b, c, d))
{ ; }
//---------------------------------------------------------------------
simd (float v):
data (_mm_set_ps1 (v))
{ ; }
//---------------------------------------------------------------------
simd (__m128 _data):
data (_data)
{ ; }
//---------------------------------------------------------------------
2018-03-20 13:30:05 +11:00
explicit operator __m128& () { return data; }
explicit operator const __m128& () const { return data; }
2018-03-16 11:10:44 +11:00
explicit operator bool () const;
float operator[] (int idx) const { return data[idx]; }
///////////////////////////////////////////////////////////////////////
__m128 data;
};
///////////////////////////////////////////////////////////////////////////
2018-03-20 13:30:05 +11:00
simd operator+ (simd a, simd b) { return _mm_add_ps (a.data, b.data); }
simd operator- (simd a, simd b) { return _mm_sub_ps (a.data, b.data); }
simd operator/ (simd a, simd b) { return _mm_div_ps (a.data, b.data); }
simd operator* (simd a, simd b) { return _mm_mul_ps (a.data, b.data); }
2018-03-16 11:10:44 +11:00
//-------------------------------------------------------------------------
2018-03-20 13:30:05 +11:00
// computes a*b + c
auto
fma (simd a, simd b, simd c)
{
#if defined(__FMA__)
return _mm_fmadd_ps (a.data, b.data, c.data);
#else
return a * b + c;
#endif
}
///////////////////////////////////////////////////////////////////////////
simd operator< (simd a, simd b) { return _mm_cmplt_ps (a.data, b.data); }
simd operator<= (simd a, simd b) { return _mm_cmple_ps (a.data, b.data); }
simd operator> (simd a, simd b) { return _mm_cmpgt_ps (a.data, b.data); }
simd operator>= (simd a, simd b) { return _mm_cmpge_ps (a.data, b.data); }
simd operator== (simd a, simd b) { return _mm_cmpeq_ps (a.data, b.data); }
2018-03-16 11:10:44 +11:00
//-------------------------------------------------------------------------
2018-03-20 13:30:05 +11:00
simd operator| (simd a, simd b) { return _mm_or_ps (a.data, b.data); }
simd operator|| (simd a, simd b) { return _mm_or_ps (a.data, b.data); }
simd operator& (simd a, simd b) { return _mm_and_ps (a.data, b.data); }
simd operator&& (simd a, simd b) { return _mm_and_ps (a.data, b.data); }
2018-03-16 11:10:44 +11:00
2018-03-20 13:30:05 +11:00
///////////////////////////////////////////////////////////////////////////
simd floor (simd val)
{
#if defined(__SSE4_1__)
return mm_floor_ps (val.data);
#else
// NOTE: assumes the rounding mode is 'nearest'
// cast to int and back to truncate
const auto truncated = _mm_cvtepi32_ps (_mm_cvtps_epi32 (val.data));
// if the truncated value is greater than the original value we got
// rounded up so we need to decrement to get the true value.
return truncated - ((truncated > val) & simd (1));
#endif
}
//---------------------------------------------------------------------------
simd ceil (simd val)
{
#if defined(__SSE4_1__)
return _mm_ceil_ps (val.data);
#else
// NOTE: assumes the rounding mode is 'nearest'
// truncate by casting to int and back
const auto truncated = _mm_cvtepi32_ps (_mm_cvtps_epi32 (val.data));
// if the truncated value is below the original value it got rounded
// down and needs to be incremented to get the true value.
return truncated + ((truncated < val) & simd (1));
#endif
}
2018-03-16 11:10:44 +11:00
///////////////////////////////////////////////////////////////////////////
simd
select (simd mask, simd a, simd b)
{
#if defined(__SSE4_1__)
return _mm_blendv_ps (a, b, mask);
#else
return _mm_or_ps (
2018-03-20 13:30:05 +11:00
_mm_and_ps (mask.data, a.data),
_mm_andnot_ps (mask.data, b.data)
2018-03-16 11:10:44 +11:00
);
#endif
}
//-------------------------------------------------------------------------
bool
all (simd val)
{
2018-03-20 13:30:05 +11:00
return _mm_movemask_ps (val.data) == 0b1111;
2018-03-16 11:10:44 +11:00
}
//-------------------------------------------------------------------------
2018-03-20 13:30:05 +11:00
bool
any (simd val)
2018-03-16 11:10:44 +11:00
{
2018-03-20 13:30:05 +11:00
return _mm_movemask_ps (val.data);
2018-03-16 11:10:44 +11:00
}
///////////////////////////////////////////////////////////////////////////
2018-03-20 13:30:05 +11:00
simd min (simd a, simd b) { return _mm_min_ps (a.data, b.data); }
simd max (simd a, simd b) { return _mm_max_ps (a.data, b.data); }
simd
clamp (simd val, simd lo, simd hi)
{
return min (max (val, lo), hi);
}
2018-03-16 11:10:44 +11:00
///////////////////////////////////////////////////////////////////////////
simd
sum (simd a)
{
2018-03-20 13:30:05 +11:00
auto part = _mm_hadd_ps (a.data, a.data);
2018-03-16 11:10:44 +11:00
return _mm_hadd_ps (part, part);
}
///////////////////////////////////////////////////////////////////////////
#if defined(__SSE4_1__)
simd
dot (simd a, simd b)
{
return _mm_dp_ps (a, b, 0xff);
}
2018-03-20 13:30:05 +11:00
#else
2018-03-16 11:10:44 +11:00
simd
dot (simd a, simd b)
{
2018-03-20 13:30:05 +11:00
return sum (a * b);
2018-03-16 11:10:44 +11:00
}
#endif
///////////////////////////////////////////////////////////////////////////
2018-03-20 13:30:05 +11:00
simd sqrt (simd a) { return _mm_sqrt_ps (a.data); }
simd rsqrt (simd a) { return _mm_rsqrt_ps (a.data); }
2018-03-16 11:10:44 +11:00
///////////////////////////////////////////////////////////////////////////
simd
norm2 (simd a)
{
return dot (a, a);
}
//-------------------------------------------------------------------------
simd
norm (simd a)
{
return sqrt (norm2 (a));
}
//-------------------------------------------------------------------------
simd
normalised (simd a)
{
return a * rsqrt (norm (a));
}
///////////////////////////////////////////////////////////////////////////
auto
abs (simd a)
{
auto bffff = _mm_set1_epi32 (-1);
auto b7fff = _mm_srli_epi32 (bffff, 1);
auto mask = _mm_castsi128_ps (b7fff);
2018-03-20 13:30:05 +11:00
return _mm_and_ps (mask, a.data);
2018-03-16 11:10:44 +11:00
}
///////////////////////////////////////////////////////////////////////////
simd
hypot (simd a)
{
return sqrt (sum (a * a));
}
///////////////////////////////////////////////////////////////////////////
simd::operator bool() const
{
return all (data);
}
2018-03-20 13:30:05 +11:00
2018-03-22 16:10:06 +11:00
///////////////////////////////////////////////////////////////////////////
std::ostream& operator<< (std::ostream &os, simd val);
2018-03-16 11:10:44 +11:00
}
#endif