GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-07-18 10:54:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix numerous pointer-to-integer conversion warnings in unit tests.

Browse Source
This commit is contained in:
Gael Guennebaud 2016-05-26 17:41:28 +02:00
parent 30d97c03ce
commit fdcad686ee
7 changed files with 26 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
test/dynalloc.cpp
View File

@ -22,7 +22,7 @@ void check_handmade_aligned_malloc()
for(int i = 1; i < 1000; i++) for(int i = 1; i < 1000; i++)
{ {
char *p = (char*)internal::handmade_aligned_malloc(i); char *p = (char*)internal::handmade_aligned_malloc(i);
VERIFY(size_t(p)%ALIGNMENT==0); VERIFY(internal::UIntPtr(p)%ALIGNMENT==0);
// if the buffer is wrongly allocated this will give a bad write --> check with valgrind // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
for(int j = 0; j < i; j++) p[j]=0; for(int j = 0; j < i; j++) p[j]=0;
internal::handmade_aligned_free(p); internal::handmade_aligned_free(p);
@ -34,7 +34,7 @@ void check_aligned_malloc()
for(int i = ALIGNMENT; i < 1000; i++) for(int i = ALIGNMENT; i < 1000; i++)
{ {
char *p = (char*)internal::aligned_malloc(i); char *p = (char*)internal::aligned_malloc(i);
VERIFY(size_t(p)%ALIGNMENT==0); VERIFY(internal::UIntPtr(p)%ALIGNMENT==0);
// if the buffer is wrongly allocated this will give a bad write --> check with valgrind // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
for(int j = 0; j < i; j++) p[j]=0; for(int j = 0; j < i; j++) p[j]=0;
internal::aligned_free(p); internal::aligned_free(p);
@ -46,7 +46,7 @@ void check_aligned_new()
for(int i = ALIGNMENT; i < 1000; i++) for(int i = ALIGNMENT; i < 1000; i++)
{ {
float *p = internal::aligned_new<float>(i); float *p = internal::aligned_new<float>(i);
VERIFY(size_t(p)%ALIGNMENT==0); VERIFY(internal::UIntPtr(p)%ALIGNMENT==0);
// if the buffer is wrongly allocated this will give a bad write --> check with valgrind // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
for(int j = 0; j < i; j++) p[j]=0; for(int j = 0; j < i; j++) p[j]=0;
internal::aligned_delete(p,i); internal::aligned_delete(p,i);
@ -58,7 +58,7 @@ void check_aligned_stack_alloc()
for(int i = ALIGNMENT; i < 400; i++) for(int i = ALIGNMENT; i < 400; i++)
{ {
ei_declare_aligned_stack_constructed_variable(float,p,i,0); ei_declare_aligned_stack_constructed_variable(float,p,i,0);
VERIFY(size_t(p)%ALIGNMENT==0); VERIFY(internal::UIntPtr(p)%ALIGNMENT==0);
// if the buffer is wrongly allocated this will give a bad write --> check with valgrind // if the buffer is wrongly allocated this will give a bad write --> check with valgrind
for(int j = 0; j < i; j++) p[j]=0; for(int j = 0; j < i; j++) p[j]=0;
} }
@ -88,7 +88,7 @@ template<typename T> void check_dynaligned()
{ {
T* obj = new T; T* obj = new T;
VERIFY(T::NeedsToAlign==1); VERIFY(T::NeedsToAlign==1);
VERIFY(size_t(obj)%ALIGNMENT==0); VERIFY(internal::UIntPtr(obj)%ALIGNMENT==0);
delete obj; delete obj;
} }
} }
@ -148,15 +148,15 @@ void test_dynalloc()
} }
{ {
MyStruct foo0; VERIFY(size_t(foo0.avec.data())%ALIGNMENT==0); MyStruct foo0; VERIFY(internal::UIntPtr(foo0.avec.data())%ALIGNMENT==0);
MyClassA fooA; VERIFY(size_t(fooA.avec.data())%ALIGNMENT==0); MyClassA fooA; VERIFY(internal::UIntPtr(fooA.avec.data())%ALIGNMENT==0);
} }
// dynamic allocation, single object // dynamic allocation, single object
for (int i=0; i<g_repeat*100; ++i) for (int i=0; i<g_repeat*100; ++i)
{ {
MyStruct *foo0 = new MyStruct(); VERIFY(size_t(foo0->avec.data())%ALIGNMENT==0); MyStruct *foo0 = new MyStruct(); VERIFY(internal::UIntPtr(foo0->avec.data())%ALIGNMENT==0);
MyClassA *fooA = new MyClassA(); VERIFY(size_t(fooA->avec.data())%ALIGNMENT==0); MyClassA *fooA = new MyClassA(); VERIFY(internal::UIntPtr(fooA->avec.data())%ALIGNMENT==0);
delete foo0; delete foo0;
delete fooA; delete fooA;
} }
@ -165,8 +165,8 @@ void test_dynalloc()
const int N = 10; const int N = 10;
for (int i=0; i<g_repeat*100; ++i) for (int i=0; i<g_repeat*100; ++i)
{ {
MyStruct *foo0 = new MyStruct[N]; VERIFY(size_t(foo0->avec.data())%ALIGNMENT==0); MyStruct *foo0 = new MyStruct[N]; VERIFY(internal::UIntPtr(foo0->avec.data())%ALIGNMENT==0);
MyClassA *fooA = new MyClassA[N]; VERIFY(size_t(fooA->avec.data())%ALIGNMENT==0); MyClassA *fooA = new MyClassA[N]; VERIFY(internal::UIntPtr(fooA->avec.data())%ALIGNMENT==0);
delete[] foo0; delete[] foo0;
delete[] fooA; delete[] fooA;
} }

2
test/first_aligned.cpp
View File

@ -41,7 +41,7 @@ void test_first_aligned()
test_first_aligned_helper(array_double+1, 50); test_first_aligned_helper(array_double+1, 50);
test_first_aligned_helper(array_double+2, 50); test_first_aligned_helper(array_double+2, 50);
double *array_double_plus_4_bytes = (double*)(size_t(array_double)+4); double *array_double_plus_4_bytes = (double*)(internal::UIntPtr(array_double)+4);
test_none_aligned_helper(array_double_plus_4_bytes, 50); test_none_aligned_helper(array_double_plus_4_bytes, 50);
test_none_aligned_helper(array_double_plus_4_bytes+1, 50); test_none_aligned_helper(array_double_plus_4_bytes+1, 50);

6
test/mapped_matrix.cpp
View File

@ -25,7 +25,7 @@ template<typename VectorType> void map_class_vector(const VectorType& m)
Scalar* array1 = internal::aligned_new<Scalar>(size); Scalar* array1 = internal::aligned_new<Scalar>(size);
Scalar* array2 = internal::aligned_new<Scalar>(size); Scalar* array2 = internal::aligned_new<Scalar>(size);
Scalar* array3 = new Scalar[size+1]; Scalar* array3 = new Scalar[size+1];
Scalar* array3unaligned = (std::size_t(array3)%EIGEN_MAX_ALIGN_BYTES) == 0 ? array3+1 : array3; Scalar* array3unaligned = (internal::UIntPtr(array3)%EIGEN_MAX_ALIGN_BYTES) == 0 ? array3+1 : array3;
Scalar array4[EIGEN_TESTMAP_MAX_SIZE]; Scalar array4[EIGEN_TESTMAP_MAX_SIZE];
Map<VectorType, AlignedMax>(array1, size) = VectorType::Random(size); Map<VectorType, AlignedMax>(array1, size) = VectorType::Random(size);
@ -65,7 +65,7 @@ template<typename MatrixType> void map_class_matrix(const MatrixType& m)
// array3unaligned -> unaligned pointer to heap // array3unaligned -> unaligned pointer to heap
Scalar* array3 = new Scalar[size+1]; Scalar* array3 = new Scalar[size+1];
for(int i = 0; i < size+1; i++) array3[i] = Scalar(1); for(int i = 0; i < size+1; i++) array3[i] = Scalar(1);
Scalar* array3unaligned = size_t(array3)%EIGEN_MAX_ALIGN_BYTES == 0 ? array3+1 : array3; Scalar* array3unaligned = internal::UIntPtr(array3)%EIGEN_MAX_ALIGN_BYTES == 0 ? array3+1 : array3;
Scalar array4[256]; Scalar array4[256];
if(size<=256) if(size<=256)
for(int i = 0; i < size; i++) array4[i] = Scalar(1); for(int i = 0; i < size; i++) array4[i] = Scalar(1);
@ -129,7 +129,7 @@ template<typename VectorType> void map_static_methods(const VectorType& m)
Scalar* array1 = internal::aligned_new<Scalar>(size); Scalar* array1 = internal::aligned_new<Scalar>(size);
Scalar* array2 = internal::aligned_new<Scalar>(size); Scalar* array2 = internal::aligned_new<Scalar>(size);
Scalar* array3 = new Scalar[size+1]; Scalar* array3 = new Scalar[size+1];
Scalar* array3unaligned = size_t(array3)%EIGEN_MAX_ALIGN_BYTES == 0 ? array3+1 : array3; Scalar* array3unaligned = internal::UIntPtr(array3)%EIGEN_MAX_ALIGN_BYTES == 0 ? array3+1 : array3;
VectorType::MapAligned(array1, size) = VectorType::Random(size); VectorType::MapAligned(array1, size) = VectorType::Random(size);
VectorType::Map(array2, size) = VectorType::Map(array1, size); VectorType::Map(array2, size) = VectorType::Map(array1, size);

8
test/mapstride.cpp
View File

@ -23,7 +23,7 @@ template<int Alignment,typename VectorType> void map_class_vector(const VectorTy
Scalar* a_array = internal::aligned_new<Scalar>(arraysize+1); Scalar* a_array = internal::aligned_new<Scalar>(arraysize+1);
Scalar* array = a_array; Scalar* array = a_array;
if(Alignment!=Aligned) if(Alignment!=Aligned)
array = (Scalar*)(ptrdiff_t(a_array) + (internal::packet_traits<Scalar>::AlignedOnScalar?sizeof(Scalar):sizeof(typename NumTraits<Scalar>::Real))); array = (Scalar*)(internal::IntPtr(a_array) + (internal::packet_traits<Scalar>::AlignedOnScalar?sizeof(Scalar):sizeof(typename NumTraits<Scalar>::Real)));
{ {
Map<VectorType, Alignment, InnerStride<3> > map(array, size); Map<VectorType, Alignment, InnerStride<3> > map(array, size);
@ -63,14 +63,14 @@ template<int Alignment,typename MatrixType> void map_class_matrix(const MatrixTy
Scalar* a_array1 = internal::aligned_new<Scalar>(arraysize+1); Scalar* a_array1 = internal::aligned_new<Scalar>(arraysize+1);
Scalar* array1 = a_array1; Scalar* array1 = a_array1;
if(Alignment!=Aligned) if(Alignment!=Aligned)
array1 = (Scalar*)(std::ptrdiff_t(a_array1) + (internal::packet_traits<Scalar>::AlignedOnScalar?sizeof(Scalar):sizeof(typename NumTraits<Scalar>::Real))); array1 = (Scalar*)(internal::IntPtr(a_array1) + (internal::packet_traits<Scalar>::AlignedOnScalar?sizeof(Scalar):sizeof(typename NumTraits<Scalar>::Real)));
Scalar a_array2[256]; Scalar a_array2[256];
Scalar* array2 = a_array2; Scalar* array2 = a_array2;
if(Alignment!=Aligned) if(Alignment!=Aligned)
array2 = (Scalar*)(std::ptrdiff_t(a_array2) + (internal::packet_traits<Scalar>::AlignedOnScalar?sizeof(Scalar):sizeof(typename NumTraits<Scalar>::Real))); array2 = (Scalar*)(internal::IntPtr(a_array2) + (internal::packet_traits<Scalar>::AlignedOnScalar?sizeof(Scalar):sizeof(typename NumTraits<Scalar>::Real)));
else else
array2 = (Scalar*)(((std::size_t(a_array2)+EIGEN_MAX_ALIGN_BYTES-1)/EIGEN_MAX_ALIGN_BYTES)*EIGEN_MAX_ALIGN_BYTES); array2 = (Scalar*)(((internal::UIntPtr(a_array2)+EIGEN_MAX_ALIGN_BYTES-1)/EIGEN_MAX_ALIGN_BYTES)*EIGEN_MAX_ALIGN_BYTES);
Index maxsize2 = a_array2 - array2 + 256; Index maxsize2 = a_array2 - array2 + 256;
// test no inner stride and some dynamic outer stride // test no inner stride and some dynamic outer stride

6
test/stdvector.cpp
View File

@ -34,7 +34,7 @@ void check_stdvector_matrix(const MatrixType& m)
VERIFY_IS_APPROX(v[21], y); VERIFY_IS_APPROX(v[21], y);
v.push_back(x); v.push_back(x);
VERIFY_IS_APPROX(v[22], x); VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(MatrixType)); VERIFY((internal::UIntPtr)&(v[22]) == (internal::UIntPtr)&(v[21]) + sizeof(MatrixType));
// do a lot of push_back such that the vector gets internally resized // do a lot of push_back such that the vector gets internally resized
// (with memory reallocation) // (with memory reallocation)
@ -69,7 +69,7 @@ void check_stdvector_transform(const TransformType&)
VERIFY_IS_APPROX(v[21], y); VERIFY_IS_APPROX(v[21], y);
v.push_back(x); v.push_back(x);
VERIFY_IS_APPROX(v[22], x); VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(TransformType)); VERIFY((internal::UIntPtr)&(v[22]) == (internal::UIntPtr)&(v[21]) + sizeof(TransformType));
// do a lot of push_back such that the vector gets internally resized // do a lot of push_back such that the vector gets internally resized
// (with memory reallocation) // (with memory reallocation)
@ -104,7 +104,7 @@ void check_stdvector_quaternion(const QuaternionType&)
VERIFY_IS_APPROX(v[21], y); VERIFY_IS_APPROX(v[21], y);
v.push_back(x); v.push_back(x);
VERIFY_IS_APPROX(v[22], x); VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(QuaternionType)); VERIFY((internal::UIntPtr)&(v[22]) == (internal::UIntPtr)&(v[21]) + sizeof(QuaternionType));
// do a lot of push_back such that the vector gets internally resized // do a lot of push_back such that the vector gets internally resized
// (with memory reallocation) // (with memory reallocation)

6
test/stdvector_overload.cpp
View File

@ -48,7 +48,7 @@ void check_stdvector_matrix(const MatrixType& m)
VERIFY_IS_APPROX(v[21], y); VERIFY_IS_APPROX(v[21], y);
v.push_back(x); v.push_back(x);
VERIFY_IS_APPROX(v[22], x); VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(MatrixType)); VERIFY((internal::UIntPtr)&(v[22]) == (internal::UIntPtr)&(v[21]) + sizeof(MatrixType));
// do a lot of push_back such that the vector gets internally resized // do a lot of push_back such that the vector gets internally resized
// (with memory reallocation) // (with memory reallocation)
@ -83,7 +83,7 @@ void check_stdvector_transform(const TransformType&)
VERIFY_IS_APPROX(v[21], y); VERIFY_IS_APPROX(v[21], y);
v.push_back(x); v.push_back(x);
VERIFY_IS_APPROX(v[22], x); VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(TransformType)); VERIFY((internal::UIntPtr)&(v[22]) == (internal::UIntPtr)&(v[21]) + sizeof(TransformType));
// do a lot of push_back such that the vector gets internally resized // do a lot of push_back such that the vector gets internally resized
// (with memory reallocation) // (with memory reallocation)
@ -118,7 +118,7 @@ void check_stdvector_quaternion(const QuaternionType&)
VERIFY_IS_APPROX(v[21], y); VERIFY_IS_APPROX(v[21], y);
v.push_back(x); v.push_back(x);
VERIFY_IS_APPROX(v[22], x); VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(QuaternionType)); VERIFY((internal::UIntPtr)&(v[22]) == (internal::UIntPtr)&(v[21]) + sizeof(QuaternionType));
// do a lot of push_back such that the vector gets internally resized // do a lot of push_back such that the vector gets internally resized
// (with memory reallocation) // (with memory reallocation)

2
test/unalignedassert.cpp
View File

@ -94,7 +94,7 @@ template<typename T>
void construct_at_boundary(int boundary) void construct_at_boundary(int boundary)
{ {
char buf[sizeof(T)+256]; char buf[sizeof(T)+256];
size_t _buf = reinterpret_cast<size_t>(buf); size_t _buf = reinterpret_cast<internal::UIntPtr>(buf);
_buf += (EIGEN_MAX_ALIGN_BYTES - (_buf % EIGEN_MAX_ALIGN_BYTES)); // make 16/32/...-byte aligned _buf += (EIGEN_MAX_ALIGN_BYTES - (_buf % EIGEN_MAX_ALIGN_BYTES)); // make 16/32/...-byte aligned
_buf += boundary; // make exact boundary-aligned _buf += boundary; // make exact boundary-aligned
T *x = ::new(reinterpret_cast<void*>(_buf)) T; T *x = ::new(reinterpret_cast<void*>(_buf)) T;