Eigen alignment crashes on Windows

[johnwason]

TL;DR Eigen alignment is causing crashes on Windows in some situations. Disabling Eigen using -DEIGEN_DONT_ALIGN=1 -DEIGEN_DONT_VECTORIZE=1 seems to fix the problem.

After a long search for the crashes on Windows, I found #746 and tesseract-robotics/tesseract_ext#44 as the source of the problems, as well as a strange crash with Eigen that took a long time to track down. Eigen attempts to align the data structures so they can be used with vectorized instructions. I am not sure how it is done on Linux, but on Windows the segfaults were tracked down to a function handmade_aligned_free. There is a corresponding handmade_aligned_alloc.

/** \internal Frees memory allocated with handmade_aligned_malloc */
EIGEN_DEVICE_FUNC inline void handmade_aligned_free(void *ptr)
{
  if (ptr) {
    EIGEN_USING_STD(free)
    free(*(reinterpret_cast<void**>(ptr) - 1));
  }
}

/** \internal Like malloc, but the returned pointer is guaranteed to be 16-byte aligned.
  * Fast, but wastes 16 additional bytes of memory. Does not throw any exception.
  */
EIGEN_DEVICE_FUNC inline void* handmade_aligned_malloc(std::size_t size, std::size_t alignment = EIGEN_DEFAULT_ALIGN_BYTES)
{
  eigen_assert(alignment >= sizeof(void*) && (alignment & (alignment-1)) == 0 && "Alignment must be at least sizeof(void*) and a power of 2");

  EIGEN_USING_STD(malloc)
  void *original = malloc(size+alignment);
  
  if (original == 0) return 0;
  void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(alignment-1))) + alignment);
  *(reinterpret_cast<void**>(aligned) - 1) = original;
  return aligned;
}

I have read that it may be the DLL interfaces causing the problem, but in general this type of pointer arithmetic is a bad idea.
MSVC has _aligned_malloc and _aligned_free functions which should be used instead, but I don't know enough about eigen or vectorized instructions to easily fix this problem. This problem is showing up in conda builds, but is not appearing in ROS Noetic Windows builds. I don't have an explanation, but it may just be luck or some compiler bug causing the problem.

[Levi-Armstrong]

I have ran into a lot of eigen alignment issues on linux also. It turns out if any class or struct contains a member variable which is an alignable type then that class and struct must have EIGEN_MAKE_ALIGNED_OPERATOR_NEW and if you store that struct in a class or struct then it must also contain EIGEN_MAKE_ALIGNED_OPERATOR_NEW which is invasive. I asked a questing a while back on eigen if they had a tool to check for this and it appears they do not so we went through and added this to every class and struct and the alignment went away. Since then we have made some improvements so it very possible some classes and struct may be missing this. This goes away in newer versions of Eigen where they upgrade to a newer version of c++ which allows them to overload the new operator and the EIGEN_MAKE_ALIGNED_OPERATOR_NEW is no longer needed but not sure when they will make that version the default on linux.

[johnwason]

Adding the compiler flag /std:c++17 to the VS2019 compiler seems to fix the problem? Apparently CMake wasn't passing the correct flag, and the compiler was defaulting to C++14. This does not have the alignment features necessary to make it work (apparently).

[Levi-Armstrong]

What version of cmake does it have?

[johnwason]

cmake version 3.23.1

[Levi-Armstrong]

I assume we must need to do something in this to correctly handle windows. Do you have any ideas?

https://github.com/ros-industrial/ros_industrial_cmake_boilerplate/blob/e909bcd7008081e3f24a24ce7035f5cd8aef5949/ros_industrial_cmake_boilerplate/cmake/cmake_tools.cmake#L448-L476

[johnwason]

All packages must have the same C++ version flags for Eigen to work, otherwise there will be incompatibilities in the generated code. I have been solving this problem by defining:

set CXXFLAGS=%CXXFLAGS% /std:c++17

Now I have been seeing failures even with this flag set. It may be necessary to completely disable alignment on Windows until Eigen uses the correct aligned allocators.