tests: Linting and clean up

Signed-off-by: Naren Dasan <[email protected]>
Signed-off-by: Naren Dasan <[email protected]>

Author: narendasan

core/conversion/conversion.cpp

@@ -18,11 +18,7 @@ bool OpSupported(const torch::jit::Node* n) {
   return evaluators::shouldEvalAtConversionTime(n) || converters::node_is_convertable(n);
 }
 
-c10::optional<torch::jit::IValue> EvaluateNode(
-    ConversionCtx* ctx,
-    const torch::jit::Node* n,
-    int level,
-    int limit) {
+c10::optional<torch::jit::IValue> EvaluateNode(ConversionCtx* ctx, const torch::jit::Node* n, int level, int limit) {
   // Check to see if you can just go through and eval all of these AOT (saves
   // the recursion) Also probably a better way to deal with the two error cases;
   TRTORCH_CHECK(

core/conversion/conversion.h

@@ -42,7 +42,11 @@ bool OpSupported(const torch::jit::Node* n);
 
 bool VerifyConverterSupportForBlock(const torch::jit::Block* b);
 
-c10::optional<torch::jit::IValue> EvaluateNode(ConversionCtx* ctx, const torch::jit::Node* n, int level = 0, int limit = 10);
+c10::optional<torch::jit::IValue> EvaluateNode(
+    ConversionCtx* ctx,
+    const torch::jit::Node* n,
+    int level = 0,
+    int limit = 10);
 
 } // namespace conversion
 } // namespace core

tests/core/lowering/test_remove_contiguous_pass.cpp

@@ -1,8 +1,8 @@
 #include <string>
-#include "gtest/gtest.h"
-#include "tests/util/util.h"
 #include "core/compiler.h"
 #include "core/lowering/passes/passes.h"
+#include "gtest/gtest.h"
+#include "tests/util/util.h"
 #include "torch/csrc/jit/ir/irparser.h"
 #include "torch/csrc/jit/ir/subgraph_matcher.h"
 

tests/util/evaluate_graph.cpp

@@ -7,23 +7,24 @@
 #include "core/conversion/var/Var.h"
 #include "core/util/prelude.h"
 
-
 namespace trtorch {
 namespace tests {
 namespace util {
 
 std::vector<torch::jit::IValue> EvaluateGraph(const torch::jit::Block* b, std::vector<torch::jit::IValue> inputs) {
+  LOG_DEBUG("Running TRTorch Version");
+
   core::conversion::ConversionCtx* ctx = new core::conversion::ConversionCtx({});
-    std::cout << "IJKWIOJWQIJOWQ" << std::endl;
 
   TRTORCH_CHECK(inputs.size() == b->inputs().size(), "Amount of provided inputs do not match number of graph inputs");
   for (size_t i = 0; i < inputs.size(); i++) {
     ctx->AssociateValueAndIValue(b->inputs()[i], inputs[i]);
   }
-  std::cout << "IJKWIOJWQIJOWQ" << std::endl;
+
   for (const auto n : b->nodes()) {
-    std::cout << *n << std::endl;
-    TRTORCH_CHECK(core::conversion::evaluators::shouldEvalAtConversionTime(n), "Test graph contains non evaluatable nodes: " << *n);
+    TRTORCH_CHECK(
+        core::conversion::evaluators::shouldEvalAtConversionTime(n),
+        "Test graph contains non evaluatable nodes: " << *n);
     auto eval = core::conversion::EvaluateNode(ctx, n);
     if (eval) {
       if (!eval.value().isTensor()) {
@@ -36,7 +37,7 @@ std::vector<torch::jit::IValue> EvaluateGraph(const torch::jit::Block* b, std::v
   }
 
   std::vector<torch::jit::IValue> outputs;
-  for(auto o : b->outputs()) {
+  for (auto o : b->outputs()) {
     auto it = ctx->evaluated_value_map.find(o);
     TRTORCH_CHECK(
         it != ctx->evaluated_value_map.end(),
@@ -48,12 +49,14 @@ std::vector<torch::jit::IValue> EvaluateGraph(const torch::jit::Block* b, std::v
   return outputs;
 }
 
-std::vector<torch::jit::IValue> EvaluateGraphJIT(std::shared_ptr<torch::jit::Graph>& g, std::vector<torch::jit::IValue> inputs) {
+std::vector<torch::jit::IValue> EvaluateGraphJIT(
+    std::shared_ptr<torch::jit::Graph>& g,
+    std::vector<torch::jit::IValue> inputs) {
   LOG_DEBUG("Running JIT version");
 
   torch::jit::GraphExecutor executor(g, "");
   auto stack = torch::jit::Stack();
-  for (auto& i  : inputs) {
+  for (auto& i : inputs) {
     torch::jit::push(stack, i);
   }
 

tests/util/util.h

@@ -47,7 +47,9 @@ std::vector<at::Tensor> RunModuleForwardAsEngine(torch::jit::Module& mod, std::v
 std::vector<torch::jit::IValue> EvaluateGraph(const torch::jit::Block* b, std::vector<torch::jit::IValue> inputs);
 
 // Runs evaluatable graphs through the JIT interpreter and returns results
-std::vector<torch::jit::IValue> EvaluateGraphJIT(std::shared_ptr<torch::jit::Graph>& g, std::vector<torch::jit::IValue> inputs);
+std::vector<torch::jit::IValue> EvaluateGraphJIT(
+    std::shared_ptr<torch::jit::Graph>& g,
+    std::vector<torch::jit::IValue> inputs);
 } // namespace util
 } // namespace tests
 } // namespace trtorch