compiler API: take CompilerOptions as an optional argument

Make all tc::compile and related functions take an instance of
CompilerOptions.  The options are defaulted to a default-constructed
instance of CompilerOptions that preserves the original behavior of the
compilaton flow.  Making the argument optional preserves the old way of
calling tc::compile since it is a user-facing function.

Author: ftynse

tc/aten/aten_compiler-inl.h

@@ -32,10 +32,11 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
     const std::string& tc,
     const std::string& entryPoint,
     const std::vector<at::Tensor>& inputs,
-    const typename Backend::MappingOptionsType& options) {
+    const typename Backend::MappingOptionsType& options,
+    const CompilerOptions& compilerOptions) {
   auto inputDLTensors = makeDLConstTensors(inputs);
   return tc::compile<Backend>(
-      tc, entryPoint, extractRawPtrs(inputDLTensors), options);
+      tc, entryPoint, extractRawPtrs(inputDLTensors), options, compilerOptions);
 }
 
 template <typename Executor>

tc/aten/aten_compiler.h

@@ -58,7 +58,8 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
     const std::string& tc,
     const std::string& entryPoint,
     const std::vector<at::Tensor>& inputs,
-    const typename Backend::MappingOptionsType& options);
+    const typename Backend::MappingOptionsType& options,
+    const CompilerOptions& compilerOptions = CompilerOptions());
 
 /// Given an executor resulting from compiling a TC, run the TC and fill the
 /// outputs vector with the results. The output vector must have as many

tc/core/compiler-inl.h

@@ -37,11 +37,13 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
     const std::string& entryPoint,
     const std::vector<const DLConstTensor*>& inputs,
     /* TODO: in the future also pass outputs for stride and alignment info */
-    const typename Backend::MappingOptionsType& options) {
+    const typename Backend::MappingOptionsType& options,
+    const CompilerOptions& compilerOptions) {
   auto parsedTcs = detail::parse(tc);
   TC_CHECK_EQ(parsedTcs.count(entryPoint), 1u)
       << "attempting to access undefined function " << entryPoint;
-  return detail::compile<Backend>(parsedTcs[entryPoint], inputs, options);
+  return detail::compile<Backend>(
+      parsedTcs[entryPoint], inputs, options, compilerOptions);
 }
 
 namespace detail {
@@ -50,13 +52,15 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
     lang::TreeRef tcDefinition,
     const std::vector<const DLConstTensor*>& inputs,
     /* TODO: in the future also pass outputs for stride and alignment info */
-    const typename Backend::MappingOptionsType& options) {
+    const typename Backend::MappingOptionsType& options,
+    const CompilerOptions& compilerOptions) {
   using CompilationResultType = typename Backend::CompilationResultType;
 
   auto inputsInfo = makeTensorInfoVector(inputs);
-  auto outputsInfo = detail::inferOutputTensorInfo(tcDefinition, inputs);
+  auto outputsInfo =
+      detail::inferOutputTensorInfo(tcDefinition, inputs, compilerOptions);
   auto halideComponents = tc2halide::translate(
-      isl::with_exceptions::globalIslCtx(), tcDefinition, CompilerOptions());
+      isl::with_exceptions::globalIslCtx(), tcDefinition, compilerOptions);
   detail::checkInputsCompliant(halideComponents, inputs);
 
   auto tcName = lang::Def(tcDefinition).name().name();

tc/core/compiler.cc

