Merge pull request #579 from facebookresearch/compiler-options

Compiler options

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

@@ -22,6 +22,7 @@
 #include "tc/aten/aten.h"
 #include "tc/core/tensor.h"
 #include "tc/core/utils/time.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc {
 namespace aten {
@@ -57,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/autotuner/autotuner-inl.h

@@ -29,6 +29,7 @@
 #include "tc/core/tensor.h"
 #include "tc/core/utils/math.h"
 #include "tc/lang/canonicalize.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc {
 namespace autotune {
@@ -74,6 +75,9 @@ void TuningHarness<Backend>::stopAfterCurrentIteration() {
 template <typename Backend>
 template <typename SearchStrategy>
 void TuningHarness<Backend>::doCompile(SearchStrategy& searchStrategy) {
+  CompilerOptions supressWarningsOptions;
+  supressWarningsOptions.emitWarnings = false;
+
   // Atomically fetch and add the next job until there are no jobs left
   while (true) {
     auto current = currentCompilationJob_.fetch_add(1);
@@ -92,8 +96,8 @@ void TuningHarness<Backend>::doCompile(SearchStrategy& searchStrategy) {
           LOG(INFO) << "[COMPILE] Start compilation @:" << current;
           LOG_LINE_BY_LINE(INFO, ssInfo);
         }
-        pExecutor =
-            tc::compile<Backend>(tcTree_, inputs_.begin()->second, options);
+        pExecutor = tc::detail::compile<Backend>(
+            tcTree_, inputs_.begin()->second, options, supressWarningsOptions);
         LOG_IF(INFO, FLAGS_debug_tuner) << "[COMPILE] Done compilation";
       } catch (const std::exception& e) {
         LOG(WARNING) << "[TUNER][COMPILE] failed compilation: " << e.what();

tc/core/compiler-inl.h

@@ -37,25 +37,30 @@ 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 compile<Backend>(parsedTcs[entryPoint], inputs, options);
+  return detail::compile<Backend>(
+      parsedTcs[entryPoint], inputs, options, compilerOptions);
 }
 
+namespace detail {
 template <typename Backend>
 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 halideComponents =
-      tc2halide::translate(isl::with_exceptions::globalIslCtx(), tcDefinition);
+  auto outputsInfo =
+      detail::inferOutputTensorInfo(tcDefinition, inputs, compilerOptions);
+  auto halideComponents = tc2halide::translate(
+      isl::with_exceptions::globalIslCtx(), tcDefinition, compilerOptions);
   detail::checkInputsCompliant(halideComponents, inputs);
 
   auto tcName = lang::Def(tcDefinition).name().name();
@@ -69,4 +74,5 @@ std::unique_ptr<typename Backend::ExecutorType> compile(
       new typename Backend::ExecutorType(
           inputsInfo, outputsInfo, halideComponents, compilationResult));
 }
+} // namespace detail
 } // namespace tc

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,9 +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),
+      tc2halide::translate(
+          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

tc/core/polyhedral/scop.cc

@@ -34,6 +34,7 @@
 #include "tc/core/polyhedral/schedule_utils.h"
 #include "tc/core/scope_guard.h"
 #include "tc/core/tc2halide.h"
+#include "tc/utils/compiler_options.h"
 
 using namespace std;
 
@@ -69,12 +70,18 @@ ScopUPtr Scop::makeScop(
   return scop;
 }
 
-ScopUPtr Scop::makeScop(isl::ctx ctx, const string& tc) {
-  return makeScop(ctx, tc2halide::translate(ctx, tc));
+ScopUPtr Scop::makeScop(
+    isl::ctx ctx,
+    const string& tc,
+    const CompilerOptions& compilerOptions) {
+  return makeScop(ctx, tc2halide::translate(ctx, tc, compilerOptions));
 }
 
-ScopUPtr Scop::makeScop(isl::ctx ctx, const lang::TreeRef& treeRef) {
-  return makeScop(ctx, tc2halide::translate(ctx, treeRef));
+ScopUPtr Scop::makeScop(
+    isl::ctx ctx,
+    const lang::TreeRef& treeRef,
+    const CompilerOptions& compilerOptions) {
+  return makeScop(ctx, tc2halide::translate(ctx, treeRef, compilerOptions));
 }
 
 isl::union_set& Scop::domainRef() {

tc/core/polyhedral/scop.h

@@ -32,6 +32,7 @@
 #include "tc/core/tc2halide.h"
 #include "tc/core/tensor.h"
 #include "tc/external/isl.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc {
 namespace polyhedral {
@@ -56,11 +57,15 @@ struct Scop {
   // Halide IR is constructed and made a member by setting halideComponents.
   // These operations are grouped and scheduled in a halide::Stmt which becomes
   // the unit from which the scop is constructed.
-  static std::unique_ptr<Scop> makeScop(isl::ctx ctx, const std::string& tc);
+  static std::unique_ptr<Scop> makeScop(
+      isl::ctx ctx,
+      const std::string& tc,
+      const CompilerOptions& compilerOptions = CompilerOptions());
 
   static std::unique_ptr<Scop> makeScop(
       isl::ctx ctx,
-      const lang::TreeRef& treeRef);
+      const lang::TreeRef& treeRef,
+      const CompilerOptions& compilerOptions = CompilerOptions());
 
   // Clone a Scop
   static std::unique_ptr<Scop> makeScop(const Scop& scop) {

tc/core/tc2halide.cc

@@ -20,6 +20,7 @@
 #include "tc/core/tc2halide.h"
 #include "tc/lang/parser.h"
 #include "tc/lang/sema.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc2halide {
 
@@ -270,7 +271,7 @@ void forwardBoundsInference(
     const std::vector<Expr>& exprs,
     const FunctionBounds& bounds,
     const lang::TreeRef& comprehension,
-    bool throwWarnings,
+    const tc::CompilerOptions& compilerOptions,
     Scope<Interval>* solution) {
   class CreateConstraints : public IRVisitor {
     using IRVisitor::visit;
@@ -488,10 +489,10 @@ void forwardBoundsInference(
     lang::ErrorReport err(comprehension);
     err << "Required precondition will not be checked at runtime: "
         << remaining;
-    if (throwWarnings) {
+    if (compilerOptions.throwWarnings) {
       throw err;
     } else {
-      warn(err);
+      warn(err, compilerOptions);
     }
   }
 }
@@ -509,7 +510,7 @@ Expr reductionUpdate(Expr e) {
 void translateComprehension(
     const lang::Comprehension& comprehension,
     const map<string, Parameter>& params,
-    bool throwWarnings,
+    const tc::CompilerOptions& compilerOptions,
     map<string, Function>* funcs,
     FunctionBounds* bounds) {
   Function f;
@@ -670,7 +671,7 @@ void translateComprehension(
   // Infer the rest
   all_exprs.push_back(rhs);
   forwardBoundsInference(
-      all_exprs, *bounds, comprehension, throwWarnings, &solution);
+      all_exprs, *bounds, comprehension, compilerOptions, &solution);
 
   // TODO: What if subsequent updates have incompatible bounds
   // (e.g. an in-place stencil)?. The .bound directive will use the
@@ -754,7 +755,9 @@ void translateComprehension(
 }
 
 // Translate a semantically checked TC def to HalideComponents struct.
-HalideComponents translateDef(const lang::Def& def, bool throwWarnings) {
+HalideComponents translateDef(
+    const lang::Def& def,
+    const tc::CompilerOptions& compilerOptions) {
   map<string, Function> funcs;
   HalideComponents components;
   components.def = def;
@@ -765,7 +768,7 @@ HalideComponents translateDef(const lang::Def& def, bool throwWarnings) {
   }
   for (auto c : def.statements()) {
     translateComprehension(
-        c, components.params, throwWarnings, &funcs, &bounds);
+        c, components.params, compilerOptions, &funcs, &bounds);
   }
   vector<Function> outputs;
   for (auto p : def.returns()) {
@@ -906,19 +909,24 @@ HalideComponents translateDef(const lang::Def& def, bool throwWarnings) {
 }
 } // namespace
 
-HalideComponents
-translate(isl::ctx ctx, const lang::TreeRef& treeRef, bool throwWarnings) {
+HalideComponents translate(
+    isl::ctx ctx,
+    const lang::TreeRef& treeRef,
+    const tc::CompilerOptions& compilerOptions = tc::CompilerOptions()) {
   LOG_IF(INFO, tc::FLAGS_debug_halide) << treeRef;
   return translateDef(
-      lang::Def(lang::Sema().checkFunction(treeRef)), throwWarnings);
+      lang::Def(lang::Sema(compilerOptions).checkFunction(treeRef)),
+      compilerOptions);
 }
 
 // NOTE: there is no guarantee here that the tc string has only one def. It
 // could have many defs. Only first def will be converted in that case.
-HalideComponents
-translate(isl::ctx ctx, const std::string& tc, bool throwWarnings) {
+HalideComponents translate(
+    isl::ctx ctx,
+    const std::string& tc,
+    const tc::CompilerOptions& compilerOptions = tc::CompilerOptions()) {
   LOG_IF(INFO, tc::FLAGS_debug_halide) << tc;
-  return translate(ctx, lang::Parser(tc).parseFunction(), throwWarnings);
+  return translate(ctx, lang::Parser(tc).parseFunction(), compilerOptions);
 }
 
 } // namespace tc2halide

tc/core/tc2halide.h

@@ -20,6 +20,7 @@
 #include "tc/external/isl.h"
 #include "tc/lang/tree.h"
 #include "tc/lang/tree_views.h"
+#include "tc/utils/compiler_options.h"
 
 namespace tc2halide {
 
@@ -44,15 +45,19 @@ struct HalideComponents {
 Halide::Internal::Call::ConstString kReductionUpdate = "ReductionUpdate";
 
 // Translate a TC parse tree into equivalent Halide imperative IR with
-// a naive schedule.
+// a naive schedule.  Additional options, such as how to treat warnings, are
+// passed in as "compilerOptions".
 HalideComponents translate(
     isl::ctx ctx,
     const lang::TreeRef& treeRef,
-    bool throwWarnings = false);
+    const tc::CompilerOptions& compilerOptions);
 
 // Translate TC source into equivalent Halide imperative IR with a
-// naive schedule.
-HalideComponents
-translate(isl::ctx ctx, const std::string& tc, bool throwWarnings = false);
+// naive schedule.  Additional options, such as how to treat warnings, are
+// passed in as "compilerOptions".
+HalideComponents translate(
+    isl::ctx ctx,
+    const std::string& tc,
+    const tc::CompilerOptions& compilerOptions);
 
 } // namespace tc2halide