add support for modulo operator

support % operator: propagate it from parser to halide to isl and add
unit tests

Author: prigoyal

tc/core/tc2halide.cc

@@ -158,6 +158,8 @@ Expr translateExpr(
       return t(0) * t(1);
     case '/':
       return t(0) / t(1);
+    case '%':
+      return t(0) % t(1);
     case lang::TK_MIN:
       return min(t(0), t(1));
     case lang::TK_MAX:

tc/lang/lexer.h

@@ -87,7 +87,7 @@ namespace lang {
   _(TK_LET, "let", "")                           \
   _(TK_EXISTS, "exists", "exists")
 
-static const char* valid_single_char_tokens = "+-*/()[]?:,={}><!";
+static const char* valid_single_char_tokens = "+-*/()[]?:,={}><!%";
 
 enum TokenKind {
   // we use characters to represent themselves so skip all valid characters
@@ -137,7 +137,7 @@ struct SharedParserData {
         {TK_AND},
         {'>', '<', TK_LE, TK_GE, TK_EQ, TK_NE},
         {'+', '-'},
-        {'*', '/'},
+        {'*', '/', '%'},
     };
     std::vector<std::vector<int>> unary_ops = {
         {'-', '!'},

tc/lang/sema.h

@@ -293,6 +293,7 @@ struct Sema {
       case '-':
       case '*':
       case '/':
+      case '%':
       case TK_MIN:
       case TK_MAX: {
         auto nexp =

tc/lang/test_expected/math.expected

@@ -1,7 +1,9 @@
 (-
   (+
     (+
-      (- (const 3 (int32)))
+      (%
+        (- (const 3 (int32)))
+        (const 2 (int32)))
       (*
         (const 4 (int32))
         (const 5 (int32))))

test/cuda/test_corner_cases.cc

@@ -320,6 +320,18 @@ i))
       at::Scalar(d[0]).toFloat());
 }
 
+TEST(TestCornerCases, E25) {
+  auto a = I();
+  auto b = I();
+  auto r = I(1);
+  Succeed(
+      "def f(int32 a, int32 b) -> (c) { c(i) = int32(a % b) where i in 0:1 }",
+      {a, b},
+      {r});
+  auto e = at::Scalar(a).toInt() % at::Scalar(b).toInt();
+  CHECK_EQ(at::Scalar(r[0]).toInt(), e);
+}
+
 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   ::gflags::ParseCommandLineFlags(&argc, &argv, true);

test/test_cuda_mapper.cc

@@ -1118,6 +1118,40 @@ TEST_F(PolyhedralMapperTest, EmptyMappingFilter) {
   mscop->codegen(specializedName);
 }
 
+TEST_F(PolyhedralMapperTest, ModulusConstantRHS) {
+  string tc = R"TC(
+def fun(float(N) a) -> (b) { b(i) = a(i % 3) where i in 0:N }
+)TC";
+  // This triggers tc2halide conversion and should not throw.
+  auto scop = Prepare(tc);
+  auto ctx = scop->domain().get_ctx();
+  for (auto r : scop->reads.wrap().get_set_list()) {
+    auto read = r.unwrap();
+    // skip irrelevant reads, if any
+    if (read.range().get_tuple_name() != std::string("a")) {
+      continue;
+    }
+    EXPECT_EQ(r.get_stride(0), 3);
+  }
+}
+
+TEST_F(PolyhedralMapperTest, ModulusVariableRHS) {
+  string tc = R"TC(
+def local_sparse_convolution(float(N, C, H, W) I, float(O, KC, KH, KW) W1) -> (O1) {
+  O1(n, o, h, w) +=! I(n, kc % c, h + kh, w + kw) * W1(o, kc, kh, kw) where c in 1:C
+}
+)TC";
+  // This triggers tc2halide conversion and should not throw.
+  auto scop = Prepare(tc);
+  for (auto r : scop->reads.range().get_set_list()) {
+    // skip irrelevant reads, if any
+    if (r.get_tuple_name() != std::string("I")) {
+      continue;
+    }
+    EXPECT_TRUE(r.plain_is_universe());
+  }
+}
+
 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   ::gflags::ParseCommandLineFlags(&argc, &argv, true);

test/test_lang.cc

@@ -232,7 +232,7 @@ int main(int argc, char** argv) {
     ASSERT(s->tree(0)->stringValue() == "min");
   }
   {
-    std::string stuff = "-3+4*5+7-a";
+    std::string stuff = "-3%2+4*5+7-a";
     Parser p(stuff);
     auto r = p.parseExp();
     std::stringstream ss;