Introducing sb handle (codeplaysoftware#363)

* Introducing the concept of sycl_blas_handle
* Removing dependency on the virtual pointer in ComputeCpp SDK
* Removing policy handler concept
* Removing The executor concept

Author: mehdi-goli

Diff for: CMakeLists.txt

@@ -39,11 +39,13 @@ endif()
 option(INSTALL_HEADER_ONLY "Install SYCL-BLAS as a header only library" OFF)
 
 set(BUILD_SHARED_LIBS ON CACHE BOOL "")
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS})
 
+set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations  -Wno-deprecated-copy-with-user-provided-copy") 
+
 if(DEFINED SYSTEM_BLAS_ROOT)
   message(DEPRECATION
     "SYSTEM_BLAS_ROOT is deprecated. Add the path to the reference BLAS to CMAKE_PREFIX_PATH instead")
@@ -74,7 +76,6 @@ find_package(PythonInterp 3 REQUIRED)
 
 if (MSVC)
   # The device compiler needs C++14 to parse the Windows headers
-  set(CMAKE_CXX_STANDARD 14)
   set(BUILD_SHARED_LIBS FALSE CACHE BOOL
     "Force SYCL-BLAS to be built as a static library on Windows"
     FORCE
@@ -189,10 +190,7 @@ if (INSTALL_HEADER_ONLY)
     FILES_MATCHING PATTERN "*.hpp"
   )
 endif()
