Compilation fix for -Werror=shadow-compatible-local

Author: Nicolas Vasilache

tc/core/polyhedral/codegen_llvm.cc

@@ -614,31 +614,32 @@ IslCodegenRes codegenISL(const Scop& scop) {
     auto collectIteratorMaps =
         [](isl::ast_node node,
            isl::ast_build build,
-           IteratorMapsType& iteratorMaps,
-           const Scop& scop,
-           StmtSubscriptExprMapType& stmtSubscripts) -> isl::ast_node {
+           IteratorMapsType& iteratorMapsInFun,
+           const Scop& scopInFun,
+           StmtSubscriptExprMapType& stmtSubscriptsInFun) -> isl::ast_node {
       auto user = node.as<isl::ast_node_user>();
       CHECK(user);
       auto expr = user.get_expr().as<isl::ast_expr_op>();
       auto schedule = build.get_schedule();
       auto scheduleMap = isl::map::from_union_map(schedule);
 
       auto stmtId = expr.get_arg(0).as<isl::ast_expr_id>().get_id();
-      CHECK_EQ(0u, iteratorMaps.count(stmtId)) << "entry exists: " << stmtId;
+      CHECK_EQ(0u, iteratorMapsInFun.count(stmtId))
+          << "entry exists: " << stmtId;
       auto iteratorMap = isl::pw_multi_aff(scheduleMap.reverse());
-      auto iterators = scop.halide.iterators.at(stmtId);
-      auto& stmtIteratorMap = iteratorMaps[stmtId];
+      auto iterators = scopInFun.halide.iterators.at(stmtId);
+      auto& stmtIteratorMap = iteratorMapsInFun[stmtId];
       for (size_t i = 0; i < iterators.size(); ++i) {
         auto expr = build.expr_from(iteratorMap.get_pw_aff(i));
         stmtIteratorMap.emplace(iterators[i], expr);
       }
-      auto& subscripts = stmtSubscripts[stmtId];
-      auto provide =
-          scop.halide.statements.at(stmtId).as<Halide::Internal::Provide>();
+      auto& subscripts = stmtSubscriptsInFun[stmtId];
+      auto provide = scopInFun.halide.statements.at(stmtId)
+                         .as<Halide::Internal::Provide>();
       for (auto e : provide->args) {
         const auto& map = iteratorMap;
         auto space = map.get_space().params();
-        auto aff = scop.makeIslAffFromStmtExpr(stmtId, space, e);
+        auto aff = scopInFun.makeIslAffFromStmtExpr(stmtId, space, e);
         auto pulled = isl::pw_aff(aff).pullback(map);
         CHECK_EQ(pulled.n_piece(), 1);
         subscripts.push_back(build.expr_from(pulled));

tc/core/polyhedral/cuda/mapped_scop.cc

@@ -463,14 +463,16 @@ isl::union_set modifyMappingNames(
     space = space.set_dim_name(isl::dim_type::param, dim, name + suffix);
   }
   auto newSet = isl::union_set::empty(space);
-  set.foreach_set([&newSet, &identifiers, &suffix](isl::set set) {
+  set.foreach_set([&newSet, &identifiers, &suffix](isl::set setInFun) {
     for (auto id : identifiers) {
       auto name = id.get_name();
-      auto dim = set.get_space().find_dim_by_name(isl::dim_type::param, name);
+      auto dim =
+          setInFun.get_space().find_dim_by_name(isl::dim_type::param, name);
       CHECK_LE(0, dim);
-      set = set.set_dim_name(isl::dim_type::param, dim, name + suffix);
+      setInFun =
+          setInFun.set_dim_name(isl::dim_type::param, dim, name + suffix);
     }
-    newSet = newSet.unite(set);
+    newSet = newSet.unite(setInFun);
   });
   return newSet;
 }

test/cuda/test_tc_mapper.cc

@@ -260,10 +260,10 @@ def batch_triple_hadamard(float(B, D) U, float(B, D) V, float(B, D) W) -> (Z) {
 }
   )TC";
 
-  auto checkFun = [=](const std::vector<at::Tensor>& inputs,
-                      std::vector<at::Tensor>& outputs) {
-    at::Tensor diff = outputs[0].sub(inputs[0] * inputs[1] * inputs[2]);
-    checkRtol(diff, inputs, D);
+  auto checkFun = [=](const std::vector<at::Tensor>& ins,
+                      std::vector<at::Tensor>& outs) {
+    at::Tensor diff = outs[0].sub(ins[0] * ins[1] * ins[2]);
+    checkRtol(diff, ins, D);
   };
   Check(
       TC,
@@ -289,8 +289,8 @@ def tensordot(float(N, C1, C2, H, W) I0, float(N, C2, C3, H, W) I1) -> (O) {
 }
   )TC";
   // No defaults for this case
-  auto checkFun = [](const std::vector<at::Tensor>& inputs,
-                     std::vector<at::Tensor>& outputs) { return true; };
+  auto checkFun = [](const std::vector<at::Tensor>& ins,
+                     std::vector<at::Tensor>& outs) { return true; };
   auto options = tc::CudaMappingOptions::makeNaiveMappingOptions();
   auto name = "tensordot";
   Check(TC, name, options, inputs, checkFun);
@@ -314,13 +314,13 @@ def fun(float(B, R) LUT, int32(B, N) I) -> (O) {
 }
 )TC";
 
-  auto checkFun = [=](const std::vector<at::Tensor>& inputs,
-                      std::vector<at::Tensor>& outputs) {
-    at::Tensor LUT = inputs[0].toBackend(at::kCPU);
-    at::Tensor I = inputs[1].toBackend(at::kCPU);
-    at::Tensor O = outputs[0].toBackend(at::kCPU);
-    auto LUTAccessor = LUT.accessor<float, 2>();
-    auto IAccessor = I.accessor<int, 2>();
+  auto checkFun = [=](const std::vector<at::Tensor>& ins,
+                      std::vector<at::Tensor>& outs) {
+    at::Tensor lut = ins[0].toBackend(at::kCPU);
+    at::Tensor in = ins[1].toBackend(at::kCPU);
+    at::Tensor O = outs[0].toBackend(at::kCPU);
+    auto LUTAccessor = lut.accessor<float, 2>();
+    auto IAccessor = in.accessor<int, 2>();
     auto OAccessor = O.accessor<float, 2>();
     for (int b = 0; b < B; b++) {
       for (int n = 0; n < N; n++) {
@@ -334,7 +334,7 @@ def fun(float(B, R) LUT, int32(B, N) I) -> (O) {
       }
     }
 
-    checkRtol(O, inputs, 5e-7);
+    checkRtol(O, ins, 5e-7);
   };
   Check(
       TC,
@@ -378,8 +378,8 @@ def spatial_batch_norm(
     normalizedOut(n, c, h, w) =        O(n, c, h, w)
 })TC";
 
-  auto checkFun = [=](const std::vector<at::Tensor>& inputs,
-                      std::vector<at::Tensor>& outputs) {
+  auto checkFun = [=](const std::vector<at::Tensor>& ins,
+                      std::vector<at::Tensor>& outs) {
     TC_CUDA_RUNTIMEAPI_ENFORCE(cudaDeviceSynchronize());
     double prec = 3e-7;
     std::cout << "Checking expected output relative precision @" << prec;
@@ -396,8 +396,8 @@ def spatial_batch_norm(
         at::Scalar(momentum[0]).toFloat(),
         at::Scalar(eps[0]).toFloat(),
         true);
-    auto diff = O.sub(outputs[0]);
-    checkRtol(diff, inputs, N * H * W, prec);
+    auto diff = O.sub(outs[0]);
+    checkRtol(diff, ins, N * H * W, prec);
   };
 
   auto name = "spatial_batch_norm";