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

DenseStorage safely copy/swap.

Browse Source 
Fixes #2229.

For dynamic matrices with fixed-sized storage, only copy/swap
elements that have been set.  Otherwise, this leads to inefficient
copying, and potential UB for non-initialized elements.
This commit is contained in:
Antonio Sanchez
2021-04-21 15:45:31 -07:00
committed by Rasmus Munk Larsen
parent 85a76a16ea
commit d213a0bcea
5 changed files with 199 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
test/dense_storage.cpp
View File

@@ -8,17 +8,16 @@
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include "main.h"
#include "AnnoyingScalar.h"
#include "SafeScalar.h"
#include <Eigen/Core>
template <typename T, int Rows, int Cols>
void dense_storage_copy()
template <typename T, int Size, int Rows, int Cols>
void dense_storage_copy(int rows, int cols)
{
static const int Size = ((Rows==Dynamic || Cols==Dynamic) ? Dynamic : Rows*Cols);
typedef DenseStorage<T,Size, Rows,Cols, 0> DenseStorageType;
typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType;
const int rows = (Rows==Dynamic) ? 4 : Rows;
const int cols = (Cols==Dynamic) ? 3 : Cols;
const int size = rows*cols;
DenseStorageType reference(size, rows, cols);
T* raw_reference = reference.data();
@@ -31,14 +30,11 @@ void dense_storage_copy()
VERIFY_IS_EQUAL(raw_reference[i], raw_copied_reference[i]);
}
template <typename T, int Rows, int Cols>
void dense_storage_assignment()
template <typename T, int Size, int Rows, int Cols>
void dense_storage_assignment(int rows, int cols)
{
static const int Size = ((Rows==Dynamic || Cols==Dynamic) ? Dynamic : Rows*Cols);
typedef DenseStorage<T,Size, Rows,Cols, 0> DenseStorageType;
typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType;
const int rows = (Rows==Dynamic) ? 4 : Rows;
const int cols = (Cols==Dynamic) ? 3 : Cols;
const int size = rows*cols;
DenseStorageType reference(size, rows, cols);
T* raw_reference = reference.data();
@@ -52,6 +48,34 @@ void dense_storage_assignment()
VERIFY_IS_EQUAL(raw_reference[i], raw_copied_reference[i]);
}
template <typename T, int Size, int Rows, int Cols>
void dense_storage_swap(int rows0, int cols0, int rows1, int cols1)
{
typedef DenseStorage<T, Size, Rows, Cols, 0> DenseStorageType;
const int size0 = rows0*cols0;
DenseStorageType a(size0, rows0, cols0);
for (int i=0; i<size0; ++i) {
a.data()[i] = static_cast<T>(i);
}
const int size1 = rows1*cols1;
DenseStorageType b(size1, rows1, cols1);
for (int i=0; i<size1; ++i) {
b.data()[i] = static_cast<T>(-i);
}
a.swap(b);
for (int i=0; i<size0; ++i) {
VERIFY_IS_EQUAL(b.data()[i], static_cast<T>(i));
}
for (int i=0; i<size1; ++i) {
VERIFY_IS_EQUAL(a.data()[i], static_cast<T>(-i));
}
}
template<typename T, int Size, std::size_t Alignment>
void dense_storage_alignment()
{
@@ -78,30 +102,78 @@ void dense_storage_alignment()
#endif
}
template<typename T>
void dense_storage_tests() {
// Dynamic Storage.
dense_storage_copy<T,Dynamic,Dynamic,Dynamic>(4, 3);
dense_storage_copy<T,Dynamic,Dynamic,3>(4, 3);
dense_storage_copy<T,Dynamic,4,Dynamic>(4, 3);
// Fixed Storage.
dense_storage_copy<T,12,4,3>(4, 3);
dense_storage_copy<T,12,Dynamic,Dynamic>(4, 3);
dense_storage_copy<T,12,4,Dynamic>(4, 3);
dense_storage_copy<T,12,Dynamic,3>(4, 3);
// Fixed Storage with Uninitialized Elements.
dense_storage_copy<T,18,Dynamic,Dynamic>(4, 3);
dense_storage_copy<T,18,4,Dynamic>(4, 3);
dense_storage_copy<T,18,Dynamic,3>(4, 3);
// Dynamic Storage.
dense_storage_assignment<T,Dynamic,Dynamic,Dynamic>(4, 3);
dense_storage_assignment<T,Dynamic,Dynamic,3>(4, 3);
dense_storage_assignment<T,Dynamic,4,Dynamic>(4, 3);
// Fixed Storage.
dense_storage_assignment<T,12,4,3>(4, 3);
dense_storage_assignment<T,12,Dynamic,Dynamic>(4, 3);
dense_storage_assignment<T,12,4,Dynamic>(4, 3);
dense_storage_assignment<T,12,Dynamic,3>(4, 3);
// Fixed Storage with Uninitialized Elements.
dense_storage_assignment<T,18,Dynamic,Dynamic>(4, 3);
dense_storage_assignment<T,18,4,Dynamic>(4, 3);
dense_storage_assignment<T,18,Dynamic,3>(4, 3);
// Dynamic Storage.
dense_storage_swap<T,Dynamic,Dynamic,Dynamic>(4, 3, 4, 3);
dense_storage_swap<T,Dynamic,Dynamic,Dynamic>(4, 3, 2, 1);
dense_storage_swap<T,Dynamic,Dynamic,Dynamic>(2, 1, 4, 3);
dense_storage_swap<T,Dynamic,Dynamic,3>(4, 3, 4, 3);
dense_storage_swap<T,Dynamic,Dynamic,3>(4, 3, 2, 3);
dense_storage_swap<T,Dynamic,Dynamic,3>(2, 3, 4, 3);
dense_storage_swap<T,Dynamic,4,Dynamic>(4, 3, 4, 3);
dense_storage_swap<T,Dynamic,4,Dynamic>(4, 3, 4, 1);
dense_storage_swap<T,Dynamic,4,Dynamic>(4, 1, 4, 3);
// Fixed Storage.
dense_storage_swap<T,12,4,3>(4, 3, 4, 3);
dense_storage_swap<T,12,Dynamic,Dynamic>(4, 3, 4, 3);
dense_storage_swap<T,12,Dynamic,Dynamic>(4, 3, 2, 1);
dense_storage_swap<T,12,Dynamic,Dynamic>(2, 1, 4, 3);
dense_storage_swap<T,12,4,Dynamic>(4, 3, 4, 3);
dense_storage_swap<T,12,4,Dynamic>(4, 3, 4, 1);
dense_storage_swap<T,12,4,Dynamic>(4, 1, 4, 3);
dense_storage_swap<T,12,Dynamic,3>(4, 3, 4, 3);
dense_storage_swap<T,12,Dynamic,3>(4, 3, 2, 3);
dense_storage_swap<T,12,Dynamic,3>(2, 3, 4, 3);
// Fixed Storage with Uninitialized Elements.
dense_storage_swap<T,18,Dynamic,Dynamic>(4, 3, 4, 3);
dense_storage_swap<T,18,Dynamic,Dynamic>(4, 3, 2, 1);
dense_storage_swap<T,18,Dynamic,Dynamic>(2, 1, 4, 3);
dense_storage_swap<T,18,4,Dynamic>(4, 3, 4, 3);
dense_storage_swap<T,18,4,Dynamic>(4, 3, 4, 1);
dense_storage_swap<T,18,4,Dynamic>(4, 1, 4, 3);
dense_storage_swap<T,18,Dynamic,3>(4, 3, 4, 3);
dense_storage_swap<T,18,Dynamic,3>(4, 3, 2, 3);
dense_storage_swap<T,18,Dynamic,3>(2, 3, 4, 3);
dense_storage_alignment<T,16,8>();
dense_storage_alignment<T,16,16>();
dense_storage_alignment<T,16,32>();
dense_storage_alignment<T,16,64>();
}
EIGEN_DECLARE_TEST(dense_storage)
{
dense_storage_copy<int,Dynamic,Dynamic>();
dense_storage_copy<int,Dynamic,3>();
dense_storage_copy<int,4,Dynamic>();
dense_storage_copy<int,4,3>();
dense_storage_copy<float,Dynamic,Dynamic>();
dense_storage_copy<float,Dynamic,3>();
dense_storage_copy<float,4,Dynamic>();
dense_storage_copy<float,4,3>();
dense_storage_assignment<int,Dynamic,Dynamic>();
dense_storage_assignment<int,Dynamic,3>();
dense_storage_assignment<int,4,Dynamic>();
dense_storage_assignment<int,4,3>();
dense_storage_assignment<float,Dynamic,Dynamic>();
dense_storage_assignment<float,Dynamic,3>();
dense_storage_assignment<float,4,Dynamic>();
dense_storage_assignment<float,4,3>();
dense_storage_alignment<float,16,8>();
dense_storage_alignment<float,16,16>();
dense_storage_alignment<float,16,32>();
dense_storage_alignment<float,16,64>();
dense_storage_tests<int>();
dense_storage_tests<float>();
dense_storage_tests<SafeScalar<float> >();
dense_storage_tests<AnnoyingScalar>();
}