Pfthb

I need to factorize ~1e05 small matrices of maximal variable size of 20x20. Profiling of the matrix factorization using HpcToolkit shows that the hotspot in the code is in Eigen::internal::partial_lu_inplace.

I checked the Eigen documenation on the inplace matrix decomposition, and I understand it can be important for large matrices to use inplace decomposition, to re-use the memory and have better cache efficiency.

I am currently computing the decomposition like this:

// Factorize the matrix.
matrixFactorization_ = A_.partialPivLu(); 

Profiling with HpcToolkit shows that the inplace factorization is the hotspot:

Is it possible to disable the inplace decomposition and test if the code will be faster for small matrices I am dealing with?

Note: If you look at the CPU time in the column on the image, you'll notice the runtime is in seconds: I am not after microsecond optimizations here, the calculation takes ~4 seconds in total.

Edit: HPCToolkit statistically profiles the code in fully optimized mode -O3 , but with the information that is required to map the measurements to the sourcecode -g3.

If the profiler gives you so detailed information then you forgot to enable compiler's optimizations (e.g., -O3 -march=native -DNDEBUG, or "Release" mode + /arch:AVX with VS). With Eigen, this will make a huge difference.

Then you might save dynamic memory allocation by using:

typedef Matrix<double,Dynamic,Dynamic,ColMajor,20,20> MatMax20;
MatMax20 A_;
PartialPivLU<MatMax20> matrixFactorization_;

The matrix A_ and all internals of PartialPivLU will thus be statically allocated.

To update an existing facto better write:

matrixFactorization_.compute(A_);