Add checks to validate strides before compilation

This commit is motivated by the need to implement checks to verify
correct strides. Adding a new unit test with incorrect strides which
looks for a new exception. Added overloaded functions to print out
information from DLTensor, DLConstTensor, TensorInfo. Added a helper
function to throw an invalid stride exception.

Author: Protonu Basu

tc/core/compiler.cc

@@ -18,6 +18,7 @@
 #include <sstream>
 #include <string>
 
+#include "tc/core/exceptions.h"
 #include "tc/core/flags.h"
 #include "tc/core/halide_utils.h"
 #include "tc/core/tensor.h"
@@ -35,6 +36,19 @@ std::vector<TensorInfo> inferOutputTensorInfo(
 }
 
 namespace detail {
+
+inline void helpThrowInvalidStride(
+    const lang::TreeRef param,
+    const DLConstTensor* inputsInfo) {
+  lang::ErrorReport ep = lang::ErrorReport(param);
+  std::ostringstream err_c;
+  err_c << ep.what() << "compilation aborted: invalid strides in tensor "
+        << std::endl;
+  err_c << *(inputsInfo);
+  err_c << std::endl;
+  throw InvalidStrideException(err_c.str());
+}
+
 void checkInputsCompliant(
     const tc2halide::HalideComponents& halideComponents,
     const std::vector<const DLConstTensor*>& inputsInfo) {
@@ -67,6 +81,20 @@ void checkInputsCompliant(
           << "expected a tensor with " << hdim << " dimensions but found "
           << dldim << " dimensions.";
     }
+    auto dlstrides = inputsInfo[i]->strides;
+    auto dlsizes = inputsInfo[i]->shape;
+    if (dldim) {
+      if (dlstrides[dldim - 1] < 1) {
+        helpThrowInvalidStride(
+            halideComponents.getDef().params()[i], inputsInfo[i]);
+      }
+      for (size_t j = 0; j < dldim - 1; ++j) {
+        if (dlstrides[j] < dlstrides[j + 1] * dlsizes[j + 1]) {
+          helpThrowInvalidStride(
+              halideComponents.getDef().params()[i], inputsInfo[i]);
+        }
+      }
+    }
   }
 }
 

tc/core/compiler.h

@@ -117,6 +117,7 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
 std::vector<TensorInfo> inferOutputTensorInfo(
     lang::TreeRef tcDefinition,
     const std::vector<const DLConstTensor*> inputs);
+
 } // namespace detail
 } // namespace tc
 

tc/core/exceptions.h

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+namespace tc {
+
+struct InvalidStrideException : public std::runtime_error {
+  explicit InvalidStrideException(const std::string& s)
+      : std::runtime_error(s) {}
+};
+
+} // namespace tc

tc/core/tensor.cc

@@ -107,6 +107,48 @@ bool TensorInfo::operator!=(const TensorInfo& t) const {
   return !(*this == t);
 }
 
