Optimized GEMM & GEMV for Intel platforms

CMakeLists.txt

@@ -76,7 +76,7 @@ add_custom_command(OUTPUT "${CMAKE_BINARY_DIR}/build/timestamp"
 
 add_custom_target(package-python DEPENDS "${CMAKE_BINARY_DIR}/build/timestamp")
 
-
+#find_package( OpenCL ${OPENCL_VERSION} )
 #Isaac
 include(CTest)
 

include/isaac/jit/generation/gemm.h

@@ -46,6 +46,39 @@ class cublas_gemm : public external_base
   bool init_;
 };
 
+class intelblas_gemm : public external_base
+{
+  bool init();
+public:
+  intelblas_gemm(char A_trans, char B_trans);
+  int is_invalid(expression_tree const  &, driver::Device const &) const;
+  std::vector<int_t> input_sizes(expression_tree const & expressions) const;
+  void enqueue(driver::CommandQueue & queue, driver::Program const &, std::string const &, runtime::execution_handler const & h);
+  expression_type type() const;
+private:
+  std::string generate_impl(std::string const & suffix, expression_tree const &, driver::Device const & device, symbolic::symbols_table const &) const;
+  const char A_trans_;
+  const char B_trans_;
+  bool init_;
+};
+
+class intelblas_gemm_image : public external_base
+{
+  bool init();
+public:
+  intelblas_gemm_image(char A_trans, char B_trans);
+  int is_invalid(expression_tree const  &, driver::Device const &) const;
+  std::vector<int_t> input_sizes(expression_tree const & expressions) const;
+  void enqueue(driver::CommandQueue & queue, driver::Program const &, std::string const &, runtime::execution_handler const & h);
+  expression_type type() const;
+private:
+  std::string generate_impl(std::string const & suffix, expression_tree const &, driver::Device const & device, symbolic::symbols_table const &) const;
+  const char A_trans_;
+  const char B_trans_;
+  bool init_;
+};
+
+
 class gemm : public parameterized_base
 {
 private:

include/isaac/jit/generation/reduce_2d.h

@@ -26,12 +26,25 @@
 
 #include "isaac/jit/syntax/expression/expression.h"
 #include "isaac/jit/generation/base.h"
+#include "isaac/jit/syntax/expression/preset.h"
 
 namespace isaac
 {
 namespace templates
 {
 
+class intelblas_gemv : public external_base
+{
+private:
+  std::string generate_impl(std::string const & suffix, expression_tree const &, driver::Device const & device, symbolic::symbols_table const &) const;
+public:
+  intelblas_gemv();
+   int is_invalid(expression_tree const  &, driver::Device const &) const { return 0;}
+  virtual std::vector<int_t> input_sizes(expression_tree const & ) const { return std::vector<int_t>();}
+  void enqueue(driver::CommandQueue & queue, driver::Program const &, std::string const &, runtime::execution_handler const & h);
+  expression_type type() const { return expression_type();}
+};
+
 class reduce_2d : public parameterized_base
 {
 protected:

include/isaac/jit/syntax/expression/preset.h

@@ -60,6 +60,32 @@ class gemm
     static args check(expression_tree::data_type const &tree, size_t rootidx);
 };
 
+class gemv
+{
+
+public:
+    struct args
+    {
+        args(): A(NULL), X(NULL), Y(NULL), type(INVALID_EXPRESSION_TYPE){ }
+        value_scalar alpha;
+        expression_tree::node const * A;
+        expression_tree::node const * X;
+        value_scalar beta;
+        expression_tree::node const * Y;
+        expression_type type;
+
+        operator bool() const
+        {
+            return type!=INVALID_EXPRESSION_TYPE && A!=NULL && X!=NULL && Y!=NULL;
+        }
+    };
+private:
+    static void handle_node( expression_tree::data_type const &tree, size_t rootidx, args & a);
+
+public:
+    static args check(expression_tree::data_type const &tree, size_t rootidx);
+};
+
 }
 
 }

lib/CMakeLists.txt

@@ -8,6 +8,7 @@ else()
 		set_target_properties(isaac PROPERTIES LINK_FLAGS "/DEF:${CMAKE_CURRENT_SOURCE_DIR}/wrap/clBLAS.def")
 	endif()
 endif()
+#target_link_libraries(isaac ${OPENCL_LIBRARIES})
 
 #Database
 if(NOT ANDROID)
@@ -21,7 +22,7 @@ if(NOT ANDROID)
     endforeach()
 endif()
 
-target_link_libraries(isaac "dl")
+target_link_libraries(isaac "dl" OpenCL pthread)
 
 #Cuda JIT headers to file
 set(CUDA_HELPERS_PATH ${CMAKE_CURRENT_SOURCE_DIR}/driver/helpers/cuda/)

lib/api/blas/clBLAS.cpp

@@ -166,7 +166,7 @@ extern "C"
     {\
         if(order==clblasRowMajor){\
             std::swap(M, N);\
-            transA = (transA==clblasTrans)?clblasNoTrans:clblasTrans;\
+            transA = (transA==clblasTrans||transA==clblasConjTrans)?clblasNoTrans:clblasTrans;\
         }\
         sc::array A((sc::int_t)M, (sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(mA, false), (sc::int_t)offA, (sc::int_t)lda);\
         \
@@ -176,7 +176,7 @@ extern "C"
         sc::array y(sy, TYPE_ISAAC, sc::driver::Buffer(my, false), (sc::int_t)offy, incy);\
         \
         sc::driver::Context const & context = A.context();\
-        if(transA==clblasTrans)\
+        if(transA==clblasTrans||transA==clblasConjTrans)\
             execute(sc::assign(y, alpha*dot(A.T, x) + beta*y), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         else\
             execute(sc::assign(y, alpha*dot(A, x) + beta*y), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
@@ -217,19 +217,19 @@ extern "C"
         }\
         sc::int_t As1 = (sc::int_t)M, As2 = (sc::int_t)K;\
         sc::int_t Bs1 = (sc::int_t)K, Bs2 = (sc::int_t)N;\
-        if(transA==clblasTrans) std::swap(As1, As2);\
-        if(transB==clblasTrans) std::swap(Bs1, Bs2);\
+        if(transA==clblasTrans || transA==clblasConjTrans) std::swap(As1, As2);\
+        if(transB==clblasTrans || transB==clblasConjTrans) std::swap(Bs1, Bs2);\
         /*Struct*/\
         sc::array A(As1, As2, TYPE_ISAAC, sc::driver::Buffer(mA, false), (sc::int_t)offA, (sc::int_t)lda);\
         sc::array B(Bs1, Bs2, TYPE_ISAAC, sc::driver::Buffer(mB, false), (sc::int_t)offB, (sc::int_t)ldb);\
         sc::array C((sc::int_t)M, (sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(mC, false), (sc::int_t)offC, (sc::int_t)ldc);\
         sc::driver::Context const & context = C.context();\
         /*Operation*/\
-        if((transA==clblasTrans) && (transB==clblasTrans))\
+        if((transA==clblasTrans || transA==clblasConjTrans) && (transB==clblasTrans || transB==clblasConjTrans))\
             execute(sc::assign(C, alpha*dot(A.T, B.T) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
-        else if((transA==clblasTrans) && (transB==clblasNoTrans))\
+        else if((transA==clblasTrans || transA==clblasConjTrans) && (transB==clblasNoTrans))\
             execute(sc::assign(C, alpha*dot(A.T, B) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
-        else if((transA==clblasNoTrans) && (transB==clblasTrans))\
+        else if((transA==clblasNoTrans) && (transB==clblasTrans || transB==clblasConjTrans))\
             execute(sc::assign(C, alpha*dot(A, B.T) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         else\
             execute(sc::assign(C, alpha*dot(A, B) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\

lib/driver/device.cpp

@@ -303,6 +303,9 @@ std::string Device::infos() const
   return oss.str();
 }
 
+Device::handle_type const & Device::handle() const
+{ return h_; }
+
 // Properties
 #define WRAP_ATTRIBUTE(ret, fname, CUNAME, CLNAME) \
   ret Device::fname() const\

lib/driver/kernel.cpp

@@ -127,6 +127,9 @@ void Kernel::setSizeArg(unsigned int index, size_t N)
   }
 }
 
+Kernel::handle_type const & Kernel::handle() const
+{ return h_; }
+
 }
 
 }

lib/jit/generation/elementwise_1d.cpp

@@ -28,6 +28,7 @@
 #include "tools/loop.hpp"
 #include "tools/vector_types.hpp"
 #include "tools/arguments.hpp"
+#include "isaac/driver/dispatch.h"
 
 #include <string>
 
@@ -102,7 +103,7 @@ std::string elementwise_1d::generate_impl(std::string const & suffix, expression
   stream.dec_tab();
   stream << "}" << std::endl;
 
-//  std::cout << stream.str() << std::endl;
+  // std::cout << stream.str() << std::endl;
   return stream.str();
 }
 
@@ -118,6 +119,7 @@ std::vector<int_t> elementwise_1d::input_sizes(expression_tree const & expressio
 
 void elementwise_1d::enqueue(driver::CommandQueue &, driver::Program const & program, std::string const & suffix, runtime::execution_handler const & control)
 {
+  // std::cout << "suffix = " << suffix << std::endl;
   expression_tree const & expressions = control.x();
   //Size
   int_t size = input_sizes(expressions)[0];
@@ -134,6 +136,8 @@ void elementwise_1d::enqueue(driver::CommandQueue &, driver::Program const & pro
   kernel.setSizeArg(current_arg++, size);
   symbolic::set_arguments(expressions, kernel, current_arg);
   control.execution_options().enqueue(program.context(), kernel, global, local);
+  driver::dispatch::clFinish(control.execution_options().queue(expressions.context()).handle().cl());
+  // clFlush(control.execution_options().queue(expressions.context()).handle().cl());
 }
 
 

lib/jit/generation/elementwise_2d.cpp

@@ -26,7 +26,7 @@
 #include "tools/arguments.hpp"
 #include "tools/loop.hpp"
 #include "tools/vector_types.hpp"
-
+#include "isaac/driver/dispatch.h"
 
 namespace isaac
 {
@@ -117,6 +117,7 @@ void elementwise_2d::enqueue(driver::CommandQueue & /*queue*/, driver::Program c
   symbolic::set_arguments(expressions, kernel, current_arg);
 
   control.execution_options().enqueue(program.context(), kernel, global, local);
+  driver::dispatch::clFinish(control.execution_options().queue(expressions.context()).handle().cl());
 }
 
 }