From 2e099e8d8f43523b5ac300ae508a7a085ec8c0f3 Mon Sep 17 00:00:00 2001 From: Srinivas Vasudevan Date: Sat, 11 Jan 2020 10:31:21 +0000 Subject: Added special_packetmath test and tweaked bounds on tests. Refactor shared packetmath code to header file. (Squashed from PR !38) --- test/packetmath_test_shared.h | 225 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 225 insertions(+) create mode 100644 test/packetmath_test_shared.h (limited to 'test/packetmath_test_shared.h') diff --git a/test/packetmath_test_shared.h b/test/packetmath_test_shared.h new file mode 100644 index 000000000..046fd8104 --- /dev/null +++ b/test/packetmath_test_shared.h @@ -0,0 +1,225 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// This Source Code Form is subject to the terms of the Mozilla +// Public License v. 2.0. If a copy of the MPL was not distributed +// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#include "main.h" +#include + +#if defined __GNUC__ && __GNUC__>=6 + #pragma GCC diagnostic ignored "-Wignored-attributes" +#endif +// using namespace Eigen; + +#ifdef EIGEN_VECTORIZE_SSE +const bool g_vectorize_sse = true; +#else +const bool g_vectorize_sse = false; +#endif + +bool g_first_pass = true; + +namespace Eigen { +namespace internal { + +template T negate(const T& x) { return -x; } + +template +Map > +bits(const T& x) { + return Map >(reinterpret_cast(&x)); +} + +// The following implement bitwise operations on floating point types +template +T apply_bit_op(Bits a, Bits b, Func f) { + Array data; + T res; + for(Index i = 0; i < data.size(); ++i) + data[i] = f(a[i], b[i]); + // Note: The reinterpret_cast works around GCC's class-memaccess warnings: + std::memcpy(reinterpret_cast(&res), data.data(), sizeof(T)); + return res; +} + +#define EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,T) \ + template<> T EIGEN_CAT(p,OP)(const T& a,const T& b) { \ + return apply_bit_op(bits(a),bits(b),FUNC); \ + } + +#define EIGEN_TEST_MAKE_BITWISE(OP,FUNC) \ + EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,float) \ + EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,double) \ + EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,half) \ + EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,std::complex) \ + EIGEN_TEST_MAKE_BITWISE2(OP,FUNC,std::complex) + +EIGEN_TEST_MAKE_BITWISE(xor,std::bit_xor()) +EIGEN_TEST_MAKE_BITWISE(and,std::bit_and()) +EIGEN_TEST_MAKE_BITWISE(or, std::bit_or()) +struct bit_andnot{ + template T + operator()(T a, T b) const { return a & (~b); } +}; +EIGEN_TEST_MAKE_BITWISE(andnot, bit_andnot()) +template +bool biteq(T a, T b) { + return (bits(a) == bits(b)).all(); +} + +} + +namespace test { + +// NOTE: we disable inlining for this function to workaround a GCC issue when using -O3 and the i387 FPU. +template EIGEN_DONT_INLINE +bool isApproxAbs(const Scalar& a, const Scalar& b, const typename NumTraits::Real& refvalue) +{ + return internal::isMuchSmallerThan(a-b, refvalue); +} + +template bool areApproxAbs(const Scalar* a, const Scalar* b, int size, const typename NumTraits::Real& refvalue) +{ + for (int i=0; i >(a,size) << "]" << " != vec: [" << Map >(b,size) << "]\n"; + return false; + } + } + return true; +} + +template bool areApprox(const Scalar* a, const Scalar* b, int size) +{ + for (int i=0; i >(a,size) << "]" << " != vec: [" << Map >(b,size) << "]\n"; + return false; + } + } + return true; +} + +#define CHECK_CWISE1(REFOP, POP) { \ + for (int i=0; i(data1))); \ + VERIFY(test::areApprox(ref, data2, PacketSize) && #POP); \ +} + +template +struct packet_helper +{ + template + inline Packet load(const T* from) const { return internal::pload(from); } + + template + inline Packet loadu(const T* from) const { return internal::ploadu(from); } + + template + inline Packet load(const T* from, unsigned long long umask) const { return internal::ploadu(from, umask); } + + template + inline void store(T* to, const Packet& x) const { internal::pstore(to,x); } + + template + inline void store(T* to, const Packet& x, unsigned long long umask) const { internal::pstoreu(to, x, umask); } +}; + +template +struct packet_helper +{ + template + inline T load(const T* from) const { return *from; } + + template + inline T loadu(const T* from) const { return *from; } + + template + inline T load(const T* from, unsigned long long) const { return *from; } + + template + inline void store(T* to, const T& x) const { *to = x; } + + template + inline void store(T* to, const T& x, unsigned long long) const { *to = x; } +}; + +#define CHECK_CWISE1_IF(COND, REFOP, POP) if(COND) { \ + test::packet_helper h; \ + for (int i=0; i h; \ + for (int i=0; i h; \ + for (int i = 0; i < PacketSize; ++i) \ + ref[i] = \ + REFOP(data1[i], data1[i + PacketSize], data1[i + 2 * PacketSize]); \ + h.store(data2, POP(h.load(data1), h.load(data1 + PacketSize), \ + h.load(data1 + 2 * PacketSize))); \ + VERIFY(test::areApprox(ref, data2, PacketSize) && #POP); \ +} + +// Specialize the runall struct in your test file by defining run(). +template< + typename Scalar, + typename PacketType, + bool IsComplex = NumTraits::IsComplex, + bool IsInteger = NumTraits::IsInteger> +struct runall; + +template< + typename Scalar, + typename PacketType = typename internal::packet_traits::type, + bool Vectorized = internal::packet_traits::Vectorizable, + bool HasHalf = !internal::is_same::half,PacketType>::value > +struct runner; + +template +struct runner +{ + static void run() { + runall::run(); + runner::half>::run(); + } +}; + +template +struct runner +{ + static void run() { + runall::run(); + runall::run(); + } +}; + +template +struct runner +{ + static void run() { + runall::run(); + } +}; + +} +} -- cgit v1.2.3