devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix sanitizer regressions in sparse serializer and packet tests

Browse Source 
libeigen/eigen!2319

Co-authored-by: Rasmus Munk Larsen <rmlarsen@gmail.com>
This commit is contained in:
Rasmus Munk Larsen
2026-03-22 09:10:16 -07:00
parent 835e5615a9
commit 6490b17e6f
7 changed files with 129 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
Eigen/src/Core/GenericPacketMath.h
View File

@@ -821,10 +821,24 @@ EIGEN_DEVICE_FUNC inline Packet pset1(const typename unpacket_traits<Packet>::ty
template <typename Packet, typename BitsType>
EIGEN_DEVICE_FUNC inline Packet pset1frombits(BitsType a);
template <typename Scalar, std::enable_if_t<std::is_trivially_copyable<Scalar>::value, int> = 0>
EIGEN_DEVICE_FUNC inline Scalar pload1_scalar(const Scalar* a) {
Scalar scalar;
EIGEN_USING_STD(memcpy)
memcpy(&scalar, a, sizeof(Scalar));
return scalar;
}
template <typename Scalar, std::enable_if_t<!std::is_trivially_copyable<Scalar>::value, int> = 0>
EIGEN_DEVICE_FUNC inline Scalar pload1_scalar(const Scalar* a) {
return Scalar(*a);
}
/** \internal \returns a packet with constant coefficients \a a[0], e.g.: (a[0],a[0],a[0],a[0]) */
template <typename Packet>
EIGEN_DEVICE_FUNC inline Packet pload1(const typename unpacket_traits<Packet>::type* a) {
return pset1<Packet>(*a);
using Scalar = typename unpacket_traits<Packet>::type;
return pset1<Packet>(pload1_scalar<Scalar>(a));
}
/** \internal \returns a packet with elements of \a *from duplicated.
@@ -834,7 +848,7 @@ EIGEN_DEVICE_FUNC inline Packet pload1(const typename unpacket_traits<Packet>::t
*/
template <typename Packet>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet ploaddup(const typename unpacket_traits<Packet>::type* from) {
return *from;
return pload1<Packet>(from);
}
/** \internal \returns a packet with elements of \a *from quadrupled.

6
Eigen/src/Core/arch/clang/PacketMath.h
View File

@@ -245,7 +245,8 @@ EIGEN_STRONG_INLINE VectorT load_vector_unaligned(const scalar_type_of_vector_t<
template <typename VectorT>
EIGEN_STRONG_INLINE VectorT load_vector_aligned(const scalar_type_of_vector_t<VectorT>* from) {
return *reinterpret_cast<const VectorT*>(assume_aligned<EIGEN_GENERIC_VECTOR_SIZE_BYTES>(from));
eigen_assert((std::uintptr_t(from) % alignof(VectorT) == 0) && "load_vector_aligned");
return *reinterpret_cast<const VectorT*>(assume_aligned<alignof(VectorT)>(from));
}
template <typename VectorT>
@@ -255,7 +256,8 @@ EIGEN_STRONG_INLINE void store_vector_unaligned(scalar_type_of_vector_t<VectorT>
template <typename VectorT>
EIGEN_STRONG_INLINE void store_vector_aligned(scalar_type_of_vector_t<VectorT>* to, const VectorT& from) {
*reinterpret_cast<VectorT*>(assume_aligned<EIGEN_GENERIC_VECTOR_SIZE_BYTES>(to)) = from;
eigen_assert((std::uintptr_t(to) % alignof(VectorT) == 0) && "store_vector_aligned");
*reinterpret_cast<VectorT*>(assume_aligned<alignof(VectorT)>(to)) = from;
}
} // namespace detail

16
Eigen/src/SparseCore/SparseMatrix.h
View File

@@ -1846,26 +1846,34 @@ class Serializer<SparseMatrix<Scalar, Options, StorageIndex>, void> {
// Inner non-zero counts.
std::size_t data_bytes = sizeof(StorageIndex) * header.outer_size;
if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
memcpy(value.innerNonZeroPtr(), src, data_bytes);
if (data_bytes != 0) {
memcpy(value.innerNonZeroPtr(), src, data_bytes);
}
src += data_bytes;
}
// Outer indices.
std::size_t data_bytes = sizeof(StorageIndex) * (header.outer_size + 1);
if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
memcpy(value.outerIndexPtr(), src, data_bytes);
if (data_bytes != 0) {
memcpy(value.outerIndexPtr(), src, data_bytes);
}
src += data_bytes;
// Inner indices.
data_bytes = sizeof(StorageIndex) * header.inner_buffer_size;
if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
memcpy(value.innerIndexPtr(), src, data_bytes);
if (data_bytes != 0) {
memcpy(value.innerIndexPtr(), src, data_bytes);
}
src += data_bytes;
// Values.
data_bytes = sizeof(Scalar) * header.inner_buffer_size;
if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
memcpy(value.valuePtr(), src, data_bytes);
if (data_bytes != 0) {
memcpy(value.valuePtr(), src, data_bytes);
}
src += data_bytes;
return src;
}

16
Eigen/src/SparseCore/SparseVector.h
View File

@@ -487,12 +487,16 @@ class Serializer<SparseVector<Scalar, Options, StorageIndex>, void> {
// Inner indices.
std::size_t data_bytes = sizeof(StorageIndex) * header.num_non_zeros;
memcpy(dest, value.innerIndexPtr(), data_bytes);
if (data_bytes != 0) {
memcpy(dest, value.innerIndexPtr(), data_bytes);
}
dest += data_bytes;
// Values.
data_bytes = sizeof(Scalar) * header.num_non_zeros;
memcpy(dest, value.valuePtr(), data_bytes);
if (data_bytes != 0) {
memcpy(dest, value.valuePtr(), data_bytes);
}
dest += data_bytes;
return dest;
@@ -515,13 +519,17 @@ class Serializer<SparseVector<Scalar, Options, StorageIndex>, void> {
// Inner indices.
std::size_t data_bytes = sizeof(StorageIndex) * header.num_non_zeros;
if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
memcpy(value.innerIndexPtr(), src, data_bytes);
if (data_bytes != 0) {
memcpy(value.innerIndexPtr(), src, data_bytes);
}
src += data_bytes;
// Values.
data_bytes = sizeof(Scalar) * header.num_non_zeros;
if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
memcpy(value.valuePtr(), src, data_bytes);
if (data_bytes != 0) {
memcpy(value.valuePtr(), src, data_bytes);
}
src += data_bytes;
return src;
}

14
test/array_cwise.cpp
View File

@@ -12,13 +12,21 @@
#include "random_without_cast_overflow.h"
// suppress annoying unsigned integer warnings
template <typename Scalar, bool IsSigned = NumTraits<Scalar>::IsSigned>
template <typename Scalar, bool IsSignedInteger = NumTraits<Scalar>::IsSigned && NumTraits<Scalar>::IsInteger,
bool IsSigned = NumTraits<Scalar>::IsSigned>
struct negative_or_zero_impl {
static Scalar run(const Scalar& a) {
using UnsignedScalar = std::make_unsigned_t<Scalar>;
return static_cast<Scalar>(UnsignedScalar(0) - static_cast<UnsignedScalar>(a));
}
};
template <typename Scalar>
struct negative_or_zero_impl<Scalar, false, true> {
static Scalar run(const Scalar& a) { return -a; }
};
template <typename Scalar>
struct negative_or_zero_impl<Scalar, false> {
static Scalar run(const Scalar&) { return 0; }
struct negative_or_zero_impl<Scalar, false, false> {
static Scalar run(const Scalar&) { return Scalar(0); }
};
template <typename Scalar>
Scalar negative_or_zero(const Scalar& a) {

107
test/packetmath.cpp
View File

@@ -11,18 +11,33 @@
#include "packetmath_test_shared.h"
#include "random_without_cast_overflow.h"
template <typename T>
template <typename T, std::enable_if_t<!NumTraits<T>::IsInteger || !NumTraits<T>::IsSigned, int> = 0>
inline T REF_ADD(const T& a, const T& b) {
return a + b;
}
template <typename T>
template <typename T, std::enable_if_t<NumTraits<T>::IsInteger && NumTraits<T>::IsSigned, int> = 0>
inline T REF_ADD(const T& a, const T& b) {
using UnsignedT = std::make_unsigned_t<T>;
return static_cast<T>(static_cast<UnsignedT>(a) + static_cast<UnsignedT>(b));
}
template <typename T, std::enable_if_t<!NumTraits<T>::IsInteger || !NumTraits<T>::IsSigned, int> = 0>
inline T REF_SUB(const T& a, const T& b) {
return a - b;
}
template <typename T>
template <typename T, std::enable_if_t<NumTraits<T>::IsInteger && NumTraits<T>::IsSigned, int> = 0>
inline T REF_SUB(const T& a, const T& b) {
using UnsignedT = std::make_unsigned_t<T>;
return static_cast<T>(static_cast<UnsignedT>(a) - static_cast<UnsignedT>(b));
}
template <typename T, std::enable_if_t<!NumTraits<T>::IsInteger || !NumTraits<T>::IsSigned, int> = 0>
inline T REF_MUL(const T& a, const T& b) {
return a * b;
}
template <typename T, std::enable_if_t<NumTraits<T>::IsInteger && NumTraits<T>::IsSigned, int> = 0>
inline T REF_MUL(const T& a, const T& b) {
using UnsignedT = std::make_unsigned_t<T>;
return static_cast<T>(static_cast<UnsignedT>(a) * static_cast<UnsignedT>(b));
}
template <typename Scalar, typename EnableIf = void>
struct madd_impl {
@@ -41,8 +56,30 @@ struct madd_impl {
};
template <typename Scalar>
struct madd_impl<Scalar,
std::enable_if_t<Eigen::internal::is_scalar<Scalar>::value && Eigen::NumTraits<Scalar>::IsSigned>> {
struct madd_impl<Scalar, std::enable_if_t<NumTraits<Scalar>::IsInteger && NumTraits<Scalar>::IsSigned>> {
using UnsignedScalar = std::make_unsigned_t<Scalar>;
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar madd(const Scalar& a, const Scalar& b, const Scalar& c) {
return static_cast<Scalar>(static_cast<UnsignedScalar>(a) * static_cast<UnsignedScalar>(b) +
static_cast<UnsignedScalar>(c));
}
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar msub(const Scalar& a, const Scalar& b, const Scalar& c) {
return static_cast<Scalar>(static_cast<UnsignedScalar>(a) * static_cast<UnsignedScalar>(b) -
static_cast<UnsignedScalar>(c));
}
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar nmadd(const Scalar& a, const Scalar& b, const Scalar& c) {
return static_cast<Scalar>(static_cast<UnsignedScalar>(c) -
static_cast<UnsignedScalar>(a) * static_cast<UnsignedScalar>(b));
}
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar nmsub(const Scalar& a, const Scalar& b, const Scalar& c) {
return static_cast<Scalar>(UnsignedScalar(0) - (static_cast<UnsignedScalar>(a) * static_cast<UnsignedScalar>(b) +
static_cast<UnsignedScalar>(c)));
}
};
template <typename Scalar>
struct madd_impl<Scalar, std::enable_if_t<Eigen::internal::is_scalar<Scalar>::value &&
Eigen::NumTraits<Scalar>::IsSigned && !NumTraits<Scalar>::IsInteger>> {
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar madd(const Scalar& a, const Scalar& b, const Scalar& c) {
return numext::madd(a, b, c);
}
@@ -354,9 +391,9 @@ void packetmath_boolean_mask_ops() {
using RealScalar = typename NumTraits<Scalar>::Real;
const int PacketSize = internal::unpacket_traits<Packet>::size;
const int size = 2 * PacketSize;
EIGEN_ALIGN_MAX Scalar data1[size];
EIGEN_ALIGN_MAX Scalar data2[size];
EIGEN_ALIGN_MAX Scalar ref[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data2[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar ref[size];
for (int i = 0; i < size; ++i) {
data1[i] = internal::random<Scalar>();
@@ -389,8 +426,8 @@ template <typename Scalar, typename Packet>
void packetmath_boolean_mask_ops_real() {
const int PacketSize = internal::unpacket_traits<Packet>::size;
const int size = 2 * PacketSize;
EIGEN_ALIGN_MAX Scalar data1[size];
EIGEN_ALIGN_MAX Scalar data2[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data2[size];
for (int i = 0; i < PacketSize; ++i) {
data1[i] = internal::random<Scalar>();
@@ -426,8 +463,8 @@ struct packetmath_boolean_mask_ops_notcomplex_test<
static void run() {
const int PacketSize = internal::unpacket_traits<Packet>::size;
const int size = 2 * PacketSize;
EIGEN_ALIGN_MAX Scalar data1[size];
EIGEN_ALIGN_MAX Scalar data2[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data2[size];
for (int i = 0; i < PacketSize; ++i) {
data1[i] = internal::random<Scalar>();
@@ -465,9 +502,9 @@ struct packetmath_minus_zero_add_test<Scalar, Packet, std::enable_if_t<!NumTrait
static void run() {
const int PacketSize = internal::unpacket_traits<Packet>::size;
const int size = 2 * PacketSize;
EIGEN_ALIGN_MAX Scalar data1[size] = {};
EIGEN_ALIGN_MAX Scalar data2[size] = {};
EIGEN_ALIGN_MAX Scalar ref[size] = {};
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[size] = {};
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data2[size] = {};
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar ref[size] = {};
for (int i = 0; i < PacketSize; ++i) {
data1[i] = Scalar(-0.0);
@@ -537,10 +574,10 @@ void packetmath() {
const int max_size = PacketSize > 4 ? PacketSize : 4;
const int size = PacketSize * max_size;
EIGEN_ALIGN_MAX Scalar data1[size];
EIGEN_ALIGN_MAX Scalar data2[size];
EIGEN_ALIGN_MAX Scalar data3[size];
EIGEN_ALIGN_MAX Scalar ref[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data2[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data3[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar ref[size];
RealScalar refvalue = RealScalar(0);
eigen_optimization_barrier_test<Packet>::run();
@@ -818,9 +855,9 @@ void packetmath_real() {
const int PacketSize = internal::unpacket_traits<Packet>::size;
const int size = PacketSize * 4;
EIGEN_ALIGN_MAX Scalar data1[PacketSize * 4] = {};
EIGEN_ALIGN_MAX Scalar data2[PacketSize * 4] = {};
EIGEN_ALIGN_MAX Scalar ref[PacketSize * 4] = {};
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[PacketSize * 4] = {};
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data2[PacketSize * 4] = {};
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar ref[PacketSize * 4] = {};
// Negate with -0.
if (PacketTraits::HasNegate) {
@@ -1234,9 +1271,9 @@ std::enable_if_t<Cond, void> run_ieee_cases(const FunctorT& fun) {
}
constexpr int size = PacketSize * 2;
EIGEN_ALIGN_MAX Scalar data1[size];
EIGEN_ALIGN_MAX Scalar data2[size];
EIGEN_ALIGN_MAX Scalar ref[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data2[size];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar ref[size];
for (int i = 0; i < size; ++i) {
data1[i] = data2[i] = ref[i] = Scalar(0);
}
@@ -1316,9 +1353,9 @@ void packetmath_notcomplex() {
typedef internal::packet_traits<Scalar> PacketTraits;
const int PacketSize = internal::unpacket_traits<Packet>::size;
EIGEN_ALIGN_MAX Scalar data1[PacketSize * 4];
EIGEN_ALIGN_MAX Scalar data2[PacketSize * 4];
EIGEN_ALIGN_MAX Scalar ref[PacketSize * 4];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[PacketSize * 4];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data2[PacketSize * 4];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar ref[PacketSize * 4];
Array<Scalar, Dynamic, 1>::Map(data1, PacketSize * 4).setRandom();
@@ -1600,12 +1637,12 @@ void packetmath_complex() {
const int PacketSize = internal::unpacket_traits<Packet>::size;
const int size = PacketSize * 4;
EIGEN_ALIGN_MAX Scalar data1[PacketSize * 4];
EIGEN_ALIGN_MAX Scalar data2[PacketSize * 4];
EIGEN_ALIGN_MAX Scalar ref[PacketSize * 4];
EIGEN_ALIGN_MAX Scalar pval[PacketSize * 4];
EIGEN_ALIGN_MAX RealScalar realdata[PacketSize * 4];
EIGEN_ALIGN_MAX RealScalar realref[PacketSize * 4];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[PacketSize * 4];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data2[PacketSize * 4];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar ref[PacketSize * 4];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar pval[PacketSize * 4];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) RealScalar realdata[PacketSize * 4];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) RealScalar realref[PacketSize * 4];
for (int i = 0; i < size; ++i) {
data1[i] = internal::random<Scalar>() * Scalar(1e2);
@@ -1745,7 +1782,7 @@ template <typename Scalar, typename Packet>
void packetmath_scatter_gather() {
typedef typename NumTraits<Scalar>::Real RealScalar;
const int PacketSize = internal::unpacket_traits<Packet>::size;
EIGEN_ALIGN_MAX Scalar data1[PacketSize];
EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar data1[PacketSize];
RealScalar refvalue = RealScalar(0);
for (int i = 0; i < PacketSize; ++i) {
data1[i] = internal::random<Scalar>();

4
test/threads_runqueue.cpp
View File

@@ -182,7 +182,7 @@ void test_stress_runqueue() {
}));
for (int i = 0; i < 2; i++) {
threads.emplace_back(new std::thread([&q, &total]() {
int sum = 0;
int64_t sum = 0;
for (int j = 1; j < kEvents; j++) {
if (q.PushBack(j) == 0) {
sum += j;
@@ -194,7 +194,7 @@ void test_stress_runqueue() {
total += sum;
}));
threads.emplace_back(new std::thread([&q, &total]() {
int sum = 0;
int64_t sum = 0;
std::vector<int> stolen;
for (int j = 1; j < kEvents;) {
if (q.PopBackHalf(&stolen) == 0) {