mirror of
https://gitlab.com/libeigen/eigen.git
synced 2024-12-15 07:10:37 +08:00
44a527dfa5
by tweaking the filename and adding 2 categories:
Troubleshooting and Advanced
* use the EXCLUDE_SYMBOLS to clean the class list
(insteaded of a homemade bash script)
* remove the broken "exemple list"
* re-structure the unsupported directory as mentionned in the ML and
integrate the doc as follow:
- snippets of the unsupported directory are directly imported from the
main snippets/CMakefile.txt (no need to duplicate code)
- add a top level "Unsupported modules" group
- unsupported modules have to defined their own sub group and nest it
using \ingroup Unsupported_modules
- then a pair of //@{ //@} will put everything in the submodule
- this is just a proposal !
67 lines
5.5 KiB
Plaintext
67 lines
5.5 KiB
Plaintext
namespace Eigen {
|
|
|
|
/** \page TopicLazyEvaluation Advanced - Lazy Evaluation and Aliasing
|
|
|
|
Executive summary: Eigen has intelligent compile-time mechanisms to enable lazy evaluation and removing temporaries where appropriate.
|
|
It will handle aliasing automatically in most cases, for example with matrix products. The automatic behavior can be overridden
|
|
manually by using the MatrixBase::eval() and MatrixBase::lazy() methods.
|
|
|
|
When you write a line of code involving a complex expression such as
|
|
|
|
\code mat1 = mat2 + mat3 * (mat4 + mat5); \endcode
|
|
|
|
Eigen determines automatically, for each sub-expression, whether to evaluate it into a temporary variable. Indeed, in certain cases it is better to evaluate immediately a sub-expression into a temporary variable, while in other cases it is better to avoid that.
|
|
|
|
A traditional math library without expression templates always evaluates all sub-expressions into temporaries. So with this code,
|
|
|
|
\code vec1 = vec2 + vec3; \endcode
|
|
|
|
a traditional library would evaluate \c vec2 + vec3 into a temporary \c vec4 and then copy \c vec4 into \c vec1. This is of course inefficient: the arrays are traversed twice, so there are a lot of useless load/store operations.
|
|
|
|
Expression-templates-based libraries can avoid evaluating sub-expressions into temporaries, which in many cases results in large speed improvements. This is called <i>lazy evaluation</i> as an expression is getting evaluated as late as possible, instead of immediately. However, most other expression-templates-based libraries <i>always</i> choose lazy evaluation. There are two problems with that: first, lazy evaluation is not always a good choice for performance; second, lazy evaluation can be very dangerous, for example with matrix products: doing <tt>matrix = matrix*matrix</tt> gives a wrong result if the matrix product is lazy-evaluated, because of the way matrix product works.
|
|
|
|
For these reasons, Eigen has intelligent compile-time mechanisms to determine automatically when to use lazy evaluation, and when on the contrary it should evaluate immediately into a temporary variable.
|
|
|
|
So in the basic example,
|
|
|
|
\code matrix1 = matrix2 + matrix3; \endcode
|
|
|
|
Eigen chooses lazy evaluation. Thus the arrays are traversed only once, producing optimized code. If you really want to force immediate evaluation, use \link MatrixBase::eval() eval()\endlink:
|
|
|
|
\code matrix1 = (matrix2 + matrix3).eval(); \endcode
|
|
|
|
Here is now a more involved example:
|
|
|
|
\code matrix1 = -matrix2 + matrix3 + 5 * matrix4; \endcode
|
|
|
|
Eigen chooses lazy evaluation at every stage in that example, which is clearly the correct choice. In fact, lazy evaluation is the "default choice" and Eigen will choose it except in a few circumstances.
|
|
|
|
<b>The first circumstance</b> in which Eigen chooses immediate evaluation, is when it sees an assignment <tt>a = b;</tt> and the expression \c b has the evaluate-before-assigning \link flags flag\endlink. The most important example of such an expression is the \link Product matrix product expression\endlink. For example, when you do
|
|
|
|
\code matrix = matrix * matrix; \endcode
|
|
|
|
Eigen first evaluates <tt>matrix * matrix</tt> into a temporary matrix, and then copies it into the original \c matrix. This guarantees a correct result as we saw above that lazy evaluation gives wrong results with matrix products. It also doesn't cost much, as the cost of the matrix product itself is much higher.
|
|
|
|
What if you know what you are doing and want to force lazy evaluation? Then use \link MatrixBase::lazy() .lazy()\endlink instead. Here is an example:
|
|
|
|
\code matrix1 = (matrix2 * matrix2).lazy(); \endcode
|
|
|
|
Here, since we know that matrix2 is not the same matrix as matrix1, we know that lazy evaluation is not dangerous, so we may force lazy evaluation. Concretely, the effect of lazy() here is to remove the evaluate-before-assigning \link flags flag\endlink and also the evaluate-before-nesting \link flags flag\endlink which we now discuss.
|
|
|
|
<b>The second circumstance</b> in which Eigen chooses immediate evaluation, is when it sees a nested expression such as <tt>a + b</tt> where \c b is already an expression having the evaluate-before-nesting \link flags flag\endlink. Again, the most important example of such an expression is the \link Product matrix product expression\endlink. For example, when you do
|
|
|
|
\code matrix1 = matrix2 + matrix3 * matrix4; \endcode
|
|
|
|
the product <tt>matrix3 * matrix4</tt> gets evaluated immediately into a temporary matrix. Indeed, experiments showed that it is often beneficial for performance to evaluate immediately matrix products when they are nested into bigger expressions.
|
|
|
|
Again, \link MatrixBase::lazy() .lazy()\endlink can be used to force lazy evaluation here.
|
|
|
|
<b>The third circumstance</b> in which Eigen chooses immediate evaluation, is when its cost model shows that the total cost of an operation is reduced if a sub-expression gets evaluated into a temporary. Indeed, in certain cases, an intermediate result is sufficiently costly to compute and is reused sufficiently many times, that is worth "caching". Here is an example:
|
|
|
|
\code matrix1 = matrix2 * (matrix3 + matrix4); \endcode
|
|
|
|
Here, provided the matrices have at least 2 rows and 2 columns, each coefficienct of the expression <tt>matrix3 + matrix4</tt> is going to be used several times in the matrix product. Instead of computing the sum everytime, it is much better to compute it once and store it in a temporary variable. Eigen understands this and evaluates <tt>matrix3 + matrix4</tt> into a temporary variable before evaluating the product.
|
|
|
|
*/
|
|
|
|
} |