Merge pull request #314 from NVIDIA/clamp

Fix unused variable out warning

Author: narendasan

core/conversion/converters/impl/element_wise.cpp

@@ -176,7 +176,7 @@ auto element_wise_registrations TRTORCH_UNUSED =
                     }
 
                     auto out = ctx->AssociateValueAndTensor(n->outputs()[0], clamp_layer_out);
-                    LOG_DEBUG("Clamp layer output tensor shape: " << clamp_layer_out->getDimensions());
+                    LOG_DEBUG("Clamp layer output tensor shape: " << out->getDimensions());
                     return true;
                   }})
         .pattern({"aten::sub.Tensor(Tensor self, Tensor other, Scalar alpha=1) -> "

tests/core/conversion/converters/test_element_wise.cpp

@@ -240,115 +240,115 @@ TEST(Converters, ATenRsubWithScalarConvertsCorrectly) {
 
 TEST(Converters, ATenClampMinConvertsCorrectly) {
   const auto graph = R"IR(
-    graph(%x.1 : Tensor):
-            %2 : int = prim::Constant[value=-2]()
-            %3 : None = prim::Constant()
-            %4 : Tensor = aten::clamp(%x.1, %2, %3)
-            return (%4))IR";
+  graph(%x.1 : Tensor):
+          %2 : int = prim::Constant[value=-2]()
+          %3 : None = prim::Constant()
+          %4 : Tensor = aten::clamp(%x.1, %2, %3)
+          return (%4))IR";
   pointwise_test_helper(graph, true);
 }
 
 TEST(Converters, ATenClampMaxConvertsCorrectly) {
   const auto graph = R"IR(
-    graph(%x.1 : Tensor):
-            %2 : int = prim::Constant[value=3]()
-            %3 : None = prim::Constant()
-            %4 : Tensor = aten::clamp(%x.1, %3, %2)
-            return (%4))IR";
+  graph(%x.1 : Tensor):
+          %2 : int = prim::Constant[value=3]()
+          %3 : None = prim::Constant()
+          %4 : Tensor = aten::clamp(%x.1, %3, %2)
+          return (%4))IR";
   pointwise_test_helper(graph, true);
 }
 
 TEST(Converters, ATenClampMinMaxConvertsCorrectly) {
   const auto graph = R"IR(
-    graph(%x.1 : Tensor):
-            %2 : int = prim::Constant[value=3]()
-            %3 : int = prim::Constant[value=-2]()
-            %4 : Tensor = aten::clamp(%x.1, %3, %2)
-            return (%4))IR";
+  graph(%x.1 : Tensor):
+          %2 : int = prim::Constant[value=3]()
+          %3 : int = prim::Constant[value=-2]()
+          %4 : Tensor = aten::clamp(%x.1, %3, %2)
+          return (%4))IR";
   pointwise_test_helper(graph, true);
 }
 
 TEST(Converters, ATenGreaterThanConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor, %1 : Tensor):
-        %2 : Tensor = aten::gt(%0, %1)
-        return (%2))IR";
+    graph(%0 : Tensor, %1 : Tensor):
+      %2 : Tensor = aten::gt(%0, %1)
+      return (%2))IR";
   pointwise_test_helper(graph, false, false, {5, 5}, {5, 5});
 }
 
 TEST(Converters, ATenGreaterThanScalarConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor):
-        %scalar : float = prim::Constant[value=3]()
-        %2 : Tensor = aten::gt(%0, %scalar)
-        return (%2))IR";
+    graph(%0 : Tensor):
+      %scalar : float = prim::Constant[value=3]()
+      %2 : Tensor = aten::gt(%0, %scalar)
+      return (%2))IR";
   pointwise_test_helper(graph, true, false, {5, 5});
 }
 
 TEST(Converters, ATenLessThanConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor, %1 : Tensor):
-        %2 : Tensor = aten::lt(%0, %1)
-        return (%2))IR";
+    graph(%0 : Tensor, %1 : Tensor):
+      %2 : Tensor = aten::lt(%0, %1)
+      return (%2))IR";
   pointwise_test_helper(graph, false, false, {5, 5}, {5, 5});
 }
 
 TEST(Converters, ATenLessThanScalarConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor):
-        %scalar : float = prim::Constant[value=3]()
-        %2 : Tensor = aten::lt(%0, %scalar)
-        return (%2))IR";
+    graph(%0 : Tensor):
+      %scalar : float = prim::Constant[value=3]()
+      %2 : Tensor = aten::lt(%0, %scalar)
+      return (%2))IR";
   pointwise_test_helper(graph, true, false, {5, 5});
 }
 
 TEST(Converters, ATenEqualConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor, %1 : Tensor):
-        %2 : Tensor = aten::eq(%0, %1)
-        return (%2))IR";
+    graph(%0 : Tensor, %1 : Tensor):
+      %2 : Tensor = aten::eq(%0, %1)
+      return (%2))IR";
   pointwise_test_helper(graph, false, false, {5, 5}, {5, 5});
 }
 
 TEST(Converters, ATenEqualScalarConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor):
-        %scalar : float = prim::Constant[value=3]()
-        %2 : Tensor = aten::eq(%0, %scalar)
-        return (%2))IR";
+    graph(%0 : Tensor):
+      %scalar : float = prim::Constant[value=3]()
+      %2 : Tensor = aten::eq(%0, %scalar)
+      return (%2))IR";
   pointwise_test_helper(graph, true, false, {5, 5});
 }
 
 TEST(Converters, ATenGEConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor, %1 : Tensor):
-        %2 : Tensor = aten::ge(%0, %1)
-        return (%2))IR";
+    graph(%0 : Tensor, %1 : Tensor):
+      %2 : Tensor = aten::ge(%0, %1)
+      return (%2))IR";
   pointwise_test_helper(graph, false, false, {5, 5}, {5, 5});
 }
 
 TEST(Converters, ATenGEScalarConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor):
-        %scalar : float = prim::Constant[value=3]()
-        %2 : Tensor = aten::ge(%0, %scalar)
-        return (%2))IR";
+    graph(%0 : Tensor):
+      %scalar : float = prim::Constant[value=3]()
+      %2 : Tensor = aten::ge(%0, %scalar)
+      return (%2))IR";
   pointwise_test_helper(graph, true, false, {5, 5});
 }
 
 TEST(Converters, ATenLEConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor, %1 : Tensor):
-        %2 : Tensor = aten::le(%0, %1)
-        return (%2))IR";
+    graph(%0 : Tensor, %1 : Tensor):
+      %2 : Tensor = aten::le(%0, %1)
+      return (%2))IR";
   pointwise_test_helper(graph, false, false, {5, 5}, {5, 5});
 }
 
 TEST(Converters, ATenLEScalarConvertsCorrectly) {
   const auto graph = R"IR(
-      graph(%0 : Tensor):
-        %scalar : float = prim::Constant[value=3]()
-        %2 : Tensor = aten::le(%0, %scalar)
-        return (%2))IR";
+    graph(%0 : Tensor):
+      %scalar : float = prim::Constant[value=3]()
+      %2 : Tensor = aten::le(%0, %scalar)
+      return (%2))IR";
   pointwise_test_helper(graph, true, false, {5, 5});
 }