Add initial support for Intel FPGA SDK for OpenCL (AOCL)

cmake/config.cmake

@@ -42,6 +42,13 @@ set(USE_ROCM OFF)
 # Whether enable SDAccel runtime
 set(USE_SDACCEL OFF)
 
+# Whether enable Intel FPGA SDK for OpenCL (AOCL) during compile,
+#
+# Possible values:
+# - OFF: disbale AOCL
+# - board_name: use specific board name for offline compilation
+set(USE_AOCL OFF)
+
 # Whether enable OpenCL runtime
 set(USE_OPENCL OFF)
 

cmake/modules/OpenCL.cmake

@@ -19,6 +19,15 @@ else()
   list(APPEND COMPILER_SRCS src/codegen/opt/build_sdaccel_off.cc)
 endif(USE_SDACCEL)
 
+if(USE_AOCL)
+  message(STATUS "Build with Intel FPGA SDK for OpenCL support")
+  add_definitions(-DAOCL_BOARD_NAME="${USE_AOCL}")
+  if(NOT USE_OPENCL)
+    message(STATUS "Enable OpenCL support required for Intel FPGA SDK for OpenCL")
+    set(USE_OPENCL ON)
+  endif()
+endif(USE_AOCL)
+
 if(USE_OPENCL)
   find_package(OpenCL REQUIRED)
   message(STATUS "Build with OpenCL support")

docs/deploy/aocl_fpga.md

@@ -0,0 +1,56 @@
+AOCL Backend Example
+====================
+
+TVM supports Intel FPGA SDK for OpenCL also known as AOCL.  Here is a tutorial for how to use TVM with AOCL.
+
+***Note***: This feature is still experimental.  We cannot use AOCL to deploy an end to end neural networks for now.  In addition, we can only use AOCL's emulation mode for now.
+
+We use a python scripts for this tutorial.
+
+- emu-aocl-fpga.py
+```# -*- coding: utf-8 -*-
+import tvm
+import numpy as np
+
+tgt_host = 'llvm'
+tgt = 'opencl'
+
+# Define a computation.
+n = tvm.var('n')
+a = tvm.placeholder((n,), name='a')
+b = tvm.placeholder((n,), name='b')
+c = tvm.compute(a.shape, lambda i: a[i] + b[i], name='c')
+
+# Make a schedule.
+s = tvm.create_schedule(c.op)
+px, x = s[c].split(c.op.axis[0], nparts=1)
+s[c].bind(px, tvm.thread_axis("pipeline"))
+
+# Make a executable code.
+fadd = tvm.build(s, [a, b, c], tgt, target_host=tgt_host, name='myadd')
+
+# Run.
+ctx = tvm.context(tgt, 0)
+n = 1024
+a = tvm.nd.array(np.random.uniform(size=n).astype(a.dtype), ctx)
+b = tvm.nd.array(np.random.uniform(size=n).astype(b.dtype), ctx)
+c = tvm.nd.array(np.zeros(n, dtype=c.dtype), ctx)
+fadd(a, b, c)```
+
+Setup
+-----
+
+- Install AOCL 17.1 on Ubuntu 16.04.4 LTS.
+- Install FPGA device driver.
+- Make ICD file.
+- Make FCD file.
+- Setup TVM with AOCL and OpenCL enabled.
+
+Emulation
+---------
+
+- Set environment variable.
+```export CL_CONTEXT_EMULATOR_DEVICE_INTELFPGA=1```
+
+- Run software emulation
+```python emu-aocl-fpga.py```

src/runtime/opencl/opencl_common.h

