mirror/eigen
2
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2024-12-21 07:19:46 +08:00
Code Issues Packages Projects Releases Wiki Activity
73985ead27
eigen/test/vectorization_logic.cpp

420 lines
20 KiB
C++
Raw Normal View History

Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
// This file is part of Eigen, a lightweight C++ template library
remove sentence "Eigen itself is part of the KDE project." it never made very precise sense. but now does it still make any?
2009-05-23 02:25:33 +08:00
// for linear algebra.
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
//
Fix unit tests wrt EIGEN_DEFAULT_TO_ROW_MAJOR
2015-12-11 17:06:28 +08:00
// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
//
Automatic relicensing to MPL2 using Keirs script. Manual fixup follows.
2012-07-14 02:42:47 +08:00
// 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/.
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
#ifdef EIGEN_TEST_PART_1
#define EIGEN_UNALIGNED_VECTORIZE 1
#endif
#ifdef EIGEN_TEST_PART_2
#define EIGEN_UNALIGNED_VECTORIZE 0
#endif
Fix unit tests wrt EIGEN_DEFAULT_TO_ROW_MAJOR
2015-12-11 17:06:28 +08:00
#ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
#undef EIGEN_DEFAULT_TO_ROW_MAJOR
#endif
Only include <iosfwd> unless either EIGEN_DEBUG_ASSIGN is defined or we're in eigen2 support mode
2010-02-28 08:04:22 +08:00
#define EIGEN_DEBUG_ASSIGN
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
#include "main.h"
#include <typeinfo>
Improve readibility of EIGEN_DEBUG_ASSIGN mode.
2015-10-27 17:38:49 +08:00
using internal::demangle_flags;
using internal::demangle_traversal;
using internal::demangle_unrolling;
extend vectorization_logic
2010-07-09 05:30:16 +08:00
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
template<typename Dst, typename Src>
Assign.h: add LinearTraversal (non-vectorized index-based traversal) Rename some constants to make names match more closely what they mean.
2009-11-19 00:57:07 +08:00
bool test_assign(const Dst&, const Src&, int traversal, int unrolling)
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
{
Relax mixing-type constraints for binary coefficient-wise operators: - Replace internal::scalar_product_traits<A,B> by Eigen::ScalarBinaryOpTraits<A,B,OP> - Remove the "functor_is_product_like" helper (was pretty ugly) - Currently, OP is not used, but it is available to the user for fine grained tuning - Currently, only the following operators have been generalized: *,/,+,-,=,*=,/=,+=,-= - TODO: generalize all other binray operators (comparisons,pow,etc.) - TODO: handle "scalar op array" operators (currently only * is handled) - TODO: move the handling of the "void" scalar type to ScalarBinaryOpTraits
2016-06-06 21:11:41 +08:00
typedef internal::copy_using_evaluator_traits<internal::evaluator<Dst>,internal::evaluator<Src>, internal::assign_op<typename Dst::Scalar,typename Src::Scalar> > traits;
Add regression unit tests for half-packet vectorization
2016-04-14 00:16:35 +08:00
bool res = traits::Traversal==traversal;
if(unrolling==InnerUnrolling+CompleteUnrolling)
Fix warning in unit tests
2016-04-14 04:00:38 +08:00
res = res && (int(traits::Unrolling)==InnerUnrolling || int(traits::Unrolling)==CompleteUnrolling);
Add regression unit tests for half-packet vectorization
2016-04-14 00:16:35 +08:00
else
Fix warning in unit tests
2016-04-14 04:00:38 +08:00
res = res && int(traits::Unrolling)==unrolling;
extend vectorization_logic
2010-07-09 05:30:16 +08:00
if(!res)
{
More debug info and use lazyProd instead of operator* to query the right flags
2014-03-13 01:14:58 +08:00
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();
extend vectorization_logic
2010-07-09 05:30:16 +08:00
std::cerr << " Expected Traversal == " << demangle_traversal(traversal)
More debug info and use lazyProd instead of operator* to query the right flags
2014-03-13 01:14:58 +08:00
<< " got " << demangle_traversal(traits::Traversal) << "\n";
extend vectorization_logic
2010-07-09 05:30:16 +08:00
std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling)
More debug info and use lazyProd instead of operator* to query the right flags
2014-03-13 01:14:58 +08:00
<< " got " << demangle_unrolling(traits::Unrolling) << "\n";
extend vectorization_logic
2010-07-09 05:30:16 +08:00
}
return res;
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
}
Fix Map-with-Stride and cover it by new unit tests.
2010-02-27 09:12:51 +08:00
template<typename Dst, typename Src>
bool test_assign(int traversal, int unrolling)
{
Relax mixing-type constraints for binary coefficient-wise operators: - Replace internal::scalar_product_traits<A,B> by Eigen::ScalarBinaryOpTraits<A,B,OP> - Remove the "functor_is_product_like" helper (was pretty ugly) - Currently, OP is not used, but it is available to the user for fine grained tuning - Currently, only the following operators have been generalized: *,/,+,-,=,*=,/=,+=,-= - TODO: generalize all other binray operators (comparisons,pow,etc.) - TODO: handle "scalar op array" operators (currently only * is handled) - TODO: move the handling of the "void" scalar type to ScalarBinaryOpTraits
2016-06-06 21:11:41 +08:00
typedef internal::copy_using_evaluator_traits<internal::evaluator<Dst>,internal::evaluator<Src>, internal::assign_op<typename Dst::Scalar,typename Src::Scalar> > traits;
More debug info and use lazyProd instead of operator* to query the right flags
2014-03-13 01:14:58 +08:00
bool res = traits::Traversal==traversal && traits::Unrolling==unrolling;
extend vectorization_logic
2010-07-09 05:30:16 +08:00
if(!res)
{
More debug info and use lazyProd instead of operator* to query the right flags
2014-03-13 01:14:58 +08:00
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();
extend vectorization_logic
2010-07-09 05:30:16 +08:00
std::cerr << " Expected Traversal == " << demangle_traversal(traversal)
More debug info and use lazyProd instead of operator* to query the right flags
2014-03-13 01:14:58 +08:00
<< " got " << demangle_traversal(traits::Traversal) << "\n";
extend vectorization_logic
2010-07-09 05:30:16 +08:00
std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling)
More debug info and use lazyProd instead of operator* to query the right flags
2014-03-13 01:14:58 +08:00
<< " got " << demangle_unrolling(traits::Unrolling) << "\n";
extend vectorization_logic
2010-07-09 05:30:16 +08:00
}
return res;
Fix Map-with-Stride and cover it by new unit tests.
2010-02-27 09:12:51 +08:00
}
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
template<typename Xpr>
Assign.h: add LinearTraversal (non-vectorized index-based traversal) Rename some constants to make names match more closely what they mean.
2009-11-19 00:57:07 +08:00
bool test_redux(const Xpr&, int traversal, int unrolling)
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
{
Relax mixing-type constraints for binary coefficient-wise operators: - Replace internal::scalar_product_traits<A,B> by Eigen::ScalarBinaryOpTraits<A,B,OP> - Remove the "functor_is_product_like" helper (was pretty ugly) - Currently, OP is not used, but it is available to the user for fine grained tuning - Currently, only the following operators have been generalized: *,/,+,-,=,*=,/=,+=,-= - TODO: generalize all other binray operators (comparisons,pow,etc.) - TODO: handle "scalar op array" operators (currently only * is handled) - TODO: move the handling of the "void" scalar type to ScalarBinaryOpTraits
2016-06-06 21:11:41 +08:00
typedef typename Xpr::Scalar Scalar;
typedef internal::redux_traits<internal::scalar_sum_op<Scalar,Scalar>,internal::redux_evaluator<Xpr> > traits;
More debug info and use lazyProd instead of operator* to query the right flags
2014-03-13 01:14:58 +08:00
extend vectorization_logic
2010-07-09 05:30:16 +08:00
bool res = traits::Traversal==traversal && traits::Unrolling==unrolling;
if(!res)
{
More debug info and use lazyProd instead of operator* to query the right flags
2014-03-13 01:14:58 +08:00
std::cerr << demangle_flags(Xpr::Flags) << std::endl;
std::cerr << demangle_flags(internal::evaluator<Xpr>::Flags) << std::endl;
traits::debug();
extend vectorization_logic
2010-07-09 05:30:16 +08:00
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;
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
}
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
template<typename Scalar, bool Enable = internal::packet_traits<Scalar>::Vectorizable>
struct vectorization_logic
extend vectorization_logic
2010-07-09 05:30:16 +08:00
{
Test vectorization logic for int
2014-07-14 20:36:20 +08:00
typedef internal::packet_traits<Scalar> PacketTraits;
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
typedef typename internal::packet_traits<Scalar>::type PacketType;
typedef typename internal::unpacket_traits<PacketType>::half HalfPacketType;
extend vectorization_logic
2010-07-09 05:30:16 +08:00
enum {
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
PacketSize = internal::unpacket_traits<PacketType>::size,
HalfPacketSize = internal::unpacket_traits<HalfPacketType>::size
extend vectorization_logic
2010-07-09 05:30:16 +08:00
};
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,2*PacketSize,2*PacketSize> Matrix22;
fix vectorization_logic unit test when defaulting to row major
2011-01-04 21:18:07 +08:00
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;
Fix 128bit packet size assumptions in unit tests.
2014-04-19 03:14:40 +08:00
typedef Matrix<Scalar,4*PacketSize,4*PacketSize,ColMajor> Matrix44c;
typedef Matrix<Scalar,4*PacketSize,4*PacketSize,RowMajor> Matrix44r;
extend vectorization_logic
2010-07-09 05:30:16 +08:00
typedef Matrix<Scalar,
(PacketSize==8 ? 4 : PacketSize==4 ? 2 : PacketSize==2 ? 1 : /*PacketSize==1 ?*/ 1),
(PacketSize==8 ? 2 : PacketSize==4 ? 2 : PacketSize==2 ? 2 : /*PacketSize==1 ?*/ 1)
> Matrix1;
typedef Matrix<Scalar,
(PacketSize==8 ? 4 : PacketSize==4 ? 2 : PacketSize==2 ? 1 : /*PacketSize==1 ?*/ 1),
(PacketSize==8 ? 2 : PacketSize==4 ? 2 : PacketSize==2 ? 2 : /*PacketSize==1 ?*/ 1),
DontAlign|((Matrix1::Flags&RowMajorBit)?RowMajor:ColMajor)> Matrix1u;
fix vectorization_logic unit test when defaulting to row major
2011-01-04 21:18:07 +08:00
// this type is made such that it can only be vectorized when viewed as a linear 1D vector
extend vectorization_logic
2010-07-09 05:30:16 +08:00
typedef Matrix<Scalar,
fix vectorization_logic unit test when defaulting to row major
2011-01-04 21:18:07 +08:00
(PacketSize==8 ? 4 : PacketSize==4 ? 6 : PacketSize==2 ? ((Matrix11::Flags&RowMajorBit)?2:3) : /*PacketSize==1 ?*/ 1),
(PacketSize==8 ? 6 : PacketSize==4 ? 2 : PacketSize==2 ? ((Matrix11::Flags&RowMajorBit)?3:2) : /*PacketSize==1 ?*/ 3)
extend vectorization_logic
2010-07-09 05:30:16 +08:00
> Matrix3;
fix vectorization_logic when EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
2011-05-20 03:52:40 +08:00
#if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
extend vectorization_logic
2010-07-09 05:30:16 +08:00
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(Vector1(),Vector1(),
InnerVectorizedTraversal,CompleteUnrolling));
VERIFY(test_assign(Vector1(),Vector1()+Vector1(),
InnerVectorizedTraversal,CompleteUnrolling));
VERIFY(test_assign(Vector1(),Vector1().cwiseProduct(Vector1()),
InnerVectorizedTraversal,CompleteUnrolling));
VERIFY(test_assign(Matrix44(),Matrix44()+Matrix44(),
InnerVectorizedTraversal,InnerUnrolling));
VERIFY(test_assign(Matrix44u(),Matrix44()+Matrix44(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearTraversal,
EIGEN_UNALIGNED_VECTORIZE ? InnerUnrolling : NoUnrolling));
VERIFY(test_assign(Matrix1(),Matrix1()+Matrix1(),
(Matrix1::InnerSizeAtCompileTime % PacketSize)==0 ? InnerVectorizedTraversal : LinearVectorizedTraversal,
CompleteUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
VERIFY(test_assign(Matrix1u(),Matrix1()+Matrix1(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? ((Matrix1::InnerSizeAtCompileTime % PacketSize)==0 ? InnerVectorizedTraversal : LinearVectorizedTraversal)
: LinearTraversal, CompleteUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
allow vectorization of mat44.col() by adding a InnerPanel boolean template parameter to Block
2010-07-23 22:29:29 +08:00
VERIFY(test_assign(Matrix44c().col(1),Matrix44c().col(2)+Matrix44c().col(3),
InnerVectorizedTraversal,CompleteUnrolling));
Fixed the vectorization logic test
2016-04-13 05:13:25 +08:00
allow vectorization of mat44.col() by adding a InnerPanel boolean template parameter to Block
2010-07-23 22:29:29 +08:00
VERIFY(test_assign(Matrix44r().row(2),Matrix44r().row(1)+Matrix44r().row(1),
InnerVectorizedTraversal,CompleteUnrolling));
Fixed the vectorization logic test
2016-04-13 05:13:25 +08:00
extend vectorization_logic
2010-07-09 05:30:16 +08:00
if(PacketSize>1)
{
allow vectorization of mat44.col() by adding a InnerPanel boolean template parameter to Block
2010-07-23 22:29:29 +08:00
typedef Matrix<Scalar,3,3,ColMajor> Matrix33c;
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
typedef Matrix<Scalar,3,1,ColMajor> Vector3;
allow vectorization of mat44.col() by adding a InnerPanel boolean template parameter to Block
2010-07-23 22:29:29 +08:00
VERIFY(test_assign(Matrix33c().row(2),Matrix33c().row(1)+Matrix33c().row(1),
LinearTraversal,CompleteUnrolling));
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
VERIFY(test_assign(Vector3(),Vector3()+Vector3(),
EIGEN_UNALIGNED_VECTORIZE ? (HalfPacketSize==1 ? InnerVectorizedTraversal : LinearVectorizedTraversal) : (HalfPacketSize==1 ? InnerVectorizedTraversal : LinearTraversal), CompleteUnrolling));
allow vectorization of mat44.col() by adding a InnerPanel boolean template parameter to Block
2010-07-23 22:29:29 +08:00
VERIFY(test_assign(Matrix33c().col(0),Matrix33c().col(1)+Matrix33c().col(1),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? (HalfPacketSize==1 ? InnerVectorizedTraversal : LinearVectorizedTraversal) : (HalfPacketSize==1 ? SliceVectorizedTraversal : LinearTraversal),
((!EIGEN_UNALIGNED_VECTORIZE) && HalfPacketSize==1) ? NoUnrolling : CompleteUnrolling));
Fixed the vectorization logic test
2016-04-13 05:13:25 +08:00
VERIFY(test_assign(Matrix3(),Matrix3().cwiseProduct(Matrix3()),
LinearVectorizedTraversal,CompleteUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
VERIFY(test_assign(Matrix<Scalar,17,17>(),Matrix<Scalar,17,17>()+Matrix<Scalar,17,17>(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
HalfPacketSize==1 ? InnerVectorizedTraversal :
EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal :
LinearTraversal,
NoUnrolling));
VERIFY(test_assign(Matrix11(), Matrix11()+Matrix11(),InnerVectorizedTraversal,CompleteUnrolling));
Fixed the vectorization logic test
2016-04-13 05:13:25 +08:00
Fix 128bit packet size assumptions in unit tests.
2014-04-19 03:14:40 +08:00
VERIFY(test_assign(Matrix11(),Matrix<Scalar,17,17>().template block<PacketSize,PacketSize>(2,3)+Matrix<Scalar,17,17>().template block<PacketSize,PacketSize>(8,4),
Fix unit test.
2016-07-07 04:25:24 +08:00
(EIGEN_UNALIGNED_VECTORIZE) ? InnerVectorizedTraversal : DefaultTraversal, CompleteUnrolling|InnerUnrolling));
Add regression unit tests for half-packet vectorization
2016-04-14 00:16:35 +08:00
VERIFY(test_assign(Vector1(),Matrix11()*Vector1(),
InnerVectorizedTraversal,CompleteUnrolling));
VERIFY(test_assign(Matrix11(),Matrix11().lazyProduct(Matrix11()),
InnerVectorizedTraversal,InnerUnrolling+CompleteUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
}
Fixed the vectorization logic test
2016-04-13 05:13:25 +08:00
Add regression unit tests for half-packet vectorization
2016-04-14 00:16:35 +08:00
VERIFY(test_redux(Vector1(),
LinearVectorizedTraversal,CompleteUnrolling));
VERIFY(test_redux(Matrix<Scalar,PacketSize,3>(),
LinearVectorizedTraversal,CompleteUnrolling));
fix vectorization_logic when EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
2011-05-20 03:52:40 +08:00
VERIFY(test_redux(Matrix3(),
LinearVectorizedTraversal,CompleteUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
fix vectorization_logic when EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
2011-05-20 03:52:40 +08:00
VERIFY(test_redux(Matrix44(),
LinearVectorizedTraversal,NoUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
fix vectorization_logic when EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
2011-05-20 03:52:40 +08:00
VERIFY(test_redux(Matrix44().template block<(Matrix1::Flags&RowMajorBit)?4:PacketSize,(Matrix1::Flags&RowMajorBit)?PacketSize:4>(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));
Fix 128bit packet size assumptions in unit tests.
2014-04-19 03:14:40 +08:00
extend vectorization_logic
2010-07-09 05:30:16 +08:00
VERIFY((test_assign<
First part of a big refactoring of alignment control to enable the handling of arbitrarily aligned buffers. It includes: - AlignedBit flag is deprecated. Alignment is now specified by the evaluator through the 'Alignment' enum, e.g., evaluator<Xpr>::Alignment. Its value is in Bytes. - Add several enums to specify alignment: Aligned8, Aligned16, Aligned32, Aligned64, Aligned128. AlignedMax corresponds to EIGEN_MAX_ALIGN_BYTES. Such enums are used to define the above Alignment value, and as the 'Options' template parameter of Map<> and Ref<>. - The Aligned enum is now deprecated. It is now an alias for Aligned16. - Currently, traits<Matrix<>>, traits<Array<>>, traits<Ref<>>, traits<Map<>>, and traits<Block<>> also expose the Alignment enum.
2015-08-06 21:31:07 +08:00
Map<Matrix22, AlignedMax, OuterStride<3*PacketSize> >,
extend vectorization_logic
2010-07-09 05:30:16 +08:00
Matrix22
>(InnerVectorizedTraversal,CompleteUnrolling)));
VERIFY((test_assign<
First part of a big refactoring of alignment control to enable the handling of arbitrarily aligned buffers. It includes: - AlignedBit flag is deprecated. Alignment is now specified by the evaluator through the 'Alignment' enum, e.g., evaluator<Xpr>::Alignment. Its value is in Bytes. - Add several enums to specify alignment: Aligned8, Aligned16, Aligned32, Aligned64, Aligned128. AlignedMax corresponds to EIGEN_MAX_ALIGN_BYTES. Such enums are used to define the above Alignment value, and as the 'Options' template parameter of Map<> and Ref<>. - The Aligned enum is now deprecated. It is now an alias for Aligned16. - Currently, traits<Matrix<>>, traits<Array<>>, traits<Ref<>>, traits<Map<>>, and traits<Block<>> also expose the Alignment enum.
2015-08-06 21:31:07 +08:00
Map<Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)>, AlignedMax, InnerStride<3*PacketSize> >,
Fix 128bit packet size assumptions in unit tests.
2014-04-19 03:14:40 +08:00
Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)>
Fix unit test.
2016-07-07 04:25:24 +08:00
>(DefaultTraversal,PacketSize>=8?InnerUnrolling:CompleteUnrolling)));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
Fix 128bit packet size assumptions in unit tests.
2014-04-19 03:14:40 +08:00
VERIFY((test_assign(Matrix11(), Matrix<Scalar,PacketSize,EIGEN_PLAIN_ENUM_MIN(2,PacketSize)>()*Matrix<Scalar,EIGEN_PLAIN_ENUM_MIN(2,PacketSize),PacketSize>(),
bug #973, improve AVX support by enabling vectorization of Vector4i-like types, and enforcing alignement of Vector4f/Vector2d-like types to preserve compatibility with SSE and future Eigen versions that will vectorize them with AVX enabled.
2015-03-14 04:15:50 +08:00
InnerVectorizedTraversal, CompleteUnrolling)));
fix vectorization_logic when EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
2011-05-20 03:52:40 +08:00
#endif
fix severe perf bug: coeff-based matrix products were not considered aligned, typically preventing vectorization. added unit test.
2011-01-03 01:07:39 +08:00
fix vectorization_logic when EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
2011-05-20 03:52:40 +08:00
VERIFY(test_assign(MatrixXX(10,10),MatrixXX(20,20).block(10,10,2,3),
SliceVectorizedTraversal,NoUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
fix vectorization_logic when EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
2011-05-20 03:52:40 +08:00
VERIFY(test_redux(VectorX(10),
extend vectorization_logic
2010-07-09 05:30:16 +08:00
LinearVectorizedTraversal,NoUnrolling));
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
}
};
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;
Add regression unit tests for half-packet vectorization
2016-04-14 00:16:35 +08:00
typedef Matrix<Scalar,3*PacketSize,5,ColMajor> Matrix35;
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
typedef Matrix<Scalar,5*PacketSize,7,DontAlign|ColMajor> Matrix57u;
// 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==8 ? 4 : PacketSize==4 ? 2 : PacketSize==2 ? 1 : /*PacketSize==1 ?*/ 1),
(PacketSize==8 ? 2 : PacketSize==4 ? 2 : PacketSize==2 ? 2 : /*PacketSize==1 ?*/ 1)
> Matrix1;
typedef Matrix<Scalar,
(PacketSize==8 ? 4 : PacketSize==4 ? 2 : PacketSize==2 ? 1 : /*PacketSize==1 ?*/ 1),
(PacketSize==8 ? 2 : PacketSize==4 ? 2 : PacketSize==2 ? 2 : /*PacketSize==1 ?*/ 1),
DontAlign|((Matrix1::Flags&RowMajorBit)?RowMajor:ColMajor)> Matrix1u;
extend vectorization_logic
2010-07-09 05:30:16 +08:00
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
// this type is made such that it can only be vectorized when viewed as a linear 1D vector
typedef Matrix<Scalar,
(PacketSize==8 ? 4 : PacketSize==4 ? 6 : PacketSize==2 ? ((Matrix11::Flags&RowMajorBit)?2:3) : /*PacketSize==1 ?*/ 1),
(PacketSize==8 ? 6 : PacketSize==4 ? 2 : PacketSize==2 ? ((Matrix11::Flags&RowMajorBit)?3:2) : /*PacketSize==1 ?*/ 3)
> Matrix3;
fix vectorization_logic when EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
2011-05-20 03:52:40 +08:00
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
#if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
VERIFY(test_assign(Vector1(),Vector1(),
InnerVectorizedTraversal,CompleteUnrolling));
VERIFY(test_assign(Vector1(),Vector1()+Vector1(),
InnerVectorizedTraversal,CompleteUnrolling));
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
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));
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
VERIFY(test_assign(Vector1(),Vector1().cwiseProduct(Vector1()),
InnerVectorizedTraversal,CompleteUnrolling));
VERIFY(test_assign(Vector1(),Vector1().template cast<Scalar>(),
InnerVectorizedTraversal,CompleteUnrolling));
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(Matrix57(),Matrix57()+Matrix57(),
InnerVectorizedTraversal,InnerUnrolling));
VERIFY(test_assign(Matrix57u(),Matrix57()+Matrix57(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearTraversal,
EIGEN_UNALIGNED_VECTORIZE ? InnerUnrolling : NoUnrolling));
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
VERIFY(test_assign(Matrix1u(),Matrix1()+Matrix1(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? ((Matrix1::InnerSizeAtCompileTime % PacketSize)==0 ? InnerVectorizedTraversal : LinearVectorizedTraversal) : LinearTraversal,CompleteUnrolling));
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
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),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? (PacketSize==1 ? InnerVectorizedTraversal : LinearVectorizedTraversal) : LinearTraversal,CompleteUnrolling));
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
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>(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? (PacketSize==1 ? InnerVectorizedTraversal : LinearVectorizedTraversal) : LinearTraversal,
NoUnrolling));
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
VERIFY(test_assign(Matrix11(),Matrix<Scalar,17,17>().template block<PacketSize,PacketSize>(2,3)+Matrix<Scalar,17,17>().template block<PacketSize,PacketSize>(8,4),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : DefaultTraversal,PacketSize>4?InnerUnrolling:CompleteUnrolling));
Add regression unit tests for half-packet vectorization
2016-04-14 00:16:35 +08:00
VERIFY(test_assign(Vector1(),Matrix11()*Vector1(),
InnerVectorizedTraversal,CompleteUnrolling));
VERIFY(test_assign(Matrix11(),Matrix11().lazyProduct(Matrix11()),
InnerVectorizedTraversal,InnerUnrolling+CompleteUnrolling));
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
}
Add regression unit tests for half-packet vectorization
2016-04-14 00:16:35 +08:00
VERIFY(test_redux(Vector1(),
LinearVectorizedTraversal,CompleteUnrolling));
VERIFY(test_redux(Matrix<Scalar,PacketSize,3>(),
LinearVectorizedTraversal,CompleteUnrolling));
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
VERIFY(test_redux(Matrix3(),
LinearVectorizedTraversal,CompleteUnrolling));
Add regression unit tests for half-packet vectorization
2016-04-14 00:16:35 +08:00
VERIFY(test_redux(Matrix35(),
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
LinearVectorizedTraversal,CompleteUnrolling));
VERIFY(test_redux(Matrix57().template block<PacketSize,3>(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,CompleteUnrolling)));
VERIFY((test_assign(Matrix57(), Matrix<Scalar,5*PacketSize,3>()*Matrix<Scalar,3,7>(),
Fix unit test.
2016-07-07 04:25:24 +08:00
InnerVectorizedTraversal, InnerUnrolling|CompleteUnrolling)));
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
#endif
extend vectorization_logic
2010-07-09 05:30:16 +08:00
}
};
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
template<typename Scalar> struct vectorization_logic_half<Scalar,false>
extend vectorization_logic
2010-07-09 05:30:16 +08:00
{
static void run() {}
};
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
void test_vectorization_logic()
{
#ifdef EIGEN_VECTORIZE
Test vectorization logic for int
2014-07-14 20:36:20 +08:00
CALL_SUBTEST( vectorization_logic<int>::run() );
fix vectorization_logic when EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
2011-05-20 03:52:40 +08:00
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() );
extend vectorization_logic
2010-07-09 05:30:16 +08:00
Enable vectorization with half-packets
2015-08-08 02:05:31 +08:00
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() );
bug #86 : use internal:: namespace instead of ei_ prefix
2010-10-25 22:15:22 +08:00
if(internal::packet_traits<float>::Vectorizable)
extend vectorization_logic
2010-07-09 05:30:16 +08:00
{
VERIFY(test_assign(Matrix<float,3,3>(),Matrix<float,3,3>()+Matrix<float,3,3>(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal,CompleteUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
VERIFY(test_redux(Matrix<float,5,2>(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : DefaultTraversal,CompleteUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
}
bug #86 : use internal:: namespace instead of ei_ prefix
2010-10-25 22:15:22 +08:00
if(internal::packet_traits<double>::Vectorizable)
extend vectorization_logic
2010-07-09 05:30:16 +08:00
{
VERIFY(test_assign(Matrix<double,3,3>(),Matrix<double,3,3>()+Matrix<double,3,3>(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal,CompleteUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
VERIFY(test_redux(Matrix<double,7,3>(),
bug #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining EIGEN_UNALIGNED_VECTORIZE=0
2016-05-25 03:54:03 +08:00
EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : DefaultTraversal,CompleteUnrolling));
extend vectorization_logic
2010-07-09 05:30:16 +08:00
}
Add a vectorization_logic unit test for assign and sum. Need to add dot and more tests, but it seems I've already found some room for improvement in sum.
2009-01-08 06:20:03 +08:00
#endif // EIGEN_VECTORIZE
}
Reference in New Issue Copy Permalink