@@ -24,16 +24,19 @@
 #include "tc/core/halide_utils.h"
 #include "tc/core/tensor.h"
 #include "tc/lang/canonicalize.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc {
 std::vector<TensorInfo> inferOutputTensorInfo(
     const std::string& tc,
     const std::string& entryPoint,
-    const std::vector<const DLConstTensor*> inputs) {
+    const std::vector<const DLConstTensor*> inputs,
+    const CompilerOptions& compilerOptions) {
   auto parsedTcs = detail::parse(tc);
   TC_CHECK_EQ(parsedTcs.count(entryPoint), 1u)
       << "attempting to access undefined function " << entryPoint;
-  return tc::detail::inferOutputTensorInfo(parsedTcs[entryPoint], inputs);
+  return tc::detail::inferOutputTensorInfo(
+      parsedTcs[entryPoint], inputs, compilerOptions);
 }
 
 namespace detail {
@@ -101,12 +104,11 @@ void checkInputsCompliant(
 
 std::vector<TensorInfo> inferOutputTensorInfo(
     lang::TreeRef tcDefinition,
-    const std::vector<const DLConstTensor*> inputs) {
+    const std::vector<const DLConstTensor*> inputs,
+    const CompilerOptions& compilerOptions) {
   return tc::inferOutputTensorInfo(
       tc2halide::translate(
-          isl::with_exceptions::globalIslCtx(),
-          tcDefinition,
-          CompilerOptions()),
+          isl::with_exceptions::globalIslCtx(), tcDefinition, compilerOptions),
       inputs);
 }
 

tc/core/compiler.h

@@ -22,6 +22,7 @@
 #include "tc/core/mapping_options.h"
 #include "tc/core/tensor.h"
 #include "tc/lang/tree.h"
+#include "tc/utils/compiler_options.h"
 
 /**
  * This provides a simple functional-style C++ API with multi-backend
@@ -62,8 +63,9 @@ namespace tc {
 /// "entryPoint", this function compiles a new TcExecutor for the specified
 /// Backend. For now, contiguous output sizes are inferred given input sizes.
 /// If you need another kernel for another entryPoint or other inputs or
-//  other options then just compile another TcExecutor; because atm we fully
-/// JIT specialize on all sizes.
+/// other options then just compile another TcExecutor; because atm we fully
+/// JIT specialize on all sizes.  General compilation options (warnings, debug
+/// info) are provided in "compilerOptions".
 /// \returns a new TcExecutor on which the run method can be called to run
 /// entryPoint
 template <typename Backend>
@@ -72,7 +74,8 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
     const std::string& entryPoint,
     const std::vector<const DLConstTensor*>& inputs,
     /* TODO: in the future also pass outputs for stride and alignment info */
-    const typename Backend::MappingOptionsType& options);
+    const typename Backend::MappingOptionsType& options,
+    const CompilerOptions& compilerOptions = CompilerOptions());
 
 /// Given a TC representation as a TC + TC function name entryPoint and a list
 /// of input tensors that match the definition in the TC function definition
@@ -85,7 +88,8 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
 std::vector<TensorInfo> inferOutputTensorInfo(
     const std::string& tc,
     const std::string& entryPoint,
-    const std::vector<const DLConstTensor*> inputs);
+    const std::vector<const DLConstTensor*> inputs,
+    const CompilerOptions& compilerOptions = CompilerOptions());
 
 namespace detail {
 /// Given a TC representation, this parses the TC functions into a map of
@@ -105,7 +109,8 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
     lang::TreeRef tcDefinition,
     const std::vector<const DLConstTensor*>& inputs,
     /* TODO: in the future also pass outputs for stride and alignment info */
-    const typename Backend::MappingOptionsType& options);
+    const typename Backend::MappingOptionsType& options,
+    const CompilerOptions& compilerOptions = CompilerOptions());
 
 /// Given a TC representation as a TreeRef and a list of input tensors that
 /// match the definition in the TC function definition (in positional order),
@@ -116,7 +121,8 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
 /// performing output shape validation.
 std::vector<TensorInfo> inferOutputTensorInfo(
     lang::TreeRef tcDefinition,
-    const std::vector<const DLConstTensor*> inputs);
+    const std::vector<const DLConstTensor*> inputs,
+    const CompilerOptions& compilerOptions = CompilerOptions());
 
 } // namespace detail
 } // namespace tc