@@ -143,7 +143,11 @@ class OpenCLWorkspace : public DeviceAPI {
   void Init(const std::string& type_key, const std::string& device_type,
             const std::string& platform_name = "");
   virtual void Init() {
+#ifndef AOCL_BOARD_NAME
     Init("opencl", "gpu");
+#else
+    Init("opencl", "accelerator");
+#endif
   }
   // Check whether the context is OpenCL or not.
   virtual bool IsOpenCLDevice(TVMContext ctx) {
@@ -284,6 +288,10 @@ class OpenCLModuleNode : public ModuleNode {
   std::unordered_map<std::string, KTRefEntry> kid_map_;
   // kernels build so far.
   std::vector<cl_kernel> kernels_;
+
+#ifdef AOCL_BOARD_NAME
+  void OfflineCompile(cl::OpenCLWorkspace* w,  cl::OpenCLThreadEntry* t);
+#endif
 };
 
 }  // namespace runtime

src/runtime/opencl/opencl_device_api.cc

@@ -208,7 +208,11 @@ std::vector<cl_device_id> GetDeviceIDs(
   cl_device_type dtype = CL_DEVICE_TYPE_ALL;
   if (device_type == "cpu") dtype = CL_DEVICE_TYPE_CPU;
   if (device_type == "gpu") dtype = CL_DEVICE_TYPE_GPU;
+#ifndef AOCL_BOARD_NAME
   if (device_type == "accelerator") dtype = CL_DEVICE_TYPE_ACCELERATOR;
+#else
+  if (device_type == "accelerator") dtype = CL_DEVICE_TYPE_DEFAULT;
+#endif
   cl_uint ret_size;
   cl_int code = clGetDeviceIDs(pid, dtype, 0, nullptr, &ret_size);
   std::vector<cl_device_id> ret;

src/runtime/opencl/opencl_module.cc

@@ -6,6 +6,8 @@
 #include <tvm/runtime/registry.h>
 #include <vector>
 #include <string>
+#include <iostream>
+#include <fstream>
 #include <unordered_map>
 #include "./opencl_common.h"
 #include "./opencl_module.h"
@@ -185,11 +187,15 @@ cl_kernel OpenCLModuleNode::InstallKernel(cl::OpenCLWorkspace* w,
     // create program
     if (fmt_ == "cl") {
       if (program_ == nullptr) {
+#ifndef AOCL_BOARD_NAME
         const char* s = data_.c_str();
         size_t len = data_.length();
         cl_int err;
         program_ = clCreateProgramWithSource(w->context, 1, &s, &len, &err);
         OPENCL_CHECK_ERROR(err);
+#else
+        OfflineCompile(w, t);
+#endif
       }
     } else if (fmt_ == "xclbin" || fmt_ == "awsxclbin") {
       const unsigned char* s = (const unsigned char *)data_.c_str();
@@ -227,6 +233,54 @@ cl_kernel OpenCLModuleNode::InstallKernel(cl::OpenCLWorkspace* w,
   return kernel;
 }
 
+#ifdef AOCL_BOARD_NAME
+void OpenCLModuleNode::OfflineCompile(cl::OpenCLWorkspace* w,
+                                      cl::OpenCLThreadEntry* t) {
+    // Write a .cl file.
+    std::ofstream ofs("aocltmp.cl");
+    if (!ofs) {
+      LOG(FATAL) << "Can't create OpenCL temporary file.";
+    }
+    ofs << data_.c_str();
+    if (!ofs) {
+      LOG(FATAL) << "Can't write to OpenCL temporary file.";
+    }
+    ofs.close();
+
+    // Compile the .cl file.
+    std::string cmd = "aoc aocltmp.cl -march=emulator -board=";
+    cmd += AOCL_BOARD_NAME;
+    if (system(cmd.c_str()) != 0) {
+      LOG(FATAL) << "OpenCL offline compilation error.";
+    }
+
+    // Read .aocx file
+    std::ifstream ifs("aocltmp.aocx", std::ios::in | std::ios::binary);
+    if (!ifs) {
+      LOG(FATAL) << "Can't open aocltmp.aocx file.";
+    }
+    ifs.seekg(0, std::fstream::end);
+    const size_t len = ifs.tellg();
+    char *buf = new char[len];
+    ifs.clear();
+    ifs.seekg(0, std::fstream::beg);
+    ifs.read(buf, len);
+    if (!ifs) {
+      LOG(FATAL) << "Can't read aocltmp.aocx file.";
+    }
+
+    // Create program from aocx.
+    cl_int err;
+    int device_id = t->context.device_id;
+    cl_device_id dev = w->devices[device_id];
+    const unsigned char* s = (const unsigned char *)buf;
+    program_ = clCreateProgramWithBinary(w->context, 1, &dev, &len, &s, NULL, &err);
+    OPENCL_CHECK_ERROR(err);
+
+    delete[] buf;
+}
+#endif
+
 Module OpenCLModuleCreate(
     std::string data,
     std::string fmt,