+std::ostream& operator<<(std::ostream& os, const TensorInfo& t) {
+  auto ndim = t.shape.size();
+  if (ndim == 0) {
+    return os;
+  }
+  os << "Dimensions: [";
+  if (ndim) {
+    for (size_t i = 0; i < ndim - 1; ++i) {
+      os << t.shape[i] << ", ";
+    }
+    os << t.shape[ndim - 1] << "]";
+    os << " Strides: [";
+    if (t.strides.size()) {
+      for (size_t i = 0; i < ndim - 1; ++i) {
+        os << t.strides[i] << ", ";
+      }
+      os << t.strides[ndim - 1] << "] ";
+    }
+  }
+  os << "Type: ";
+  os << toString(t.dtype) << " ";
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const DLTensor& t) {
+  auto t_info = TensorInfo(&t);
+  os << t_info;
+  os << "Byte Offset: ";
+  os << t.byte_offset << " ";
+  os << "Base Pointer: " << t.data << " ";
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const DLConstTensor& t) {
+  auto t_info = TensorInfo(&t);
+  os << t_info;
+  os << "Byte Offset: ";
+  os << t.byte_offset << " ";
+  os << "Base Pointer: " << t.data << " ";
+  return os;
+}
+
 std::vector<TensorInfo> makeTensorInfoVector(
     const google::protobuf::RepeatedPtrField<TensorInfoProto>& buf) {
   std::vector<TensorInfo> iis;

tc/core/tensor.h

@@ -127,6 +127,8 @@ bool operator==(const DLDataType& t1, const DLDataType& t2);
 std::string toString(const DLDataType& t);
 std::ostream& operator<<(std::ostream& os, const DLDataType& t);
 std::ostream& operator<<(std::ostream& os, const DLTensor& t);
+std::ostream& operator<<(std::ostream& os, const TensorInfo& t);
+std::ostream& operator<<(std::ostream& os, const DLConstTensor& t);
 
 // Basic metadata-owning DLTensor, only copies the underlying raw pointer.
 DLTensorUPtr makeDLTensor(const DLTensor* ptr);

test/cuda/test_tc_mapper.cc

@@ -22,6 +22,7 @@
 #include "tc/aten/aten_compiler.h"
 #include "tc/core/cuda/cuda.h"
 #include "tc/core/cuda/cuda_tc_executor.h"
+#include "tc/core/exceptions.h"
 #include "tc/core/scope_guard.h"
 #include "tc/lang/canonicalize.h"
 #include "tc/lang/sema.h"
@@ -306,10 +307,10 @@ TEST_F(TcCudaMapperTest, TensorAddStrided) {
   M = 64;
   at::Tensor I0 = at::CUDA(at::kFloat).rand({N, M});
   at::Tensor I0_view =
-      I0.type().tensor().set_(*I0.storage(), 0, {N, M}, {1, 16});
+      I0.type().tensor().set_(*I0.storage(), 0, {N, M}, {128, 1});
   at::Tensor I1 = at::CUDA(at::kFloat).rand({N, M});
   at::Tensor I1_view =
-      I1.type().tensor().set_(*I1.storage(), 0, {N, M}, {1, 16});
+      I1.type().tensor().set_(*I1.storage(), 0, {N, M}, {128, 1});
   std::vector<at::Tensor> inputs = {I0_view, I1_view};
 
   static constexpr auto TC = R"TC(
@@ -327,12 +328,41 @@ def tensoraddstrided(float(N, M) I0_view, float(N, M) I1_view) -> (O) {
   std::string expected =
       "const float32 (*I0_view)[64] = "
       "reinterpret_cast<const float32 (*)[64]>(pI0_view)";
-
   ASSERT_NE(std::string::npos, res.second.find(expected))
       << "In resulting code:\n"
       << res.second << "\nfound unexpected: " << expected;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// TensorAddInvalidStrides
+//   O(n, m) += I0_view(n, m) * I1_view(n, m)
+///////////////////////////////////////////////////////////////////////////////
+TEST_F(TcCudaMapperTest, TensorAddInvalidStrides) {
+  N = 64;
+  M = 64;
+  at::Tensor I0 = at::CUDA(at::kFloat).rand({N, M});
+  at::Tensor I0_view =
+      I0.type().tensor().set_(*I0.storage(), 0, {N, M}, {16, 1});
+  at::Tensor I1 = at::CUDA(at::kFloat).rand({N, M});
+  at::Tensor I1_view =
+      I1.type().tensor().set_(*I1.storage(), 0, {N, M}, {16, 1});
+  std::vector<at::Tensor> inputs = {I0_view, I1_view};
+
+  static constexpr auto TC = R"TC(
+def tensoraddstrided(float(N, M) I0_view, float(N, M) I1_view) -> (O) {
+    O(n, m) += I0_view(n, m) + I1_view(n, m)
+}
+  )TC";
+
+  auto checkFun = [](const std::vector<at::Tensor>& ins,
+                     std::vector<at::Tensor>& outs) { return true; };
+  auto options = tc::CudaMappingOptions::makeNaiveMappingOptions();
+  auto name = "tensoraddstrided";
+
+  EXPECT_THROW(
+      Check(TC, name, options, inputs, checkFun), tc::InvalidStrideException);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Lookup Table
 //   O(b, n) +=! LUT(I(b, n), r_r)