Thanks for the answer!
Sorry again for my unclear phrasing!
Just to be absolutely sure:
Lets say we have:
If we use A locally:
is a.t aligned on the Stack, (how does alignment work on the stack)
If we use A on the heap:
A * a = new A;
then as "a" is not aligned , also a.t is not aligned
If we use EIGEN_MAKE_ALLOCATOR_NEW inside A , then "a" is aligned ,
BUT what happens in this example:
std::vector< C , Eigen::aligned_allocator<C> >
Is vec.b.a.t now aligned in memory? which does NOT
result in a segfault if Eigen uses SIMD internally?
If we use locally lets say:
c.b.a.t do something with t
is c.b.a.t aligned on the Stack?
Or on the heap:
C * c = new C;
c might not be aligned => c.b might not be aligned => c.b.a
=> might not bealigned => c.b.a.t might not be aligned =>
SEGFAULT for usage of c.b.a.t
How do I need to correct the above example such that in the cases
above, vector A::t is always aligned to 16bytes?
Thanks for the help!
On 11/26/2014 04:40 PM, Christoph
On 26.11.2014 16:17, Gabriel wrote:
So that means if we have a class S with a
hierarchy of classes composed
By hierarchy of classes, I usually assume inheritance, not
in each other and
the last one uses a fixed-size vectorizable type, for example
In your example, I would call `A` the first class/struct (or
inner-most to be more specific). Your code would not compile as it
is, because `C` needs to know `B` and `B` needs to know `A`.
EIGEN_MAKE_ALIGNED_OPERATOR_NEW // < IS THIS NEEDED?
You need the EIGEN_MAKE_ALIGNED_OPERATOR_NEW only in classes which
you intend to allocate using new. It will not really hurt, adding
it to all other classes as well (only some code is generated,
which should be removed during linkage if it is not used).
Inheritance will propagate AlignedNew, but composing classes will
and we want to use S in an
We need :
std::vector<S, Eigen::aligned_allocator<S> >;
Yes, if S requires alignment, this is what you need to write (for
C++03). C++11 makes the #include<Eigen/StdVector> redundant.
Is that correct? Isnt that really
Mostly, that is the fault of C++, because it does not
automatically propagate alignment requirements to new and
std::allocator. This does not properly work in C++11 yet, either
(not sure if by design, or because compilers aren't ready yet).
Also cf this bug report:
Actually, for many 64bit systems many things work out of the box,
because allocation methods align to 16byte by default (again, I'm
not entirely sure if that is mandatory, or system specific).