cs_array_hip.h

Go to the documentation of this file.

#include "hip/hip_runtime.h"
/*============================================================================
 * Array handling utilities.
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2026 EDF S.A.
 
  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
  Foundation; either version 2 of the License, or (at your option) any later
  version.
 
  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  details.
 
  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
  Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 * Standard C and C++ library headers
 *----------------------------------------------------------------------------*/
 
#include <string.h>
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "base/cs_defs.h"
#include "base/cs_base_hip.h"
 
/*----------------------------------------------------------------------------*/
 
/*=============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/*=============================================================================
 * Public inline function prototypes
 *============================================================================*/
 
/*=============================================================================
 * Public function prototypes
 *============================================================================*/
 
/* Default kernel that loops over an integer range and calls a device functor.
   This kernel uses a grid_size-stride loop and thus guarantees that all
   integers are processed, even if the grid is smaller.
   All arguments *must* be passed by value to avoid passing CPU references
   to the GPU. */
 
template <typename T, size_t stride>
__global__ void
hip_kernel_set_value(cs_lnum_t    n,
                      const T      ref_val,
                      const int    size_arrs,
                      T          **array_ptrs)
{
  // grid_size-stride loop
  for (cs_lnum_t id = blockIdx.x * blockDim.x + threadIdx.x; id < n;
       id += blockDim.x * gridDim.x) {
    for (int j = 0; j < size_arrs; j++) {
      for (size_t k = 0; k < stride; k++) {
        array_ptrs[j][id*stride + k] = ref_val;
      } // end loop stride
    }
  } // end loop arrays
}
 
template <typename T, size_t stride>
__global__ void
hip_kernel_set_value(cs_lnum_t    n,
                      const T     *ref_val,
                      const int    size_arrs,
                      T          **array_ptrs)
{
  // grid_size-stride loop
  for (cs_lnum_t id = blockIdx.x * blockDim.x + threadIdx.x; id < n;
       id += blockDim.x * gridDim.x) {
    for (int j = 0; j < size_arrs; j++) {
      for (size_t k = 0; k < stride; k++) {
        array_ptrs[j][id*stride + k] = ref_val[k];
      } // end loop stride
    }
  } // end loop arrays
}
 
template <typename T, size_t stride>
__global__ void
hip_kernel_set_value(cs_lnum_t   n,
                      const T     ref_val,
                      T          *array)
{
  // grid_size-stride loop
  for (cs_lnum_t id = blockIdx.x * blockDim.x + threadIdx.x; id < n;
       id += blockDim.x * gridDim.x) {
    for (size_t k = 0; k < stride; k++) {
      array[id*stride + k] = ref_val;
    } // end loop stride
  } // end loop arrays
}
 
template <typename T, size_t stride>
__global__ void
hip_kernel_set_value(cs_lnum_t   n,
                      const T    *ref_val,
                      T          *array)
{
  // grid_size-stride loop
  for (cs_lnum_t id = blockIdx.x * blockDim.x + threadIdx.x; id < n;
       id += blockDim.x * gridDim.x) {
    for (size_t k = 0; k < stride; k++) {
      array[id*stride + k] = *ref_val;
    } // end loop stride
  } // end loop arrays
}
 