-install(DIRECTORY ${CMAKE_SOURCE_DIR}/external/computecpp-sdk/include/vptr
-  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-  COMPONENT sycl_blas
-)
+
 install(FILES ${version_file} DESTINATION ${CMAKE_INSTALL_PREFIX})
 install(EXPORT sycl_blas
   DESTINATION ${CMAKE_INSTALL_PREFIX}

Diff for: README.md

@@ -18,28 +18,31 @@ the project.
 
 ## Table of Contents
 
-  * [Motivation](#motivation)
-  * [Basic Concepts](#basic-concepts)
-    * [Views](#views)
-    * [Operations](#operations)
-    * [Executors](#executors)
-    * [Interface](#interface)
-  * [API description](#api-description)
-    * [BLAS 1](#blas-1)
-    * [BLAS 2](#blas-2)
-    * [BLAS 3](#blas-3)
-  * [Requirements](#requirements)
-  * [Setup](#setup)
-    * [Compile with ComputeCpp](#Compile-with-ComputeCpp)
-    * [Compile with DPC++](#Compile-with-DPC++)
-    * [Instaling SYCL-BLAS](#Instaling-SYCL-BLAS)
-    * [POWER_VR support (ComputeCpp Only)](#POWER_VR-support-(ComputeCpp-Only))
-    * [Doxygen](#Doxygen)
-    * [How to compile](#how-to-compile)
-    * [CMake options](#cmake-options)
-    * [Cross-Compile](#cross-compile)
-  * [Tests and benchmarks](#tests-and-benchmarks)
-  * [Contributing to the project](#contributing-to-the-project)
+- [SYCL-BLAS Implementation](#sycl-blas-implementation)
+  - [Table of Contents](#table-of-contents)
+  - [Motivation](#motivation)
+  - [Basic Concepts](#basic-concepts)
+    - [Views](#views)
+    - [Operations](#operations)
+    - [SB\_Handle](#sb_handle)
+    - [Interface](#interface)
+  - [API description](#api-description)
+    - [BLAS 1](#blas-1)
+    - [BLAS 2](#blas-2)
+    - [BLAS 3](#blas-3)
+  - [Requirements](#requirements)
+  - [Setup](#setup)
+    - [Compile with ComputeCpp](#compile-with-computecpp)
+    - [Compile with DPC++](#compile-with-dpc)
+    - [Compile with hipSYCL](#compile-with-hipsycl)
+    - [Instaling SYCL-BLAS](#instaling-sycl-blas)
+    - [POWER\_VR support (ComputeCpp Only)](#power_vr-support-computecpp-only)
+    - [Doxygen](#doxygen)
+    - [CMake options](#cmake-options)
+    - [Cross-Compile (ComputeCpp Only)](#cross-compile-computecpp-only)
+  - [Tests and benchmarks](#tests-and-benchmarks)
+  - [Contributing to the project](#contributing-to-the-project)
+    - [Guides and Other Documents](#guides-and-other-documents)
 
 ## Motivation
 
@@ -110,7 +113,7 @@ All the relevant files can be found in
 the `include` directory.
 
 There are four components in SYCL-BLAS, the *View*, the *Operations*,
-the *Executors* and the *Interface* itself.
+the *SB_Handle* and the *Interface* itself.
 
 ### Views
 
@@ -144,14 +147,11 @@ The leaf nodes of an Expression Tree are Views or Scalar types (data).
 The intermediate nodes of the Expression Tree are operations (e.g,
 binary operations, unary operations, etc).
 
-### Executors
+### SB_Handle
 
-An executor traverses the Expression Tree to evaluate the operations that it
+An SB_Handle traverses the Expression Tree to evaluate the operations that it
 defines.
-Executors use different techniques to evaluate the expression tree.
-The basic C++ executor performs a for loop on the size of the data and calls
-the evaluation function on each item.
-
+SB_Handle use different techniques to evaluate the expression tree.
 The SYCL evaluator transform the tree into a device tree (i.e, converting
 buffer to accessors) and then evaluates the Expression Tree on the device.
 
@@ -176,8 +176,8 @@ of multiple BLAS operations.
 
 This section references all the supported operations and their interface.
 
-All operations take as their first argument a reference to the executor, a
-`blas::Executor` created with a `sycl::queue`. The return value is usually an
+All operations take as their first argument a reference to the SB_Handle, a
+`blas::SB_Handle` created with a `sycl::queue`. The return value is usually an
 array of SYCL events (except for some operations that can return a scalar or
 a tuple). The containers for the vectors and matrices (and scalars written by
 the BLAS operations) are iterator buffers that can be created with

Diff for: Roadmap.md

@@ -27,6 +27,4 @@ Medium Term:
 Long Term:
 
 * Complete the Blas 3 interface
-* Test the Parallel and Sequential Executors
 * Add continuous integration testing 
-

Diff for: benchmark/clBench/acl/blas3/gemm.cpp

@@ -38,14 +38,14 @@ std::string get_name(std::string t1, std::string t2, int m, int k, int n) {
   return str.str();
 }
 
-void run(benchmark::State& state, int t1, int t2,
-         index_t m, index_t k, index_t n, float alpha, float beta, bool* success) {
+void run(benchmark::State& state, int t1, int t2, index_t m, index_t k,
+         index_t n, float alpha, float beta, bool* success) {
   // Standard test setup.
   std::string t1s = blas_benchmark::utils::from_transpose_enum(
       static_cast<blas_benchmark::utils::Transposition>(t1));
   std::string t2s = blas_benchmark::utils::from_transpose_enum(
       static_cast<blas_benchmark::utils::Transposition>(t2));
-  if(t1s != "n" || t2s != "n") {
+  if (t1s != "n" || t2s != "n") {
     state.SkipWithError("Transposed matrices not supported in ACL benchmarks");
     return;
   }
@@ -85,8 +85,7 @@ void run(benchmark::State& state, int t1, int t2,
   // Matrices
   std::vector<float> a = blas_benchmark::utils::random_data<float>(m * k);
   std::vector<float> b = blas_benchmark::utils::random_data<float>(k * n);
-  std::vector<float> c =
-      blas_benchmark::utils::const_data<float>(m * n, 0);
+  std::vector<float> c = blas_benchmark::utils::const_data<float>(m * n, 0);
 
   // Device matrices
   const arm_compute::TensorShape shape_a(k, m), shape_b(n, k), shape_c(n, m);
@@ -96,9 +95,12 @@ void run(benchmark::State& state, int t1, int t2,
   arm_compute::CLScheduler::get().default_init();
   arm_compute::CLTensor arm_a, arm_b, arm_c;
 #endif
-  arm_a.allocator()->init(arm_compute::TensorInfo(shape_a, 1, arm_compute::DataType::F32));
-  arm_b.allocator()->init(arm_compute::TensorInfo(shape_b, 1, arm_compute::DataType::F32));
-  arm_c.allocator()->init(arm_compute::TensorInfo(shape_c, 1, arm_compute::DataType::F32));
+  arm_a.allocator()->init(
+      arm_compute::TensorInfo(shape_a, 1, arm_compute::DataType::F32));
+  arm_b.allocator()->init(
+      arm_compute::TensorInfo(shape_b, 1, arm_compute::DataType::F32));
+  arm_c.allocator()->init(
+      arm_compute::TensorInfo(shape_c, 1, arm_compute::DataType::F32));
   arm_a.allocator()->allocate();
   arm_b.allocator()->allocate();
   arm_c.allocator()->allocate();
@@ -172,14 +174,13 @@ void register_benchmark(blas_benchmark::Args& args, bool* success) {
     int t1 = static_cast<int>(blas_benchmark::utils::to_transpose_enum(t1s));
     int t2 = static_cast<int>(blas_benchmark::utils::to_transpose_enum(t2s));
 
-    auto BM_lambda = [&](benchmark::State& st, int t1,
-                         int t2, index_t m, index_t k, index_t n,
-                         float alpha, float beta, bool* success) {
+    auto BM_lambda = [&](benchmark::State& st, int t1, int t2, index_t m,
+                         index_t k, index_t n, float alpha, float beta,
+                         bool* success) {
       run(st, t1, t2, m, k, n, alpha, beta, success);
     };
-    benchmark::RegisterBenchmark(get_name(t1s, t2s, m, k, n).c_str(),
-                                 BM_lambda, t1, t2, m, k, n, alpha,
-                                 beta, success);
+    benchmark::RegisterBenchmark(get_name(t1s, t2s, m, k, n).c_str(), BM_lambda,
+                                 t1, t2, m, k, n, alpha, beta, success);
   }
 }
 

Diff for: benchmark/clBench/acl/utils.hpp

@@ -2,7 +2,6 @@
 #define ACL_UTILS_HPP
 
 #include <CL/cl.h>
-#include <clBench/clwrap.hpp>
 #include <arm_compute/core/Helpers.h>
 #include <arm_compute/core/ITensor.h>
 #include <arm_compute/core/Types.h>
@@ -11,6 +10,7 @@
 #include <arm_compute/runtime/CL/CLFunctions.h>
 #include <arm_compute/runtime/CL/CLScheduler.h>
 #include <arm_compute/runtime/Tensor.h>
+#include <clBench/clwrap.hpp>
 #include <thread>
 
 #ifdef ACL_BACKEND_NEON

Diff for: benchmark/clBench/clblas/blas3/trsm.cpp

@@ -64,10 +64,8 @@ void run(benchmark::State& state, ExecutorType* executorPtr, char side,
   clblasTranspose transA =
       blas_benchmark::utils::translate_transposition(&transpose);
   clblasSide sideA = blas_benchmark::utils::translate_side(&side);
-  clblasUplo triangleA =
-      blas_benchmark::utils::translate_triangle(&triangle);
-  clblasDiag diagA =
-      blas_benchmark::utils::translate_diagonal(&diagonal);
+  clblasUplo triangleA = blas_benchmark::utils::translate_triangle(&triangle);
+  clblasDiag diagA = blas_benchmark::utils::translate_diagonal(&diagonal);
 
   if (clblasSetup() != CL_SUCCESS) {
     state.SkipWithError("error initiazing clblas");
@@ -90,8 +88,7 @@ void run(benchmark::State& state, ExecutorType* executorPtr, char side,
   err = clEnqueueWriteBuffer(executorPtr->queue(), a_gpu, CL_TRUE, 0,
                              sizeA * sizeof(scalar_t), a.data(), 0, nullptr,
                              nullptr);
-  err =
-      clEnqueueWriteBuffer(executorPtr->queue(), b_gpu, CL_TRUE, 0,
+  err = clEnqueueWriteBuffer(executorPtr->queue(), b_gpu, CL_TRUE, 0,
                              sizeB * sizeof(scalar_t), b.data(), 0, nullptr,
                              nullptr);
 

Diff for: benchmark/clBench/clblas/utils.hpp

@@ -1,9 +1,9 @@
 #ifndef CLBLAST_UTILS_HPP
 #define CLBLAST_UTILS_HPP
 
-#include <common/common_utils.hpp>
-#include <clBench/clwrap.hpp>
 #include <clBLAS.h>
+#include <clBench/clwrap.hpp>
+#include <common/common_utils.hpp>
 
 typedef Context ExecutorType;
 
@@ -86,7 +86,7 @@ static inline clblasSide translate_side(const char *side) {
   }
 }
 
-static inline clblasUplo translate_triangle(const char* triangle) {
+static inline clblasUplo translate_triangle(const char *triangle) {
   if (triangle[0] == 'u') {
     return clblasUpper;
   } else if (triangle[0] == 'l') {
@@ -99,7 +99,8 @@ static inline clblasUplo translate_triangle(const char* triangle) {
 static inline clblasDiag translate_diagonal(const char *diag) {
   if (diag[0] == 'u') {
     return clblasUnit;
-  } if (diag[0] == 'n') {
+  }
+  if (diag[0] == 'n') {
     return clblasNonUnit;
   } else {
     throw std::runtime_error("Got invalid diagonal parameter!");

Diff for: benchmark/clBench/clblast/utils.hpp

@@ -26,9 +26,9 @@
 #ifndef CLBLAST_UTILS_HPP
 #define CLBLAST_UTILS_HPP
 
-#include <common/common_utils.hpp>
 #include <clBench/clwrap.hpp>
 #include <clblast.h>
+#include <common/common_utils.hpp>
 
 typedef Context ExecutorType;
 
@@ -111,7 +111,7 @@ static inline clblast::Side translate_side(const char *side) {
   }
 }
 
-static inline clblast::Triangle translate_triangle(const char* triangle) {
+static inline clblast::Triangle translate_triangle(const char *triangle) {
   if (triangle[0] == 'u') {
     return clblast::Triangle::kUpper;
   } else if (triangle[0] == 'l') {
@@ -124,7 +124,8 @@ static inline clblast::Triangle translate_triangle(const char* triangle) {
 static inline clblast::Diagonal translate_diagonal(const char *diag) {
   if (diag[0] == 'u') {
     return clblast::Diagonal::kUnit;
-  } if (diag[0] == 'n') {
+  }
+  if (diag[0] == 'n') {
     return clblast::Diagonal::kNonUnit;
   } else {
     throw std::runtime_error("Got invalid diagonal parameter!");

Diff for: benchmark/clBench/clwrap.hpp

@@ -30,9 +30,9 @@
 #include <stdexcept>
 #include <vector>
 
+#include <CL/cl.h>
 #include <algorithm>
 #include <memory>
-#include <CL/cl.h>
 
 /* We don't want to return exceptions in destructors. #define them out for now.
  */
@@ -150,10 +150,10 @@ class OpenCLDeviceSelector {
   cl_platform_id best_platform = NULL;
   int best_score = 0;
 
-  static cl_device_type match_device_type(std::string requested){
+  static cl_device_type match_device_type(std::string requested) {
     if (requested.empty()) return CL_DEVICE_TYPE_ALL;
     std::transform(requested.begin(), requested.end(), requested.begin(),
-                 ::tolower);
+                   ::tolower);
     if (requested == "gpu") return CL_DEVICE_TYPE_GPU;
     if (requested == "cpu") return CL_DEVICE_TYPE_CPU;
     if (requested == "accel") return CL_DEVICE_TYPE_ACCELERATOR;
@@ -238,7 +238,8 @@ class OpenCLDeviceSelector {
   OpenCLDeviceSelector(std::string vendor, std::string type) {
     // Get the number of platforms, and a list of IDs
     cl_uint num_platforms = get_platform_count();
-    std::unique_ptr<cl_platform_id[]> platforms(new cl_platform_id[num_platforms]);
+    std::unique_ptr<cl_platform_id[]> platforms(
+        new cl_platform_id[num_platforms]);
     cl_int status = clGetPlatformIDs(num_platforms, platforms.get(), NULL);
     if (status != CL_SUCCESS) {
       do_error("failure in clGetPlatformIDs");
@@ -254,7 +255,7 @@ class OpenCLDeviceSelector {
       cl_uint num_devices = get_device_count(platform);
       std::unique_ptr<cl_device_id[]> devices(new cl_device_id[num_devices]);
       cl_int status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, num_devices,
-                                    devices.get(), NULL);
+                                     devices.get(), NULL);
       if (status != CL_SUCCESS) {
         do_error("failure in clGetDeviceIDs");
       }
@@ -289,7 +290,6 @@ class Context {
   bool is_active = false;
 
  public:
- 
   // Delete the copy constructor so that we don't accidentally leak references
   // to the underlying opencl context
   Context(const Context &) = delete;
@@ -301,7 +301,7 @@ class Context {
         is_active(c.active()),
         command_queue(c.queue()) {}
 
-  Context(OpenCLDeviceSelector oclds= OpenCLDeviceSelector("*", "*")) {
+  Context(OpenCLDeviceSelector oclds = OpenCLDeviceSelector("*", "*")) {
     platform = oclds.platform();
     device = oclds.device();
     create();
@@ -314,8 +314,8 @@ class Context {
     if (status != CL_SUCCESS) {
       do_error("failure to create context");
     }
-    command_queue =
-        clCreateCommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE, &status);
+    command_queue = clCreateCommandQueue(context, device,
+                                         CL_QUEUE_PROFILING_ENABLE, &status);
     if (status != CL_SUCCESS) {
       do_error("failure to create command queue");
     }
@@ -349,7 +349,6 @@ class Context {
   }
 
   operator cl_context() const { return context; }
-
 };
 
 class CLEventHandler {
@@ -379,7 +378,6 @@ class CLEventHandler {
       release(event);
     }
   }
-
 };
 
 template <typename scalar_t, int Options = CL_MEM_READ_WRITE>
@@ -458,5 +456,4 @@ class MemBuffer {
   }
 };
 
-
 #endif /* end of include guard: CLWRAP_HPP */