Segfault in Cholesky factorization

[ggael]

Re: Segfault in Cholesky factorization

Mon Oct 05, 2009 9:00 am

ok, the problem is that on a 32 bits linux system, objects lying on the stack are only aligned on a 4 bytes boundary while I assumed doubles were are least aligned on a 8 bytes boundary. Performance wise it is always a good idea to align doubles on 8 bytes, so the solutions are:

- on the user side: use this gcc's flag: -malign-double

- on the Eigen side: enforce the alignment of objects of doubles (or complex of double) on 8 bytes.

ok, the problem is that on a 32 bits linux system, objects lying on the stack are only aligned on a 4 bytes boundary while I assumed doubles were are least aligned on a 8 bytes boundary. Performance wise it is always a good idea to align doubles on 8 bytes, so the solutions are:

- on the user side: use this gcc's flag: -malign-double

- on the Eigen side: enforce the alignment of objects of doubles (or complex of double) on 8 bytes.

[bjacob]

Re: Segfault in Cholesky factorization

Mon Oct 05, 2009 10:42 am

Performance wise it is always a good idea to align doubles on 8 bytes, so the solutions are:

- on the user side: use this gcc's flag: -malign-double

- on the Eigen side: enforce the alignment of objects of doubles (or complex of double) on 8 bytes.

I'm OK to enforce 8byte alignment of doubles, since this doesn't lead to additional memory consumption. We just need to document that well, e.g. for Map...

Then we are going to run into one of the issues with the UnalignedArrayAssert, namely: when passing-by-value. But precisely that's OK because that only matters when vectorization is on, and then that's already covered by the UnalignedArrayAssert.

[quote]
Performance wise it is always a good idea to align doubles on 8 bytes, so the solutions are:

- on the user side: use this gcc's flag: -malign-double

- on the Eigen side: enforce the alignment of objects of doubles (or complex of double) on 8 bytes.
[/quote]

I'm OK to enforce 8byte alignment of doubles, since this doesn't lead to additional memory consumption. We just need to document that well, e.g. for Map...

Then we are going to run into [i]one[/i] of the issues with the UnalignedArrayAssert, namely: when passing-by-value. But precisely that's OK because that only matters when vectorization is on, and then that's already covered by the UnalignedArrayAssert.

[bjacob]

Re: Segfault in Cholesky factorization

Mon Oct 05, 2009 2:12 pm

ok, the changes are done.

TaMo: seems to be fixed now.

Gael: i align based only on total size, so e.g. Vector2f gets aligned. Do you prefer to only align to 8byte if sizeof(T) itself is multiple of 8? No big important reason for my choice, it was just easier to document.

ok, the changes are done.

TaMo: seems to be fixed now.

Gael: i align based only on total size, so e.g. Vector2f gets aligned. Do you prefer to only align to 8byte if sizeof(T) itself is multiple of 8? No big important reason for my choice, it was just easier to document.

Re: Segfault in Cholesky factorization

Mon Oct 05, 2009 3:57 pm

Could this be the same bug affecting my inability to create an std::vector or std::valarray of SparseMatrix's? When I try, I get a bus error. I can create a raw array of SparseMatrix's just fine and a vector/valarray of DynamicSparseMatrix's just fine, too. Here is code to reproduce the problem (eigen 2.0.6):

Code: Select all

// g++ -Iext/eigen2 foo.c

#include "Eigen/Eigen"

typedef double real_t;
typedef Eigen::DynamicSparseMatrix< real_t, Eigen::RowMajor > assembly_matrix_t;
typedef Eigen::SparseMatrix< real_t, Eigen::RowMajor > solve_matrix_t;

and then one of

Code: Select all

#include <vector>

int main( int argc, char* argv[] )
{
    std::vector< solve_matrix_t > foo;
    foo.resize( 100 );
   
    return 0;
}

or

Code: Select all

#include <valarray>

int main( int argc, char* argv[] )
{
    std::valarray< solve_matrix_t > foo;
    foo.resize( 100 );
   
    return 0;
}

or

Code: Select all

