mirror of
https://github.com/PaddlePaddle/FastDeploy.git
synced 2025-10-07 01:22:59 +08:00
609 lines
26 KiB
C++
609 lines
26 KiB
C++
// This file is part of Eigen, a lightweight C++ template library
|
|
// for linear algebra.
|
|
//
|
|
// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
|
|
//
|
|
// 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/.
|
|
|
|
#ifdef EIGEN_TEST_PART_1
|
|
#define EIGEN_UNALIGNED_VECTORIZE 1
|
|
#endif
|
|
|
|
#ifdef EIGEN_TEST_PART_2
|
|
#define EIGEN_UNALIGNED_VECTORIZE 0
|
|
#endif
|
|
|
|
#ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
|
|
#undef EIGEN_DEFAULT_TO_ROW_MAJOR
|
|
#endif
|
|
#define EIGEN_DEBUG_ASSIGN
|
|
#include <typeinfo>
|
|
#include "main.h"
|
|
|
|
// Disable "ignoring attributes on template argument"
|
|
// for packet_traits<Packet*>
|
|
// => The only workaround would be to wrap _m128 and the likes
|
|
// within wrappers.
|
|
#if EIGEN_GNUC_AT_LEAST(6, 0)
|
|
#pragma GCC diagnostic ignored "-Wignored-attributes"
|
|
#endif
|
|
|
|
using internal::demangle_flags;
|
|
using internal::demangle_traversal;
|
|
using internal::demangle_unrolling;
|
|
|
|
template <typename Dst, typename Src>
|
|
bool test_assign(const Dst&, const Src&, int traversal, int unrolling) {
|
|
EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst, Src);
|
|
typedef internal::copy_using_evaluator_traits<
|
|
internal::evaluator<Dst>, internal::evaluator<Src>,
|
|
internal::assign_op<typename Dst::Scalar, typename Src::Scalar> >
|
|
traits;
|
|
bool res = traits::Traversal == traversal;
|
|
if (unrolling == InnerUnrolling + CompleteUnrolling)
|
|
res = res && (int(traits::Unrolling) == InnerUnrolling ||
|
|
int(traits::Unrolling) == CompleteUnrolling);
|
|
else
|
|
res = res && int(traits::Unrolling) == unrolling;
|
|
if (!res) {
|
|
std::cerr << "Src: " << demangle_flags(Src::Flags) << std::endl;
|
|
std::cerr << " " << demangle_flags(internal::evaluator<Src>::Flags)
|
|
<< std::endl;
|
|
std::cerr << "Dst: " << demangle_flags(Dst::Flags) << std::endl;
|
|
std::cerr << " " << demangle_flags(internal::evaluator<Dst>::Flags)
|
|
<< std::endl;
|
|
traits::debug();
|
|
std::cerr << " Expected Traversal == " << demangle_traversal(traversal)
|
|
<< " got " << demangle_traversal(traits::Traversal) << "\n";
|
|
std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling)
|
|
<< " got " << demangle_unrolling(traits::Unrolling) << "\n";
|
|
}
|
|
return res;
|
|
}
|
|
|
|
template <typename Dst, typename Src>
|
|
bool test_assign(int traversal, int unrolling) {
|
|
EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst, Src);
|
|
typedef internal::copy_using_evaluator_traits<
|
|
internal::evaluator<Dst>, internal::evaluator<Src>,
|
|
internal::assign_op<typename Dst::Scalar, typename Src::Scalar> >
|
|
traits;
|
|
bool res = traits::Traversal == traversal && traits::Unrolling == unrolling;
|
|
if (!res) {
|
|
std::cerr << "Src: " << demangle_flags(Src::Flags) << std::endl;
|
|
std::cerr << " " << demangle_flags(internal::evaluator<Src>::Flags)
|
|
<< std::endl;
|
|
std::cerr << "Dst: " << demangle_flags(Dst::Flags) << std::endl;
|
|
std::cerr << " " << demangle_flags(internal::evaluator<Dst>::Flags)
|
|
<< std::endl;
|
|
traits::debug();
|
|
std::cerr << " Expected Traversal == " << demangle_traversal(traversal)
|
|
<< " got " << demangle_traversal(traits::Traversal) << "\n";
|
|
std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling)
|
|
<< " got " << demangle_unrolling(traits::Unrolling) << "\n";
|
|
}
|
|
return res;
|
|
}
|
|
|
|
template <typename Xpr>
|
|
bool test_redux(const Xpr&, int traversal, int unrolling) {
|
|
typedef typename Xpr::Scalar Scalar;
|
|
typedef internal::redux_traits<internal::scalar_sum_op<Scalar, Scalar>,
|
|
internal::redux_evaluator<Xpr> >
|
|
traits;
|
|
|
|
bool res = traits::Traversal == traversal && traits::Unrolling == unrolling;
|
|
if (!res) {
|
|
std::cerr << demangle_flags(Xpr::Flags) << std::endl;
|
|
std::cerr << demangle_flags(internal::evaluator<Xpr>::Flags) << std::endl;
|
|
traits::debug();
|
|
|
|
std::cerr << " Expected Traversal == " << demangle_traversal(traversal)
|
|
<< " got " << demangle_traversal(traits::Traversal) << "\n";
|
|
std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling)
|
|
<< " got " << demangle_unrolling(traits::Unrolling) << "\n";
|
|
}
|
|
return res;
|
|
}
|
|
|
|
template <typename Scalar,
|
|
bool Enable = internal::packet_traits<Scalar>::Vectorizable>
|
|
struct vectorization_logic {
|
|
typedef internal::packet_traits<Scalar> PacketTraits;
|
|
|
|
typedef typename internal::packet_traits<Scalar>::type PacketType;
|
|
typedef typename internal::unpacket_traits<PacketType>::half HalfPacketType;
|
|
enum {
|
|
PacketSize = internal::unpacket_traits<PacketType>::size,
|
|
HalfPacketSize = internal::unpacket_traits<HalfPacketType>::size
|
|
};
|
|
static void run() {
|
|
typedef Matrix<Scalar, PacketSize, 1> Vector1;
|
|
typedef Matrix<Scalar, Dynamic, 1> VectorX;
|
|
typedef Matrix<Scalar, Dynamic, Dynamic> MatrixXX;
|
|
typedef Matrix<Scalar, PacketSize, PacketSize> Matrix11;
|
|
typedef Matrix<Scalar, (Matrix11::Flags & RowMajorBit) ? 8 : 2 * PacketSize,
|
|
(Matrix11::Flags & RowMajorBit) ? 2 * PacketSize : 8>
|
|
Matrix22;
|
|
typedef Matrix<Scalar,
|
|
(Matrix11::Flags & RowMajorBit) ? 16 : 4 * PacketSize,
|
|
(Matrix11::Flags & RowMajorBit) ? 4 * PacketSize : 16>
|
|
Matrix44;
|
|
typedef Matrix<Scalar,
|
|
(Matrix11::Flags & RowMajorBit) ? 16 : 4 * PacketSize,
|
|
(Matrix11::Flags & RowMajorBit) ? 4 * PacketSize : 16,
|
|
DontAlign | EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION>
|
|
Matrix44u;
|
|
typedef Matrix<Scalar, 4 * PacketSize, 4 * PacketSize, ColMajor> Matrix44c;
|
|
typedef Matrix<Scalar, 4 * PacketSize, 4 * PacketSize, RowMajor> Matrix44r;
|
|
|
|
typedef Matrix<
|
|
Scalar, (PacketSize == 16
|
|
? 8
|
|
: PacketSize == 8 ? 4 : PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? 1
|
|
: /*PacketSize==1 ?*/ 1),
|
|
(PacketSize == 16 ? 2 : PacketSize == 8
|
|
? 2
|
|
: PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? 2
|
|
: /*PacketSize==1 ?*/ 1)>
|
|
Matrix1;
|
|
|
|
typedef Matrix<
|
|
Scalar, (PacketSize == 16
|
|
? 8
|
|
: PacketSize == 8 ? 4 : PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? 1
|
|
: /*PacketSize==1 ?*/ 1),
|
|
(PacketSize == 16 ? 2 : PacketSize == 8
|
|
? 2
|
|
: PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? 2
|
|
: /*PacketSize==1 ?*/ 1),
|
|
DontAlign | ((Matrix1::Flags & RowMajorBit) ? RowMajor : ColMajor)>
|
|
Matrix1u;
|
|
|
|
// this type is made such that it can only be vectorized when viewed as a
|
|
// linear 1D vector
|
|
typedef Matrix<
|
|
Scalar,
|
|
(PacketSize == 16
|
|
? 4
|
|
: PacketSize == 8
|
|
? 4
|
|
: PacketSize == 4
|
|
? 6
|
|
: PacketSize == 2
|
|
? ((Matrix11::Flags & RowMajorBit) ? 2 : 3)
|
|
: /*PacketSize==1 ?*/ 1),
|
|
(PacketSize == 16
|
|
? 12
|
|
: PacketSize == 8
|
|
? 6
|
|
: PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? ((Matrix11::Flags & RowMajorBit) ? 3 : 2)
|
|
: /*PacketSize==1 ?*/ 3)>
|
|
Matrix3;
|
|
|
|
#if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
|
|
VERIFY(test_assign(Vector1(), Vector1(), InnerVectorizedTraversal,
|
|
CompleteUnrolling));
|
|
VERIFY(test_assign(Vector1(), Vector1() + Vector1(),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
VERIFY(test_assign(Vector1(), Vector1().cwiseProduct(Vector1()),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
VERIFY(test_assign(Vector1(), Vector1().template cast<Scalar>(),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix44(), Matrix44() + Matrix44(),
|
|
InnerVectorizedTraversal, InnerUnrolling));
|
|
|
|
VERIFY(test_assign(
|
|
Matrix44u(), Matrix44() + Matrix44(),
|
|
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearTraversal,
|
|
EIGEN_UNALIGNED_VECTORIZE ? InnerUnrolling : NoUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix1(), Matrix1() + Matrix1(),
|
|
(Matrix1::InnerSizeAtCompileTime % PacketSize) == 0
|
|
? InnerVectorizedTraversal
|
|
: LinearVectorizedTraversal,
|
|
CompleteUnrolling));
|
|
|
|
VERIFY(
|
|
test_assign(Matrix1u(), Matrix1() + Matrix1(),
|
|
EIGEN_UNALIGNED_VECTORIZE
|
|
? ((Matrix1::InnerSizeAtCompileTime % PacketSize) == 0
|
|
? InnerVectorizedTraversal
|
|
: LinearVectorizedTraversal)
|
|
: LinearTraversal,
|
|
CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix44c().col(1),
|
|
Matrix44c().col(2) + Matrix44c().col(3),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix44r().row(2),
|
|
Matrix44r().row(1) + Matrix44r().row(1),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
|
|
if (PacketSize > 1) {
|
|
typedef Matrix<Scalar, 3, 3, ColMajor> Matrix33c;
|
|
typedef Matrix<Scalar, 3, 1, ColMajor> Vector3;
|
|
VERIFY(test_assign(Matrix33c().row(2),
|
|
Matrix33c().row(1) + Matrix33c().row(1),
|
|
LinearTraversal, CompleteUnrolling));
|
|
VERIFY(test_assign(Vector3(), Vector3() + Vector3(),
|
|
sizeof(Scalar) == 16 ? InnerVectorizedTraversal
|
|
: (EIGEN_UNALIGNED_VECTORIZE
|
|
? LinearVectorizedTraversal
|
|
: LinearTraversal),
|
|
CompleteUnrolling));
|
|
VERIFY(test_assign(
|
|
Matrix33c().col(0), Matrix33c().col(1) + Matrix33c().col(1),
|
|
EIGEN_UNALIGNED_VECTORIZE
|
|
? (sizeof(Scalar) == 16 ? InnerVectorizedTraversal
|
|
: LinearVectorizedTraversal)
|
|
: (sizeof(Scalar) == 16 ? SliceVectorizedTraversal
|
|
: LinearTraversal),
|
|
((!EIGEN_UNALIGNED_VECTORIZE) && (sizeof(Scalar) == 16))
|
|
? NoUnrolling
|
|
: CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix3(), Matrix3().cwiseProduct(Matrix3()),
|
|
LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix<Scalar, 17, 17>(),
|
|
Matrix<Scalar, 17, 17>() + Matrix<Scalar, 17, 17>(),
|
|
sizeof(Scalar) == 16 ? InnerVectorizedTraversal
|
|
: EIGEN_UNALIGNED_VECTORIZE
|
|
? LinearVectorizedTraversal
|
|
: LinearTraversal,
|
|
NoUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix11(), Matrix11() + Matrix11(),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(
|
|
Matrix11(),
|
|
Matrix<Scalar, 21, 21>().template block<PacketSize, PacketSize>(2,
|
|
3) +
|
|
Matrix<Scalar, 21, 21>().template block<PacketSize, PacketSize>(
|
|
3, 2),
|
|
(EIGEN_UNALIGNED_VECTORIZE) ? InnerVectorizedTraversal
|
|
: DefaultTraversal,
|
|
CompleteUnrolling | InnerUnrolling));
|
|
|
|
VERIFY(test_assign(Vector1(), Matrix11() * Vector1(),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix11(), Matrix11().lazyProduct(Matrix11()),
|
|
InnerVectorizedTraversal,
|
|
InnerUnrolling + CompleteUnrolling));
|
|
}
|
|
|
|
VERIFY(test_redux(Vector1(), LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_redux(Vector1().array() * Vector1().array(),
|
|
LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_redux((Vector1().array() * Vector1().array()).col(0),
|
|
LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_redux(Matrix<Scalar, PacketSize, 3>(),
|
|
LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_redux(Matrix3(), LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_redux(Matrix44(), LinearVectorizedTraversal, NoUnrolling));
|
|
|
|
if (PacketSize > 1) {
|
|
VERIFY(
|
|
test_redux(Matrix44().template block < (Matrix1::Flags & RowMajorBit)
|
|
? 4
|
|
: PacketSize,
|
|
(Matrix1::Flags & RowMajorBit) ? PacketSize : 4 > (1, 2),
|
|
SliceVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(
|
|
test_redux(Matrix44().template block < (Matrix1::Flags & RowMajorBit)
|
|
? 2
|
|
: PacketSize,
|
|
(Matrix1::Flags & RowMajorBit) ? PacketSize : 2 > (1, 2),
|
|
DefaultTraversal, CompleteUnrolling));
|
|
}
|
|
|
|
VERIFY(test_redux(Matrix44c().template block<2 * PacketSize, 1>(1, 2),
|
|
LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_redux(Matrix44r().template block<1, 2 * PacketSize>(2, 1),
|
|
LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(
|
|
(test_assign<Map<Matrix22, AlignedMax, OuterStride<3 * PacketSize> >,
|
|
Matrix22>(InnerVectorizedTraversal, CompleteUnrolling)));
|
|
|
|
VERIFY((test_assign<Map<Matrix<Scalar, EIGEN_PLAIN_ENUM_MAX(2, PacketSize),
|
|
EIGEN_PLAIN_ENUM_MAX(2, PacketSize)>,
|
|
AlignedMax, InnerStride<3 * PacketSize> >,
|
|
Matrix<Scalar, EIGEN_PLAIN_ENUM_MAX(2, PacketSize),
|
|
EIGEN_PLAIN_ENUM_MAX(2, PacketSize)> >(
|
|
DefaultTraversal,
|
|
PacketSize >= 8 ? InnerUnrolling : CompleteUnrolling)));
|
|
|
|
VERIFY((test_assign(
|
|
Matrix11(),
|
|
Matrix<Scalar, PacketSize, EIGEN_PLAIN_ENUM_MIN(2, PacketSize)>() *
|
|
Matrix<Scalar, EIGEN_PLAIN_ENUM_MIN(2, PacketSize), PacketSize>(),
|
|
InnerVectorizedTraversal, CompleteUnrolling)));
|
|
#endif
|
|
|
|
VERIFY(test_assign(MatrixXX(10, 10), MatrixXX(20, 20).block(10, 10, 2, 3),
|
|
SliceVectorizedTraversal, NoUnrolling));
|
|
|
|
VERIFY(test_redux(VectorX(10), LinearVectorizedTraversal, NoUnrolling));
|
|
}
|
|
};
|
|
|
|
template <typename Scalar>
|
|
struct vectorization_logic<Scalar, false> {
|
|
static void run() {}
|
|
};
|
|
|
|
template <typename Scalar,
|
|
bool Enable = !internal::is_same<
|
|
typename internal::unpacket_traits<
|
|
typename internal::packet_traits<Scalar>::type>::half,
|
|
typename internal::packet_traits<Scalar>::type>::value>
|
|
struct vectorization_logic_half {
|
|
typedef internal::packet_traits<Scalar> PacketTraits;
|
|
typedef typename internal::unpacket_traits<
|
|
typename internal::packet_traits<Scalar>::type>::half PacketType;
|
|
enum { PacketSize = internal::unpacket_traits<PacketType>::size };
|
|
static void run() {
|
|
typedef Matrix<Scalar, PacketSize, 1> Vector1;
|
|
typedef Matrix<Scalar, PacketSize, PacketSize> Matrix11;
|
|
typedef Matrix<Scalar, 5 * PacketSize, 7, ColMajor> Matrix57;
|
|
typedef Matrix<Scalar, 3 * PacketSize, 5, ColMajor> Matrix35;
|
|
typedef Matrix<Scalar, 5 * PacketSize, 7, DontAlign | ColMajor> Matrix57u;
|
|
|
|
typedef Matrix<
|
|
Scalar, (PacketSize == 16
|
|
? 8
|
|
: PacketSize == 8 ? 4 : PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? 1
|
|
: /*PacketSize==1 ?*/ 1),
|
|
(PacketSize == 16 ? 2 : PacketSize == 8
|
|
? 2
|
|
: PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? 2
|
|
: /*PacketSize==1 ?*/ 1)>
|
|
Matrix1;
|
|
|
|
typedef Matrix<
|
|
Scalar, (PacketSize == 16
|
|
? 8
|
|
: PacketSize == 8 ? 4 : PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? 1
|
|
: /*PacketSize==1 ?*/ 1),
|
|
(PacketSize == 16 ? 2 : PacketSize == 8
|
|
? 2
|
|
: PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? 2
|
|
: /*PacketSize==1 ?*/ 1),
|
|
DontAlign | ((Matrix1::Flags & RowMajorBit) ? RowMajor : ColMajor)>
|
|
Matrix1u;
|
|
|
|
// this type is made such that it can only be vectorized when viewed as a
|
|
// linear 1D vector
|
|
typedef Matrix<
|
|
Scalar,
|
|
(PacketSize == 16
|
|
? 4
|
|
: PacketSize == 8
|
|
? 4
|
|
: PacketSize == 4
|
|
? 6
|
|
: PacketSize == 2
|
|
? ((Matrix11::Flags & RowMajorBit) ? 2 : 3)
|
|
: /*PacketSize==1 ?*/ 1),
|
|
(PacketSize == 16
|
|
? 12
|
|
: PacketSize == 8
|
|
? 6
|
|
: PacketSize == 4
|
|
? 2
|
|
: PacketSize == 2
|
|
? ((Matrix11::Flags & RowMajorBit) ? 3 : 2)
|
|
: /*PacketSize==1 ?*/ 3)>
|
|
Matrix3;
|
|
|
|
#if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
|
|
VERIFY(test_assign(Vector1(), Vector1(), InnerVectorizedTraversal,
|
|
CompleteUnrolling));
|
|
VERIFY(test_assign(Vector1(), Vector1() + Vector1(),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
VERIFY(test_assign(Vector1(),
|
|
Vector1().template segment<PacketSize>(0).derived(),
|
|
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal
|
|
: LinearVectorizedTraversal,
|
|
CompleteUnrolling));
|
|
VERIFY(test_assign(Vector1(), Scalar(2.1) * Vector1() - Vector1(),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
VERIFY(test_assign(
|
|
Vector1(), (Scalar(2.1) * Vector1().template segment<PacketSize>(0) -
|
|
Vector1().template segment<PacketSize>(0))
|
|
.derived(),
|
|
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal
|
|
: LinearVectorizedTraversal,
|
|
CompleteUnrolling));
|
|
VERIFY(test_assign(Vector1(), Vector1().cwiseProduct(Vector1()),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
VERIFY(test_assign(Vector1(), Vector1().template cast<Scalar>(),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix57(), Matrix57() + Matrix57(),
|
|
InnerVectorizedTraversal, InnerUnrolling));
|
|
|
|
VERIFY(test_assign(
|
|
Matrix57u(), Matrix57() + Matrix57(),
|
|
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearTraversal,
|
|
EIGEN_UNALIGNED_VECTORIZE ? InnerUnrolling : NoUnrolling));
|
|
|
|
VERIFY(
|
|
test_assign(Matrix1u(), Matrix1() + Matrix1(),
|
|
EIGEN_UNALIGNED_VECTORIZE
|
|
? ((Matrix1::InnerSizeAtCompileTime % PacketSize) == 0
|
|
? InnerVectorizedTraversal
|
|
: LinearVectorizedTraversal)
|
|
: LinearTraversal,
|
|
CompleteUnrolling));
|
|
|
|
if (PacketSize > 1) {
|
|
typedef Matrix<Scalar, 3, 3, ColMajor> Matrix33c;
|
|
VERIFY(test_assign(Matrix33c().row(2),
|
|
Matrix33c().row(1) + Matrix33c().row(1),
|
|
LinearTraversal, CompleteUnrolling));
|
|
VERIFY(test_assign(
|
|
Matrix33c().col(0), Matrix33c().col(1) + Matrix33c().col(1),
|
|
EIGEN_UNALIGNED_VECTORIZE
|
|
? (sizeof(Scalar) == 16 ? InnerVectorizedTraversal
|
|
: LinearVectorizedTraversal)
|
|
: (sizeof(Scalar) == 16 ? SliceVectorizedTraversal
|
|
: LinearTraversal),
|
|
((!EIGEN_UNALIGNED_VECTORIZE) && (sizeof(Scalar) == 16))
|
|
? NoUnrolling
|
|
: CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(
|
|
Matrix3(), Matrix3().cwiseQuotient(Matrix3()),
|
|
PacketTraits::HasDiv ? LinearVectorizedTraversal : LinearTraversal,
|
|
CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix<Scalar, 17, 17>(),
|
|
Matrix<Scalar, 17, 17>() + Matrix<Scalar, 17, 17>(),
|
|
sizeof(Scalar) == 16 ? InnerVectorizedTraversal
|
|
: (EIGEN_UNALIGNED_VECTORIZE
|
|
? LinearVectorizedTraversal
|
|
: LinearTraversal),
|
|
NoUnrolling));
|
|
|
|
VERIFY(test_assign(
|
|
Matrix11(),
|
|
Matrix<Scalar, 17, 17>().template block<PacketSize, PacketSize>(2,
|
|
3) +
|
|
Matrix<Scalar, 17, 17>().template block<PacketSize, PacketSize>(
|
|
8, 4),
|
|
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal
|
|
: DefaultTraversal,
|
|
InnerUnrolling + CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Vector1(), Matrix11() * Vector1(),
|
|
InnerVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_assign(Matrix11(), Matrix11().lazyProduct(Matrix11()),
|
|
InnerVectorizedTraversal,
|
|
InnerUnrolling + CompleteUnrolling));
|
|
}
|
|
|
|
VERIFY(test_redux(Vector1(), LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_redux(Matrix<Scalar, PacketSize, 3>(),
|
|
LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(test_redux(Matrix3(), LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(
|
|
test_redux(Matrix35(), LinearVectorizedTraversal, CompleteUnrolling));
|
|
|
|
VERIFY(
|
|
test_redux(Matrix57().template block < PacketSize == 1 ? 2 : PacketSize,
|
|
3 > (1, 0), SliceVectorizedTraversal, CompleteUnrolling));
|
|
|
|
if (PacketSize > 1) {
|
|
VERIFY(test_redux(Matrix57().template block<PacketSize, 2>(1, 0),
|
|
DefaultTraversal, CompleteUnrolling));
|
|
}
|
|
|
|
VERIFY((test_assign<Map<Matrix<Scalar, EIGEN_PLAIN_ENUM_MAX(2, PacketSize),
|
|
EIGEN_PLAIN_ENUM_MAX(2, PacketSize)>,
|
|
AlignedMax, InnerStride<3 * PacketSize> >,
|
|
Matrix<Scalar, EIGEN_PLAIN_ENUM_MAX(2, PacketSize),
|
|
EIGEN_PLAIN_ENUM_MAX(2, PacketSize)> >(
|
|
DefaultTraversal,
|
|
PacketSize > 4 ? InnerUnrolling : CompleteUnrolling)));
|
|
|
|
VERIFY((test_assign(
|
|
Matrix57(),
|
|
Matrix<Scalar, 5 * PacketSize, 3>() * Matrix<Scalar, 3, 7>(),
|
|
InnerVectorizedTraversal, InnerUnrolling + CompleteUnrolling)));
|
|
#endif
|
|
}
|
|
};
|
|
|
|
template <typename Scalar>
|
|
struct vectorization_logic_half<Scalar, false> {
|
|
static void run() {}
|
|
};
|
|
|
|
EIGEN_DECLARE_TEST(vectorization_logic) {
|
|
#ifdef EIGEN_VECTORIZE
|
|
|
|
CALL_SUBTEST(vectorization_logic<int>::run());
|
|
CALL_SUBTEST(vectorization_logic<float>::run());
|
|
CALL_SUBTEST(vectorization_logic<double>::run());
|
|
CALL_SUBTEST(vectorization_logic<std::complex<float> >::run());
|
|
CALL_SUBTEST(vectorization_logic<std::complex<double> >::run());
|
|
|
|
CALL_SUBTEST(vectorization_logic_half<int>::run());
|
|
CALL_SUBTEST(vectorization_logic_half<float>::run());
|
|
CALL_SUBTEST(vectorization_logic_half<double>::run());
|
|
CALL_SUBTEST(vectorization_logic_half<std::complex<float> >::run());
|
|
CALL_SUBTEST(vectorization_logic_half<std::complex<double> >::run());
|
|
|
|
if (internal::packet_traits<float>::Vectorizable) {
|
|
VERIFY(test_assign(
|
|
Matrix<float, 3, 3>(), Matrix<float, 3, 3>() + Matrix<float, 3, 3>(),
|
|
EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal,
|
|
CompleteUnrolling));
|
|
|
|
VERIFY(test_redux(Matrix<float, 5, 2>(),
|
|
EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal
|
|
: DefaultTraversal,
|
|
CompleteUnrolling));
|
|
}
|
|
|
|
if (internal::packet_traits<double>::Vectorizable) {
|
|
VERIFY(test_assign(
|
|
Matrix<double, 3, 3>(), Matrix<double, 3, 3>() + Matrix<double, 3, 3>(),
|
|
EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal,
|
|
CompleteUnrolling));
|
|
|
|
VERIFY(test_redux(Matrix<double, 7, 3>(),
|
|
EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal
|
|
: DefaultTraversal,
|
|
CompleteUnrolling));
|
|
}
|
|
#endif // EIGEN_VECTORIZE
|
|
}
|