refactor: Apply linting

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

Author: narendasan

core/compiler.cpp

@@ -288,18 +288,24 @@ GraphAndMapping ConstructFallbackGraph(
   return {new_g, old_to_new_g};
 }
 
-
-void MapInputsAndDetermineDTypes(CompileSpec& cfg, std::shared_ptr<torch::jit::Graph>& g, ir::StaticParams& static_params, ir::TypeMap& first_use_type_map) {
+void MapInputsAndDetermineDTypes(
+    CompileSpec& cfg,
+    std::shared_ptr<torch::jit::Graph>& g,
+    ir::StaticParams& static_params,
+    ir::TypeMap& first_use_type_map) {
   // Associate input specs with inputs
   cfg.convert_info.inputs = std::move(ir::associate_specs_with_inputs(g, cfg.inputs, static_params));
 
   for (auto& in : g->inputs()) {
     auto est_type_opt = first_use_type_map.find(in)->second;
     ir::Input& spec = cfg.convert_info.inputs.find(in)->second;
     if (est_type_opt && !spec.dtype_is_user_defined) {
-      // If we can calculate the type from the graph and the type was not defined by the user then use the calculated type
-      LOG_INFO("Since input type is not explicitly defined, infering using first tensor calculation\n  Found input "
-        << in->debugName() << " has type " << est_type_opt.value() << ". If this is incorrect explicitly set dtype for input and file a bug");
+      // If we can calculate the type from the graph and the type was not defined by the user then use the calculated
+      // type
+      LOG_INFO(
+          "Since input type is not explicitly defined, infering using first tensor calculation\n  Found input "
+          << in->debugName() << " has type " << est_type_opt.value()
+          << ". If this is incorrect explicitly set dtype for input and file a bug");
       spec.dtype = util::ScalarTypeToTRTDataType(est_type_opt.value());
     } else if (!est_type_opt && !spec.dtype_is_user_defined) {
       // If we cannot calculate the type and the user did not define the type, then default to FP32
@@ -313,7 +319,7 @@ void MapInputsAndDetermineDTypes(CompileSpec& cfg, std::shared_ptr<torch::jit::G
       } else {
         if (util::TRTDataTypeToScalarType(cfg.convert_info.inputs.find(in)->second.dtype) != est_type_opt.value()) {
           std::stringstream ss;
-          ss <<"For input " << in->debugName() << ", found user specified input dtype as ";
+          ss << "For input " << in->debugName() << ", found user specified input dtype as ";
           ss << cfg.convert_info.inputs.find(in)->second.dtype;
           ss << ", however when inspecting the graph, the input type expected was inferred to be ";
           ss << est_type_opt.value() << std::endl;
@@ -340,7 +346,9 @@ std::string ConvertGraphToTRTEngine(const torch::jit::script::Module& mod, std::
   auto graph_and_parameters = lowering::Lower(mod, method_name, cfg.lower_info);
 
   auto g = graph_and_parameters.first;
-  TRTORCH_CHECK(conversion::VerifyConverterSupportForBlock(g->block()), "Not all operations in graph are supported by the compiler");
+  TRTORCH_CHECK(
+      conversion::VerifyConverterSupportForBlock(g->block()),
+      "Not all operations in graph are supported by the compiler");
   auto params = graph_and_parameters.second;
   auto static_params = ir::get_static_params(g->inputs(), params);
   // Infer the type of an input from the weights of the calculation
@@ -385,17 +393,17 @@ torch::jit::Module CompileGraph(const torch::jit::Module& mod, CompileSpec cfg)
 
       MapInputsAndDetermineDTypes(cfg, g, static_params, first_use_types);
 
-      if (cfg.partition_info.enabled
-            && (cfg.lower_info.forced_fallback_modules.size() == 0
-                  && cfg.partition_info.forced_fallback_operators.size() == 0
-                  && conversion::VerifyConverterSupportForBlock(g->block(), true))) {
+      if (cfg.partition_info.enabled &&
+          (cfg.lower_info.forced_fallback_modules.size() == 0 &&
+           cfg.partition_info.forced_fallback_operators.size() == 0 &&
+           conversion::VerifyConverterSupportForBlock(g->block(), true))) {
         LOG_INFO("Skipping partitioning since model is fully supported");
       }
 
-      if (cfg.partition_info.enabled
-            && !(cfg.lower_info.forced_fallback_modules.size() == 0
-                  && cfg.partition_info.forced_fallback_operators.size() == 0
-                  && conversion::VerifyConverterSupportForBlock(g->block(), false))) {
+      if (cfg.partition_info.enabled &&
+          !(cfg.lower_info.forced_fallback_modules.size() == 0 &&
+            cfg.partition_info.forced_fallback_operators.size() == 0 &&
+            conversion::VerifyConverterSupportForBlock(g->block(), false))) {
         auto input_ivalues_map = partitioning::generateRandomInputs(cfg.convert_info.inputs, first_use_types);
         auto graph_and_mapping = ConstructFallbackGraph(new_mod, g->block(), input_ivalues_map, cfg, static_params);
         new_g = graph_and_mapping.first;
@@ -408,7 +416,9 @@ torch::jit::Module CompileGraph(const torch::jit::Module& mod, CompileSpec cfg)
           return mod;
         }
       } else {
-        TRTORCH_CHECK(conversion::VerifyConverterSupportForBlock(g->block()), "Not all operations in graph are supported by the compiler");
+        TRTORCH_CHECK(
+            conversion::VerifyConverterSupportForBlock(g->block()),
+            "Not all operations in graph are supported by the compiler");
         auto engine = conversion::ConvertBlockToEngine(g->block(), cfg.convert_info, static_params);
         auto device_spec = cfg.convert_info.engine_settings.device;
         auto cuda_device = runtime::CudaDevice(device_spec.gpu_id, device_spec.device_type);

core/conversion/conversion.cpp

@@ -518,7 +518,7 @@ bool VerifyConverterSupportForBlock(const torch::jit::Block* b, bool suppress_er
             if (suppress_errors) {
               LOG_ERROR(
                   "Unsupported operator: " << *schema << std::endl
-                                          << trtorch::core::util::GetPyTorchSourceCode(n) << std::endl);
+                                           << trtorch::core::util::GetPyTorchSourceCode(n) << std::endl);
             }
           }
         }

core/conversion/conversion.h

@@ -25,7 +25,7 @@ std::string ConvertBlockToEngine(
 
 bool OpSupported(const torch::jit::Node* n);
 
-bool VerifyConverterSupportForBlock(const torch::jit::Block* b, bool suppress_errors=false);
+bool VerifyConverterSupportForBlock(const torch::jit::Block* b, bool suppress_errors = false);
 
 c10::optional<torch::jit::IValue> EvaluateNode(
     ConversionCtx* ctx,

core/util/jit_util.h

@@ -9,7 +9,6 @@ namespace trtorch {
 namespace core {
 namespace util {
 
-
 inline std::string node_info(const torch::jit::Node* n) {
   std::stringstream ss;
   ss << *n;

cpp/include/trtorch/trtorch.h

@@ -387,7 +387,8 @@ struct TRTORCH_API CompileSpec {
      * / traditional TRT convection (FP32 for FP32 only, FP16 for FP32 and FP16, FP32 for Int8)
      *
      * @param shape Input tensor shape
-     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor calculation if detectable else Float32)
+     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor
+     * calculation if detectable else Float32)
      * @param format Expected tensor format for the input (Defaults to contiguous)
      */
     Input(std::vector<int64_t> shape, TensorFormat format = TensorFormat::kContiguous);
@@ -398,7 +399,8 @@ struct TRTORCH_API CompileSpec {
      * tensor format
      *
      * @param shape Input tensor shape
-     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor calculation if detectable else Float32)
+     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor
+     * calculation if detectable else Float32)
      * @param format Expected tensor format for the input (Defaults to contiguous)
      */
     Input(std::vector<int64_t> shape, DataType dtype, TensorFormat format = TensorFormat::kContiguous);
@@ -421,7 +423,8 @@ struct TRTORCH_API CompileSpec {
      * allow the user to configure expected input shape tensor format
      *
      * @param shape Input tensor shape
-     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor calculation if detectable else Float32)
+     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor
+     * calculation if detectable else Float32)
      * @param format Expected tensor format for the input (Defaults to contiguous)
      */
     Input(c10::ArrayRef<int64_t> shape, DataType dtype, TensorFormat format = TensorFormat::kContiguous);
@@ -451,7 +454,8 @@ struct TRTORCH_API CompileSpec {
      * @param min_shape Minimum shape for input tensor
      * @param opt_shape Target optimization shape for input tensor
      * @param max_shape Maximum acceptible shape for input tensor
-     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor calculation if detectable else Float32)
+     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor
+     * calculation if detectable else Float32)
      * @param format Expected tensor format for the input (Defaults to contiguous)
      */
     Input(
@@ -486,7 +490,8 @@ struct TRTORCH_API CompileSpec {
      * @param min_shape Minimum shape for input tensor
      * @param opt_shape Target optimization shape for input tensor
      * @param max_shape Maximum acceptible shape for input tensor
-     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor calculation if detectable else Float32)
+     * @param dtype Expected data type for the input (Defaults to the type of the weights in the first tensor
+     * calculation if detectable else Float32)
      * @param format Expected tensor format for the input (Defaults to contiguous)
      */
     Input(
@@ -646,13 +651,14 @@ struct TRTORCH_API CompileSpec {
   uint64_t min_block_size = 3;
 
   /**
-   * List of aten operators that must be run in PyTorch. An error will be thrown if this list is not empty but ``require_full_compilation`` is True
+   * List of aten operators that must be run in PyTorch. An error will be thrown if this list is not empty but
+   * ``require_full_compilation`` is True
    */
   std::vector<std::string> torch_executed_ops;
 
-
   /**
-   * List of modules that must be run in PyTorch. An error will be thrown if this list is not empty but ``require_full_compilation`` is True
+   * List of modules that must be run in PyTorch. An error will be thrown if this list is not empty but
+   * ``require_full_compilation`` is True
    */
   std::vector<std::string> torch_executed_modules;
 };

cpp/src/compile_spec.cpp

@@ -322,13 +322,15 @@ core::CompileSpec to_internal_compile_spec(CompileSpec external) {
   internal.convert_info.engine_settings.device.allow_gpu_fallback = external.device.allow_gpu_fallback;
   internal.convert_info.engine_settings.max_batch_size = external.max_batch_size;
 
-  TRTORCH_CHECK(!(external.require_full_compilation && (external.torch_executed_ops.size() > 0)),
-                 "require_full_compilation is enabled however the list of ops to run in torch is not empty (Found "
-                  << external.torch_executed_ops.size() << " ops)");
+  TRTORCH_CHECK(
+      !(external.require_full_compilation && (external.torch_executed_ops.size() > 0)),
+      "require_full_compilation is enabled however the list of ops to run in torch is not empty (Found "
+          << external.torch_executed_ops.size() << " ops)");
 
-  TRTORCH_CHECK(!(external.require_full_compilation && (external.torch_executed_modules.size() > 0)),
-                 "require_full_compilation is enabled however the list of modules to run in torch is not empty (Found "
-                  << external.torch_executed_modules.size() << " modules)");
+  TRTORCH_CHECK(
+      !(external.require_full_compilation && (external.torch_executed_modules.size() > 0)),
+      "require_full_compilation is enabled however the list of modules to run in torch is not empty (Found "
+          << external.torch_executed_modules.size() << " modules)");
 
   internal.partition_info.enabled = external.require_full_compilation;
   internal.partition_info.min_block_size = external.min_block_size;

py/trtorch/Input.py

@@ -135,30 +135,30 @@ def _to_internal(self) -> trtorch._C.Input:
         if self.shape_mode == Input._ShapeMode.DYNAMIC:
             if not Input._supported_input_size_type(self.shape["min_shape"]):
                 raise TypeError(
-                        "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
-                        + str(type(self.shape["min_shape"])) + " for min_shape")
+                    "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+                    + str(type(self.shape["min_shape"])) + " for min_shape")
             else:
                 internal_in.min = self.shape["min_shape"]
 
             if not Input._supported_input_size_type(self.shape["opt_shape"]):
                 raise TypeError(
-                        "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
-                        + str(type(self.shape["opt_shape"])) + " for opt_shape")
+                    "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+                    + str(type(self.shape["opt_shape"])) + " for opt_shape")
             else:
                 internal_in.min = self.shape["op_shape"]
 
             if not Input._supported_input_size_type(self.shape["max_shape"]):
                 raise TypeError(
-                        "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
-                        + str(type(self.shape["max_shape"])) + " for max_shape")
+                    "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+                    + str(type(self.shape["max_shape"])) + " for max_shape")
             else:
                 internal_in.min = self.shape["opt_shape"]
             internal_in.input_is_dynamic = True
         else:
             if not Input._supported_input_size_type(self.shape):
                 raise TypeError(
-                        "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
-                        + str(type(self.shape)) + " for shape")
+                    "Input shape specifications for inputs are required to be a List, tuple or torch.Size, found type: "
+                    + str(type(self.shape)) + " for shape")
             else:
                 internal_in.opt = self.shape
             internal_in.input_is_dynamic = False

py/trtorch/_compile_spec.py

@@ -306,17 +306,18 @@ def TensorRTCompileSpec(inputs=[],
     compile_spec = {
         "inputs": inputs,
         "device": device,
-        "disable_tf32": disable_tf32, # Force FP32 layers to use traditional as FP32 format vs the default behavior of rounding the inputs to 10-bit mantissas before multiplying, but accumulates the sum using 23-bit mantissas
-        "sparse_weights": sparse_weights, #Enable sparsity for convolution and fully connected layers.
-        "enabled_precisions": enabled_precisions, # Enabling FP16 kernels
-        "refit": refit, # enable refit
-        "debug": debug, # enable debuggable engine
-        "strict_types": strict_types, # kernels should strictly run in operating precision
-        "capability": capability, # Restrict kernel selection to safe gpu kernels or safe dla kernels
-        "num_min_timing_iters": num_min_timing_iters, # Number of minimization timing iterations used to select kernels
-        "num_avg_timing_iters": num_avg_timing_iters, # Number of averaging timing iterations used to select kernels
-        "workspace_size": workspace_size, # Maximum size of workspace given to TensorRT
-        "max_batch_size": max_batch_size, # Maximum batch size (must be >= 1 to be set, 0 means not set)
+        "disable_tf32":
+            disable_tf32,  # Force FP32 layers to use traditional as FP32 format vs the default behavior of rounding the inputs to 10-bit mantissas before multiplying, but accumulates the sum using 23-bit mantissas
+        "sparse_weights": sparse_weights,  #Enable sparsity for convolution and fully connected layers.
+        "enabled_precisions": enabled_precisions,  # Enabling FP16 kernels
+        "refit": refit,  # enable refit
+        "debug": debug,  # enable debuggable engine
+        "strict_types": strict_types,  # kernels should strictly run in operating precision
+        "capability": capability,  # Restrict kernel selection to safe gpu kernels or safe dla kernels
+        "num_min_timing_iters": num_min_timing_iters,  # Number of minimization timing iterations used to select kernels
+        "num_avg_timing_iters": num_avg_timing_iters,  # Number of averaging timing iterations used to select kernels
+        "workspace_size": workspace_size,  # Maximum size of workspace given to TensorRT
+        "max_batch_size": max_batch_size,  # Maximum batch size (must be >= 1 to be set, 0 means not set)
         "calibrator": calibrator,
         "truncate_long_and_double": truncate_long_and_double
     }