int main( int argc, char* argv[] )
{
    solve_matrix_t* foo = new solve_matrix_t[ 100 ];
    delete [] foo;
   
    return 0;
}

The code with the new[] works fine, while the others crash. If I change solve_matrix_t to assembly_matrix_t it doesn't crash.
This is on Mac OS X, in case the problem is platform specific.

Thanks for making such a great library, by the way! I wouldn't have found this if I wasn't using Eigen so heavily.

Yotam

Could this be the same bug affecting my inability to create an std::vector or std::valarray of SparseMatrix's? When I try, I get a bus error. I can create a raw array of SparseMatrix's just fine and a vector/valarray of DynamicSparseMatrix's just fine, too. Here is code to reproduce the problem (eigen 2.0.6):

[code]// g++ -Iext/eigen2 foo.c

#include "Eigen/Eigen"

typedef double real_t;
typedef Eigen::DynamicSparseMatrix< real_t, Eigen::RowMajor > assembly_matrix_t;
typedef Eigen::SparseMatrix< real_t, Eigen::RowMajor > solve_matrix_t;[/code]

and then one of

[code]#include <vector>

int main( int argc, char* argv[] )
{
std::vector< solve_matrix_t > foo;
foo.resize( 100 );

return 0;
}[/code]

or

[code]#include <valarray>

int main( int argc, char* argv[] )
{
std::valarray< solve_matrix_t > foo;
foo.resize( 100 );

return 0;
}[/code]

or

[code]int main( int argc, char* argv[] )
{
solve_matrix_t* foo = new solve_matrix_t[ 100 ];
delete [] foo;

return 0;
}[/code]

The code with the new[] works fine, while the others crash. If I change solve_matrix_t to assembly_matrix_t it doesn't crash.
This is on Mac OS X, in case the problem is platform specific.

Thanks for making such a great library, by the way! I wouldn't have found this if I wasn't using Eigen so heavily. :-)

Yotam

[bjacob]

Re: Segfault in Cholesky factorization

Mon Oct 05, 2009 5:18 pm

No, this doesn't seem to be the same error. The error discussed in this thread was a very special issue about a specific function assuming double's to be 8 byte aligned.

Can you please open an issue on the tracker, and post a full back-trace of your crash (compile with -g3) ?

No, this doesn't seem to be the same error. The error discussed in this thread was a very special issue about a specific function assuming double's to be 8 byte aligned.

Can you please open an issue on the tracker, and post a full back-trace of your crash (compile with -g3) ?

Re: Segfault in Cholesky factorization

Mon Oct 05, 2009 5:47 pm

No, this doesn't seem to be the same error. The error discussed in this thread was a very special issue about a specific function assuming double's to be 8 byte aligned.

Can you please open an issue on the tracker, and post a full back-trace of your crash (compile with -g3) ?

Done: http://bitbucket.org/eigen/eigen2/issue ... alarray-of

Thanks,
Yotam

[quote="bjacob"]No, this doesn't seem to be the same error. The error discussed in this thread was a very special issue about a specific function assuming double's to be 8 byte aligned.

Can you please open an issue on the tracker, and post a full back-trace of your crash (compile with -g3) ?[/quote]

Done: http://bitbucket.org/eigen/eigen2/issue/60/crash-when-using-an-std-vector-or-std-valarray-of

Thanks,
Yotam

[bjacob]

Re: Segfault in Cholesky factorization

Mon Oct 05, 2009 6:00 pm

Thanks! Now we can't forget about it.

Thanks! Now we can't forget about it.

[ggael]

Re: Segfault in Cholesky factorization

Tue Oct 06, 2009 8:44 am

here is my answer:

"This bug is not present in the devel branch, and since the sparse module was marked as experimental in the 2.0.x branch I won't try to backport the fix. Well actually I tried to backport a few fixes, but there have been too many changes now and this would take me hours to fix it. So please, use the devel branch."

here is my answer:

"This bug is not present in the devel branch, and since the sparse module was marked as experimental in the 2.0.x branch I won't try to backport the fix. Well actually I tried to backport a few fixes, but there have been too many changes now and this would take me hours to fix it. So please, use the devel branch."