template <typename T, size_t stride>
__global__ void
cs_hip_kernel_set_zero(cs_lnum_t   n,
                        T          *array)
{
  T c = static_cast<T>(0);
 
  // grid_size-stride loop
  for (cs_lnum_t id = blockIdx.x * blockDim.x + threadIdx.x; id < n;
       id += blockDim.x * gridDim.x) {
    for (size_t k = 0; k < stride; k++) {
      array[id*stride + k] = c;
    } // end loop stride
  } // end loop arrays
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template <typename T, size_t stride, typename... Arrays>
void
cs_arrays_set_value(hipStream_t     stream,
                    bool             async,
                    cs_lnum_t        n_elts,
                    T               *ref_val,
                    Arrays&&...      arrays)
{
  const long block_size_ = 256;
  const long grid_size_ = (n_elts % block_size_) ?
                           n_elts/block_size_ + 1 : n_elts/block_size_;
 
  /* Explicit expansion of arrays */
  const int size_arrs = sizeof...(arrays);
  T* _array_ptrs[] = {arrays ...};
 
  if (size_arrs > 1) {
    hipGraph_t graph;
    hipGraphExec_t graph_exec = NULL;
 
    CS_HIP_CHECK(hipStreamBeginCapture(stream, hipStreamCaptureModeGlobal));
    for (int j = 0; j < size_arrs; j++) {
      hip_kernel_set_value<T, stride><<<grid_size_, block_size_, 0, stream>>>
        (n_elts, ref_val, _array_ptrs[j]);
    }
    CS_HIP_CHECK(hipStreamEndCapture(stream, &graph));
 
    CS_HIP_CHECK(hipGraphInstantiate(&graph_exec, graph,
                                     nullptr, nullptr, 0));
    CS_HIP_CHECK(hipGraphLaunch(graph_exec, stream));
 
    /* For multiple arrays, sync even if async is required,
       to ensure the graph is not destroyed before all kernels
       are scheduled */
 
    CS_HIP_CHECK(hipStreamSynchronize(stream));
    CS_HIP_CHECK(hipGetLastError());
 
    CS_HIP_CHECK(hipGraphDestroy(graph));
    CS_HIP_CHECK(hipGraphExecDestroy(graph_exec));
  }
 
  else {
    hip_kernel_set_value<T, stride><<<grid_size_, block_size_, 0, stream>>>
      (n_elts, ref_val, _array_ptrs[0]);
 
    if (async == false) {
      CS_HIP_CHECK(hipStreamSynchronize(stream));
      CS_HIP_CHECK(hipGetLastError());
    }
  }
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template <typename T, size_t stride, typename... Arrays>
void
cs_arrays_set_value(hipStream_t     stream,
                    bool             async,
                    cs_lnum_t        n_elts,
                    T                ref_val,
                    Arrays&&...      arrays)
{
  const long block_size_ = 256;
  const long grid_size_ = (n_elts % block_size_) ?
                           n_elts/block_size_ + 1 : n_elts/block_size_;
 
  /* Explicit expansion of arrays */
  const int size_arrs = sizeof...(arrays);
  T* _array_ptrs[] = {arrays ...};
 
  if (size_arrs > 1) {
    hipGraph_t graph;
    hipGraphExec_t graph_exec = NULL;
 
    CS_HIP_CHECK(hipStreamBeginCapture(stream, hipStreamCaptureModeGlobal));
 
    for (int j = 0; j < size_arrs; j++) {
      hip_kernel_set_value<T, stride><<<grid_size_, block_size_, 0, stream>>>
        (n_elts, ref_val, _array_ptrs[j]);
    }
    CS_HIP_CHECK(hipStreamEndCapture(stream, &graph));
 
    CS_HIP_CHECK(hipGraphInstantiate(&graph_exec, graph,
                                     nullptr, nullptr, 0));
    CS_HIP_CHECK(hipGraphLaunch(graph_exec, stream));
 
    /* For multiple arrays, sync even if async is required,
       to ensure the graph is not destroyed before all kernels
       are scheduled */
 
    CS_HIP_CHECK(hipStreamSynchronize(stream));
    CS_HIP_CHECK(hipGetLastError());
 
    CS_HIP_CHECK(hipGraphDestroy(graph));
    CS_HIP_CHECK(hipGraphExecDestroy(graph_exec));
  }
 
  else {
    hip_kernel_set_value<T, stride><<<grid_size_, block_size_, 0, stream>>>
      (n_elts, ref_val, _array_ptrs[0]);
 
    if (async == false) {
      CS_HIP_CHECK(hipStreamSynchronize(stream));
      CS_HIP_CHECK(hipGetLastError());
    }
  }
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template <typename T, size_t stride, typename... Arrays>
void
cs_arrays_set_zero(hipStream_t     stream,
                   bool             async,
                   cs_lnum_t        n_elts,
                   Arrays&&...      arrays)
{
  const long block_size_ = 256;
  const long grid_size_ = (n_elts % block_size_) ?
                           n_elts/block_size_ + 1 : n_elts/block_size_;
 
  /* Explicit expansion of arrays */
  const int size_arrs = sizeof...(arrays);
  T* _array_ptrs[] = {arrays ...};
 
  if (size_arrs > 1) {
    hipGraph_t graph;
    hipGraphExec_t graph_exec = NULL;
 
    CS_HIP_CHECK(hipStreamBeginCapture(stream, hipStreamCaptureModeGlobal));
    for (int j = 0; j < size_arrs; j++) {
      cs_hip_kernel_set_zero<T, stride><<<grid_size_, block_size_, 0, stream>>>
        (n_elts, _array_ptrs[j]);
    }
    CS_HIP_CHECK(hipStreamEndCapture(stream, &graph));
 
    CS_HIP_CHECK(hipGraphInstantiate(&graph_exec, graph,
                                     nullptr, nullptr, 0));
    CS_HIP_CHECK(hipGraphLaunch(graph_exec, stream));
 
    /* For multiple arrays, sync even if async is required,
       to ensure the graph is not destroyed before all kernels
       are scheduled */
 
    CS_HIP_CHECK(hipStreamSynchronize(stream));
    CS_HIP_CHECK(hipGetLastError());
 
    CS_HIP_CHECK(hipGraphDestroy(graph));
    CS_HIP_CHECK(hipGraphExecDestroy(graph_exec));
  }
 
  else {
    cs_hip_kernel_set_zero<T, stride><<<grid_size_, block_size_, 0, stream>>>
      (n_elts, _array_ptrs[0]);
 
    if (async == false) {
      CS_HIP_CHECK(hipStreamSynchronize(stream));
      CS_HIP_CHECK(hipGetLastError());
    }
  }
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template <typename T>
void
cs_array_copy(hipStream_t     stream,
              bool             async,
              const cs_lnum_t  size,
              const T*         src,
              T*               dest)
{
  CS_HIP_CHECK(hipMemcpyAsync(dest, src, size*sizeof(T),
                              hipMemcpyDeviceToDevice, stream));
  if (async == false) {
    CS_HIP_CHECK(hipStreamSynchronize(stream));
    CS_HIP_CHECK(hipGetLastError());
  }
}
 
/*----------------------------------------------------------------------------*/