[mlir] Add padding to 1-D Vector in CRunnerUtils.h

[nicolasvasilache]

Summary

This revision adds padding for 1-D Vector in the common case of x86
execution with a stadard data layout. This supports properly interfacing
codegen with arrays of e.g. vector<9xf32>.

Such vectors are already assumed padded to the next power of 2 by LLVM
codegen with the default x86 data layout:

define void @test_vector_add_1d_2_3(<3 x float>* nocapture readnone %0,
<3 x float>* nocapture readonly %1, i64 %2, i64 %3, i64 %4, <3 x float>*
nocapture readnone %5, <3 x float>* nocapture readonly %6, i64 %7, i64
%8, i64 %9, <3 x float>* nocapture readnone %10, <3 x float>* nocapture
%11, i64 %12, i64 %13, i64 %14) local_unnamed_addr {
  %16 = getelementptr <3 x float>, <3 x float>* %6, i64 1
  %17 = load <3 x float>, <3 x float>* %16, align 16
  %18 = getelementptr <3 x float>, <3 x float>* %1, i64 1
  %19 = load <3 x float>, <3 x float>* %18, align 16
  %20 = fadd <3 x float> %17, %19
  %21 = getelementptr <3 x float>, <3 x float>* %11, i64 1

The pointer addressing a vector<3xf32> is assumed aligned @16.
Similarly, the pointer addressing a vector<65xf32> is assumed aligned
@512.

This revision allows using objects such as vector<3xf32> properly with
the standard x86 data layout used in the JitRunner. Integration testing
is done out of tree, at the moment such testing fails without this
change.

[nicolasvasilache]

Update assertions.

[nicolasvasilache]

Format.

[stella.stamenova]

I'm seeing an error on Windows with this:

##[error]mlir\include\mlir\ExecutionEngine\CRunnerUtils.h(93,0): Error C2672: 'detail::nextPowerOf2': no matching overloaded function found
   378>E:\agent\_work\4\s\mlir\include\mlir/ExecutionEngine/CRunnerUtils.h(93): error C2672: 'detail::nextPowerOf2': no matching overloaded function found [E:\agent\_work\4\b\tools\mlir\test\mlir-cpu-runner\cblas.vcxproj]
         E:\agent\_work\4\s\mlir\include\mlir/ExecutionEngine/CRunnerUtils.h(94): note: see reference to class template instantiation 'detail::Vector1D<T,Dim,false>' being compiled
##[error]mlir\include\mlir\ExecutionEngine\CRunnerUtils.h(93,0): Error C2975: 'N': invalid template argument for 'detail::nextPowerOf2', expected compile-time constant expression
   378>E:\agent\_work\4\s\mlir\include\mlir/ExecutionEngine/CRunnerUtils.h(93): error C2975: 'N': invalid template argument for 'detail::nextPowerOf2', expected compile-time constant expression [E:\agent\_work\4\b\tools\mlir\test\mlir-cpu-runner\cblas.vcxproj]
         E:\agent\_work\4\s\mlir\include\mlir/ExecutionEngine/CRunnerUtils.h(58): note: see declaration of 'N'
##[error]mlir\include\mlir\ExecutionEngine\CRunnerUtils.h(113,0): Error C2672: 'detail::isPowerOf2': no matching overloaded function found
   378>E:\agent\_work\4\s\mlir\include\mlir/ExecutionEngine/CRunnerUtils.h(113): error C2672: 'detail::isPowerOf2': no matching overloaded function found [E:\agent\_work\4\b\tools\mlir\test\mlir-cpu-runner\cblas.vcxproj]
         E:\agent\_work\4\s\mlir\include\mlir/ExecutionEngine/CRunnerUtils.h(113): note: see reference to class template instantiation 'Vector<T,Dim,>' being compiled
##[error]mlir\include\mlir\ExecutionEngine\CRunnerUtils.h(113,0): Error C2975: 'N': invalid template argument for 'detail::isPowerOf2', expected compile-time constant expression
   378>E:\agent\_work\4\s\mlir\include\mlir/ExecutionEngine/CRunnerUtils.h(113): error C2975: 'N': invalid template argument for 'detail::isPowerOf2', expected compile-time constant expression [E:\agent\_work\4\b\tools\mlir\test\mlir-cpu-runner\cblas.vcxproj]
         E:\agent\_work\4\s\mlir\include\mlir/ExecutionEngine/CRunnerUtils.h(43): note: see declaration of 'N'

[nicolasvasilache]

@stella.stamenova this seems related: https://developercommunityapi.westus.cloudapp.azure.com/content/problem/110435/not-compile-time-constant-expression.html
This is marked as "fixed in: visual studio 2019 version 16.2"

[stella.stamenova]

In D75459#1903822, @nicolasvasilache wrote:

@stella.stamenova this seems related: https://developercommunityapi.westus.cloudapp.azure.com/content/problem/110435/not-compile-time-constant-expression.html
This is marked as "fixed in: visual studio 2019 version 16.2"

We are still using VS 2017 because of the bug in some versions of VS 2019 that hits LLVM (https://developercommunity.visualstudio.com/content/problem/845933/miscompile-boolean-condition-deduced-to-be-always.html).

[nicolasvasilache]

@stella.stamenova this seems a bit tricky to fix at a distance for me, can you propose a patch that would selectively disable what your particular version of MSVC does not support for now with a TODO once it can be reactivated?

[flaub]

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

42

We should be able to replace this chunk with:

constexpr bool isPowerOf2(int N) { return (!(N & (N - 1))); }

constexpr unsigned nextPowerOf2(int N) {
  if (N < 1)
    return 1;
  return isPowerOf2(N) ? N : 2 * nextPowerOf2((N + 1) / 2);
}

This should work on C++11 and also works with MSVC.

[flaub]

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

85

With the above change, this can be:

char padding[detail::nextPowerOf2(sizeof(T[Dim])) - sizeof(T[Dim])];

Which I think is both easier to read and works on MSVC. We should probably try to use constexpr functions over template specialization now that we can use C++11.

[flaub]

See https://reviews.llvm.org/D75584 for a potential fix.

[nicolasvasilache]

thanks much @flaub !

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

 template <int N> void dropFront(int64_t arr[N], int64_t *res) {
   for (unsigned i = 1; i < N; ++i)
     *(res + i - 1) = arr[i];
 }
 
 //===----------------------------------------------------------------------===//
 // Codegen-compatible structures for Vector type.
 //===----------------------------------------------------------------------===//
+namespace detail {
+  template <unsigned N>
+  constexpr unsigned nextPowerOf2();
+  template <>
+  constexpr unsigned nextPowerOf2<0>() {
+    return 1;
+  }
+  template <>
+  constexpr unsigned nextPowerOf2<1>() {
+    return 1;
+  }
+  template <unsigned N>
+  constexpr unsigned nextPowerOf2() {
+    return (!(N & (N - 1))) ? N : 2 * nextPowerOf2<(N + 1) / 2>();
+  }
+} // end namespace detail
+
+// N-D vectors recurse down to 1-D.
 template <typename T, int Dim, int... Dims>
 struct Vector {
+  constexpr Vector<T, Dims...> &operator[](unsigned i) { return vector[i]; }
+  constexpr const Vector<T, Dims...> &operator[](unsigned i) const {
+    return vector[i];
+  }
+
+private:
   Vector<T, Dims...> vector[Dim];
 };
 
-template <typename T, int Dim>
-struct Vector<T, Dim> {
+// 1-D vectors in LLVM are automatically padded to the next power of 2.
+// We insert explicit padding in to account for this.
+template <typename T, int Dim> struct Vector<T, Dim> {
+  Vector() {
+    static_assert(detail::nextPowerOf2<sizeof(T[Dim])>() >= sizeof(T[Dim]),
+                  "size error");
+    static_assert(detail::nextPowerOf2<sizeof(T[Dim])>() < 2 * sizeof(T[Dim]),
+                  "size error");
+  }
+  constexpr T &operator[](unsigned i) { return vector[i]; }
+  constexpr const T &operator[](unsigned i) const { return vector[i]; }
+
+private:
   T vector[Dim];
+  char padding[detail::nextPowerOf2<sizeof(T[Dim])>() - sizeof(T[Dim])];
 };
 
 template <int D1, typename T>
 using Vector1D = Vector<T, D1>;
 template <int D1, int D2, typename T>
 using Vector2D = Vector<T, D1, D2>;
 template <int D1, int D2, int D3, typename T>
 using Vector3D = Vector<T, D1, D2, D3>;

mlir/include/mlir/ExecutionEngine/RunnerUtils.h

 
 template <typename T, int M, int... Dims>
 void VectorDataPrinter<T, M, Dims...>::print(std::ostream &os,
                                              const Vector<T, M, Dims...> &val) {
   static_assert(M > 0, "0 dimensioned tensor");
   static_assert(sizeof(val) == M * StaticSizeMult<Dims...>::value * sizeof(T),
                 "Incorrect vector size!");
   // First
-  os << "(" << val.vector[0];
+  os << "(" << val[0];
   if (M > 1)
     os << ", ";
   if (sizeof...(Dims) > 1)
     os << "\n";
   // Kernel
   for (unsigned i = 1; i + 1 < M; ++i) {
     printSpace(os, 2 * sizeof...(Dims));
-    os << val.vector[i] << ", ";
+    os << val[i] << ", ";
     if (sizeof...(Dims) > 1)
       os << "\n";
   }
   // Last
   if (M > 1) {
     printSpace(os, sizeof...(Dims));
-    os << val.vector[M - 1];
+    os << val[M - 1];
   }
   os << ")";
 }
 
 template <typename T, int M, int... Dims>
 std::ostream &operator<<(std::ostream &os, const Vector<T, M, Dims...> &v) {
   VectorDataPrinter<T, M, Dims...>::print(os, v);
   return os;