Make swiglu and rmsnor svm optional

Modify swiglu and rmsnorm cl implementations to work with both
svm allocated tensors and buffers

**Self-evaluation:**
1. Build test: [X]Passed [ ]Failed [ ]Skipped
2. Run test:   [X]Passed [ ]Failed [ ]Skipp

Signed-off-by: Grzegorz Kisala <[email protected]>

Author: gkisalapl

nntrainer/layers/cl_layers/swiglu_cl.cpp

@@ -116,91 +116,66 @@ void SwiGLULayerCl::swigluProcess(Tensor const &in1, Tensor const &in2,
 }
 
 void SwiGLULayerCl::swiglu_cl(float *matAdata, float *vecXdata, float *vecYdata,
-                              unsigned int dim1, unsigned int dim2, bool svm) {
-  auto *global_cl_context =
+                              unsigned int dim1, unsigned int dim2,
+                              const bool use_svm) {
+  auto cl_context =
     static_cast<ClContext *>(Engine::Global().getRegisteredContext("gpu"));
-  auto &clbuffInstance = ClBufferManager::Global();
 
-  do {
-    const auto &kernel_swiglu_ptr = getLayerKernelPtrs()[Kernels::SWIGLU_CL];
-    int dim = int(dim1 * dim2);
+  const auto &kernel = getLayerKernelPtrs()[Kernels::SWIGLU_CL];
+  const size_t dim = dim1 * dim2;
 
-    if (!svm) {
-      bool write_result = true;
-
-      write_result &= clbuffInstance.getInBufferA()->WriteDataRegion(
-        global_cl_context->command_queue_inst_, dim * sizeof(float), matAdata);
-      write_result &= clbuffInstance.getInBufferB()->WriteDataRegion(
-        global_cl_context->command_queue_inst_, dim * sizeof(float), vecXdata);
-      if (!write_result) {
-        break;
-      }
-
-      auto bufferInA = clbuffInstance.getInBufferA()->GetBuffer();
-      auto bufferInB = clbuffInstance.getInBufferB()->GetBuffer();
-      auto bufferOutA = clbuffInstance.getOutBufferA()->GetBuffer();
-
-      bool set_result = true;
-      set_result &=
-        kernel_swiglu_ptr->SetKernelArguments(0, &bufferInA, sizeof(cl_mem));
-      set_result &=
-        kernel_swiglu_ptr->SetKernelArguments(1, &bufferInB, sizeof(cl_mem));
-      set_result &=
-        kernel_swiglu_ptr->SetKernelArguments(2, &bufferOutA, sizeof(cl_mem));
-      if (!set_result) {
-        break;
-      }
-    } else {
-      bool map_result = true;
-      map_result &=
-        global_cl_context->command_queue_inst_.enqueueSVMUnmap(matAdata);
-      map_result &=
-        global_cl_context->command_queue_inst_.enqueueSVMUnmap(vecXdata);
-      if (!map_result) {
-        ml_loge("Failed to map svm");
-        break;
-      }
-
-      bool set_svm_result = true;
-      set_svm_result &= kernel_swiglu_ptr->SetKernelSVMArguments(0, matAdata);
-      set_svm_result &= kernel_swiglu_ptr->SetKernelSVMArguments(1, vecXdata);
-      set_svm_result &= kernel_swiglu_ptr->SetKernelSVMArguments(2, vecYdata);
-      if (!set_svm_result) {
-        ml_loge("Failed to set svm");
-        break;
-      }
-    }
+  if (!use_svm) {
+    bool write_result = true;
+    auto &clbuffInstance = ClBufferManager::Global();
 
-    // NOTE(mwlasiuk) : local size can not be larger than global
-    const int32_t desired_local = 64;
-    const bool can_use_desired = dim >= desired_local;
-    const int32_t chosen_local = can_use_desired ? desired_local : dim;
+    write_result &= clbuffInstance.getInBufferA()->WriteDataRegion(
+      cl_context->command_queue_inst_, dim * sizeof(float), matAdata);
+    write_result &= clbuffInstance.getInBufferB()->WriteDataRegion(
+      cl_context->command_queue_inst_, dim * sizeof(float), vecXdata);
+    if (!write_result) {
+      return;
+    }
 
-    const int work_groups_count[3] = {dim, 1, 1};
-    /// @todo: create a group size by device & input
-    const int work_group_size[3] = {chosen_local, 1, 1}; // test-value
+    auto bufferInA = clbuffInstance.getInBufferA()->GetBuffer();
+    auto bufferInB = clbuffInstance.getInBufferB()->GetBuffer();
+    auto bufferOutA = clbuffInstance.getOutBufferA()->GetBuffer();
 
-    if (!global_cl_context->command_queue_inst_.DispatchCommand(
-          kernel_swiglu_ptr, work_groups_count, work_group_size)) {
-      ml_loge("Failed to run");
-      break;
+    bool set_result = true;
+    set_result &= kernel->SetKernelArguments(0, &bufferInA, sizeof(cl_mem));
+    set_result &= kernel->SetKernelArguments(1, &bufferInB, sizeof(cl_mem));
+    set_result &= kernel->SetKernelArguments(2, &bufferOutA, sizeof(cl_mem));
+    if (!set_result) {
+      return;
     }
-
-    if (!svm) {
-      if (!clbuffInstance.getOutBufferA()->ReadDataRegion(
-            global_cl_context->command_queue_inst_, dim * sizeof(float),
-            vecYdata)) {
-        break;
-      }
-    } else {
-      if (!global_cl_context->command_queue_inst_.enqueueSVMMap(
-            vecYdata, dim * sizeof(float), true)) {
-        ml_loge("Failed to unmap svm");
-        break;
-      }
+  } else {
+    bool set_svm_result = true;
+    set_svm_result &= kernel->SetKernelSVMArguments(0, matAdata);
+    set_svm_result &= kernel->SetKernelSVMArguments(1, vecXdata);
+    set_svm_result &= kernel->SetKernelSVMArguments(2, vecYdata);
+    if (!set_svm_result) {
+      ml_loge("Failed to set svm");
+      return;
     }
+  }
 
-  } while (false);
+  std::array<size_t, 3> global_work_size = {dim, 1, 1};
+
+  cl_event swiglu_wait;
+
+  if (!cl_context->command_queue_inst_.enqueueKernel(
+        kernel->GetKernel(), global_work_size.size(), global_work_size.data(),
+        nullptr, 0, nullptr, &swiglu_wait)) {
+  }
+
+  cl_context->command_queue_inst_.waitForEvent(1, &swiglu_wait);
+
+  if (!use_svm) {
+    auto &clbuffInstance = ClBufferManager::Global();
+    if (!clbuffInstance.getOutBufferA()->ReadDataRegion(
+          cl_context->command_queue_inst_, dim * sizeof(float), vecYdata)) {
+      return;
+    }
+  }
 }
 
 #ifdef ENABLE_FP16

nntrainer/layers/cl_layers/swiglu_cl.h

@@ -77,7 +77,7 @@ class SwiGLULayerCl final : public LayerImplCl {
    * @copydoc Layer::exportTo(Exporter &exporter, ExportMethods method)
    */
   void exportTo(Exporter &exporter,
-                const ml::train::ExportMethods &method) const override {};
+                const ml::train::ExportMethods &method) const override{};
 
   /**
    * @copydoc Layer::getType()
@@ -106,9 +106,11 @@ class SwiGLULayerCl final : public LayerImplCl {
    * @param[in] vecYdata float * for Output Vector Y
    * @param[in] dim1 number of elements in input vector A
    * @param[in] dim1 number of elements in input vector X
+   * @param[in] use_svm input pointers allocated by OpenCL SVM
    */
   void swiglu_cl(float *matAdata, float *vecXdata, float *vecYdata,
-                 unsigned int dim1, unsigned int dim2, bool svm = false);
+                 unsigned int dim1, unsigned int dim2,
+                 const bool use_svm = false);
 
 #ifdef ENABLE_FP16
   /**

nntrainer/tensor/cl_operations/blas_kernels_templates.h

@@ -398,20 +398,25 @@ inline static void rmsnorm_cl_internal(ClContext::SharedPtrClKernel kernel,
   if (!kernel->SetKernelArguments(5, &width, sizeof(int))) {
     return;
   }
+
 #ifdef __ANDROID__
   constexpr int SUBGROUP_SIZE = 64;
 #else
   constexpr int SUBGROUP_SIZE = 32;
 #endif
-  const int work_groups_count[3] = {static_cast<int>(height) * SUBGROUP_SIZE, 1,
-                                    1};
 
-  const int work_group_size[3] = {SUBGROUP_SIZE, 1, 1};
-  if (!blas_cc->command_queue_inst_.DispatchCommand(kernel, work_groups_count,
-                                                    work_group_size)) {
-    return;
+  std::array<size_t, 3> global_work_size = {height * SUBGROUP_SIZE, 1, 1};
+  std::array<size_t, 3> local_work_size = {SUBGROUP_SIZE, 1, 1};
+
+  cl_event rmsnorm_wait;
+
+  if (!blas_cc->command_queue_inst_.enqueueKernel(
+        kernel->GetKernel(), global_work_size.size(), global_work_size.data(),
+        local_work_size.data(), 0, nullptr, &rmsnorm_wait)) {
   }
 
+  blas_cc->command_queue_inst_.waitForEvent(1, &rmsnorm_wait);
+
   if (!use_svm) {
     auto &clbuffInstance = ClBufferManager::Global();
     if (!clbuffInstance.getOutBufferA()->ReadDataRegion(