[C++ API] Step 9: Introduce CPU and CUDA backend files

The CpuBackend and the CudaBackend types contain the dependent
types and functions one needs to implement to support a new
backend.
These types will be used in the next commit to create both the
end-to-end CUDA tuner + compiler as well as a mock CPU autotuner +
compiler example.

Author: nicolasvasilache

tc/core/cpu/cpu_backend.h

@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <glog/logging.h>
+
+#include "tc/core/cpu/cpu_mapping_options.h"
+#include "tc/core/cpu/cpu_mapping_options_cpp_printer.h"
+#include "tc/core/cpu/cpu_rtc.h"
+#include "tc/core/halide_utils.h"
+#include "tc/core/tensor.h"
+
+namespace tc {
+/**
+ * RAII placement support, modeled on CUDA getDevice / setDevice support in
+ * WithCudaDevice.
+ * TODO: Impl me (NUMA domain/pinned to core/nothing?)
+ */
+struct WithCpuDevice {
+  WithCpuDevice(size_t g) {}
+};
+
+/**
+ * Information returned by polyhedral compilation
+ */
+struct CpuCompilationResult {
+  std::string source;
+  std::string specializedName;
+  std::vector<long> parameters;
+};
+
+/**
+ * Information that can be set at runtime to control placement and
+ * synchronization information of a kernel.
+ */
+struct CpuRuntimeInformation {};
+
+struct CpuTcExecutor;
+
+/**
+ * This type declares the dependent types and static functions needed to
+ * autotune, compile and run for the CPU backend.
+ */
+struct CpuBackend {
+  using ExecutorType = CpuTcExecutor;
+  using MappingOptionsType = CpuMappingOptions;
+  using CompilationResultType = CpuCompilationResult;
+  using OptionsCacheProtoType = CpuOptionsCacheProto;
+  using OptionsCacheValueProtoType = CpuOptionsCacheValueProto;
+  using RTCFunctionType = CpuRTCFunction;
+
+  using WithDevice = WithCpuDevice;
+  using RuntimeInformation = CpuRuntimeInformation;
+  using MappingOptionsAsCpp = CpuMappingOptionsAsCpp;
+  using MappingOptionsCppPrinter = CpuMappingOptionsCppPrinter;
+
+  static inline std::string backendString() {
+    LOG(ERROR) << "NYI: CpuBackend::backendString";
+    return "SOME_CPU";
+  }
+  static inline std::string makeDeviceFilename(const std::string& fn) {
+    return fn + ".cpu";
+  }
+
+  /// Main entry point for polyhedral compilation
+  static CompilationResultType compileWithTcMapper(
+      const std::string& tcName,
+      tc2halide::HalideComponents halideComponents,
+      const std::vector<const DLConstTensor*>& inputs,
+      /* TODO: in the future also pass outputs for stride and alignment */
+      const MappingOptionsType& options);
+};
+} // namespace tc

tc/core/cpu/cpu_rtc.h

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+namespace tc {
+/**
+ * This is the class that holds a binary object resulting from compilation.
+ * It must provide a clear function and be callable.
+ * TODO: Impl me
+ */
+struct CpuRTCFunction {
+  void clear() {}
+  template <typename... Args>
+  void operator()(Args&... args) {}
+};
+} // namespace tc

tc/core/cuda/cuda_backend.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "tc/core/cuda/cuda.h"
+#include "tc/core/cuda/cuda_mapping_options.h"
+#include "tc/core/cuda/cuda_mapping_options_cpp_printer.h"
+#include "tc/core/cuda/cuda_rtc.h"
+#include "tc/core/halide_utils.h"
+#include "tc/core/tensor.h"
+
+namespace tc {
+/**
+ * Information returned by polyhedral compilation. In particular, since we use
+ * tightening of loop bounds for CUDA kernels, it includes the actual grid and
+ * block sizes needed at runtime.
+ */
+struct CudaCompilationResult {
+  std::string source;
+  std::string specializedName;
+  std::vector<long> parameters;
+  Grid grid;
+  Block block;
+};
+
+/**
+ * Information that can be set at runtime to control placement and
+ * synchronization information of a kernel.
+ */
+struct CudaRuntimeInformation {
+  cudaStream_t stream{0};
+};
+
+struct CudaTcExecutor;
+
+/**
+ * This type declares the dependent types and static functions needed to
+ * autotune, compile and run for the CPU backend.
+ */
+struct CudaBackend {
+  using ExecutorType = CudaTcExecutor;
+  using MappingOptionsType = CudaMappingOptions;
+  using CompilationResultType = CudaCompilationResult;
+  using OptionsCacheProtoType = CudaOptionsCacheProto;
+  using OptionsCacheValueProtoType = CudaOptionsCacheValueProto;
+  using RTCFunctionType = CudaRTCFunction;
+
+  using WithDevice = WithCudaDevice;
+  using RuntimeInformation = CudaRuntimeInformation;
+  using MappingOptionsAsCpp = CudaMappingOptionsAsCpp;
+  using MappingOptionsCppPrinter = CudaMappingOptionsCppPrinter;
+
+  static inline std::string backendString() {
+    return CudaGPUInfo::GPUInfo().getCudaDeviceStr();
+  }
+  static inline std::string makeDeviceFilename(const std::string& fn) {
+    return fn + ".cuda";
+  }
+
+  /// Main entry point for polyhedral compilation
+  static CompilationResultType compileWithTcMapper(
+      const std::string& tcName,
+      tc2halide::HalideComponents halideComponents,
+      const std::vector<const DLConstTensor*>& inputs,
+      /* TODO: in the future also pass outputs for stride and alignment */
+      const MappingOptionsType& options);
+};
+} // namespace tc