cs_base_accel.h

Go to the documentation of this file.

#ifndef __CS_BASE_ACCEL_H__
#define __CS_BASE_ACCEL_H__
 
/*============================================================================
 * Definitions, global variables, and base functions for accelerators.
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2024 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.
*/
 
/*----------------------------------------------------------------------------*/
 
#include "cs_defs.h"
 
/*----------------------------------------------------------------------------
 * Standard C and C++ library headers
 *----------------------------------------------------------------------------*/
 
#include <stdio.h>
 
#if defined(SYCL_LANGUAGE_VERSION)
#include <sycl/sycl.hpp>
#endif
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "bft_mem.h"
 
/*=============================================================================
 * Macro definitions
 *============================================================================*/
 
/*
 * Allocate memory for _ni items of type _type.
 *
 * This macro calls cs_malloc_hd(), automatically setting the
 * allocated variable name and source file name and line arguments.
 *
 * If separate allocations are used on the host and device
 * (mode == CS_ALLOC_HOST_DEVICE), the host pointer is returned.
 *
 * parameters:
 *   _ptr  --> pointer to allocated memory.
 *   _ni   <-- number of items.
 *   _type <-- element type.
 *   _mode <-- allocation mode.
 */
 
#define CS_MALLOC_HD(_ptr, _ni, _type, _mode) \
_ptr = (_type *) cs_malloc_hd(_mode, _ni, sizeof(_type), \
                                   #_ptr, __FILE__, __LINE__)
 
/*
 * Reallocate memory for _ni items of type _type.
 *
 * This macro calls cs_realloc_hd(), automatically setting the
 * allocated variable name and source file name and line arguments.
 *
 * If the allocation parameters are unchanged, no actual reallocation
 * occurs.
 *
 * parameters:
 *   _ptr  <->  pointer to allocated memory.
 *   _ni   <-- number of items.
 *   _type <-- element type.
 *   _mode <-- allocation mode.
 */
 
#define CS_REALLOC_HD(_ptr, _ni, _type, _mode) \
_ptr = (_type *) cs_realloc_hd(_ptr, _mode, _ni, sizeof(_type), \
                               #_ptr, __FILE__, __LINE__)
 
/*
 * Free allocated memory.
 *
 * This macro calls cs_mem_free_any(), automatically setting the
 * allocated variable name and source file name and line arguments.
 *
 * The freed pointer is set to NULL to avoid accidental reuse.
 *
 * If separate allocations are used on the host and device
 * (mode == CS_ALLOC_HOST_DEVICE), the host pointer should be used with this
 * function.
 *
 * parameters:
 *   _ptr  <->  pointer to allocated memory.
 */
 
#define CS_FREE_HD(_ptr) \
cs_free_hd(_ptr, #_ptr, __FILE__, __LINE__), _ptr = NULL
 
/*
 * Free allocated memory.
 *
 * This macro calls cs_mem_free(), automatically setting the
 * allocated variable name and source file name and line arguments.
 *
 * The freed pointer is set to NULL to avoid accidental reuse.
 *
 * If separate allocations are used on the host and device
 * (mode == CS_ALLOC_HOST_DEVICE), the host pointer should be used with this
 * function.
 *
 * parameters:
 *   _ptr  <->  pointer to allocated memory.
 */
 
#define CS_FREE(_ptr) \
cs_free_hd(_ptr, #_ptr, __FILE__, __LINE__), _ptr = NULL
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
/*=============================================================================
 * Global variable definitions
 *============================================================================*/
 
#if defined(HAVE_ACCEL)
 
extern cs_alloc_mode_t  cs_alloc_mode;
extern cs_alloc_mode_t  cs_alloc_mode_read_mostly;
 
extern int cs_mpi_device_support;
 
#else
 
#define cs_alloc_mode CS_ALLOC_HOST
#define cs_alloc_mode_read_mostly CS_ALLOC_HOST
 
#define cs_mpi_device_support 0;
 
#endif
 
#if defined(SYCL_LANGUAGE_VERSION)
extern sycl::queue  cs_glob_sycl_queue;
#endif
 
/*=============================================================================
 * Public C function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
int
cs_get_device_id(void);
 
#else
 
static inline int
cs_get_device_id(void)
{
  return -1;
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void *
cs_malloc_hd(cs_alloc_mode_t   mode,
             size_t            ni,
             size_t            size,
             const char       *var_name,
             const char       *file_name,
             int               line_num);
 
#else
 
inline static void *
cs_malloc_hd(cs_alloc_mode_t   mode,
             size_t            ni,
             size_t            size,
             const char       *var_name,
             const char       *file_name,
             int               line_num)
{
  CS_UNUSED(mode);
  return bft_mem_malloc(ni, size, var_name, file_name, line_num);
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void *
cs_realloc_hd(void            *ptr,
              cs_alloc_mode_t  mode,
              size_t           ni,
              size_t           size,
              const char      *var_name,
              const char      *file_name,
              int              line_num);
 
#else
 
inline static void *
cs_realloc_hd(void             *ptr,
              cs_alloc_mode_t   mode,
              size_t            ni,
              size_t            size,
              const char       *var_name,
              const char       *file_name,
              int               line_num)
{
  CS_UNUSED(mode);
  return bft_mem_realloc(ptr, ni, size, var_name, file_name, line_num);
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_free_hd(void         *ptr,
           const char   *var_name,
           const char   *file_name,
           int           line_num);
 
#else
 
inline static void
cs_free_hd(void         *ptr,
           const char   *var_name,
           const char   *file_name,
           int           line_num)
{
  bft_mem_free(ptr, var_name, file_name, line_num);
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void *
cs_get_device_ptr(void  *ptr);
 
#else
 
inline static void *
cs_get_device_ptr(void  *ptr)
{
  return ptr;
}
 
#endif
 
END_C_DECLS
 
#if defined(__cplusplus) && defined(HAVE_ACCEL)
 
template <class T>
inline const T *restrict
cs_get_device_ptr_const(T *ptr)
{
  const void *ptr_v
    = cs_get_device_ptr(reinterpret_cast<void *>(ptr));
 
  return (const T *restrict)ptr_v;
}
 
#endif // __cplusplus && HAVE_ACCEL
 
BEGIN_C_DECLS
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
const void *
cs_get_device_ptr_const(const void  *ptr);
 
#else
 
inline static const void *
cs_get_device_ptr_const(const void  *ptr)
{
  return ptr;
}
 
#endif
 
END_C_DECLS
 
#if defined(__cplusplus) && defined(HAVE_ACCEL)
 
template <class T>
inline const T *restrict
cs_get_device_ptr_const(const T *ptr)
{
  const void *ptr_v
    = cs_get_device_ptr_const(reinterpret_cast<const void *>(ptr));
 
  return (const T *restrict)ptr_v;
}
 
#endif // __cplusplus && HAVE_ACCEL
 
BEGIN_C_DECLS
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
const void *
cs_get_device_ptr_const_pf(const void  *ptr);
 
#else
 
inline static const void *
cs_get_device_ptr_const_pf(const void  *ptr)
{
  return ptr;
}
 
#endif
 
END_C_DECLS
 
#if defined(__cplusplus) && defined(HAVE_ACCEL)
 
template <class T>
inline const T *restrict
cs_get_device_ptr_const_pf(const T *ptr)
{
  const void *ptr_v
    = cs_get_device_ptr_const_pf(reinterpret_cast<const void *>(ptr));
 
  return (const T *restrict)ptr_v;
}
 
#endif // __cplusplus && HAVE_ACCEL
 
BEGIN_C_DECLS
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
cs_alloc_mode_t
cs_check_device_ptr(const void  *ptr);
 
#else
 
inline static cs_alloc_mode_t
cs_check_device_ptr(const void  *ptr)
{
  CS_UNUSED(ptr);
  return CS_ALLOC_HOST;
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void *
cs_associate_device_ptr(void    *host_ptr,
                        size_t   ni,
                        size_t   size);
 
#else
 
#define cs_associate_device_ptr(_host_ptr, _ni, _size);
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_disassociate_device_ptr(void  *host_ptr);
 
#else
 
#define cs_disassociate_device_ptr(_host_ptr);
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_set_alloc_mode(void             **host_ptr,
                  cs_alloc_mode_t     mode);
 
#else
 
#define cs_set_alloc_mode(_host_ptr, mode);
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_mem_advise_set_read_mostly(void  *ptr);
 
#else
 
#define cs_mem_advise_set_read_mostly(ptr);
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_mem_advise_unset_read_mostly(void  *ptr);
 
#else
 
#define cs_mem_advise_unset_read_mostly(ptr);
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_sync_h2d(const void  *ptr);
 
#else
 
static inline void
cs_sync_h2d(const void  *ptr)
{
  CS_UNUSED(ptr);
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_sync_h2d_future(const void  *ptr);
 
#else
 
static inline void
cs_sync_h2d_future(const void  *ptr)
{
  CS_UNUSED(ptr);
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_sync_d2h(void  *ptr);
 
#else
 
static inline void
cs_sync_d2h(void  *ptr)
{
  CS_UNUSED(ptr);
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_sync_d2h_if_needed(void  *ptr);
 
#else
 
static inline void
cs_sync_d2h_if_needed(void  *ptr)
{
  CS_UNUSED(ptr);
}
 
#endif
 
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_prefetch_h2d(void    *ptr,
                size_t   size);
 
#else
 
static inline void
cs_prefetch_h2d(void    *ptr,
                size_t   size)
{
  CS_UNUSED(ptr);
  CS_UNUSED(size);
}
 
#endif
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
void
cs_prefetch_d2h(void    *ptr,
                size_t   size);
 
#else
 
static inline void
cs_prefetch_d2h(void    *ptr,
                size_t   size)
{
  CS_UNUSED(ptr);
  CS_UNUSED(size);
}
 
#endif
 
#if defined(HAVE_ACCEL)
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_copy_h2d(void        *dest,
            const void  *src,
            size_t       size);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_copy_d2h(void        *dest,
            const void  *src,
            size_t       size);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_copy_d2d(void        *dest,
            const void  *src,
            size_t       size);
 
#endif /* defined(HAVE_ACCEL) */
 
#if defined(HAVE_OPENMP_TARGET)
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_omp_target_select_default_device(void);
 
#endif /* defined(HAVE_OPENMP_TARGET) */
 
#if defined(HAVE_SYCL)
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_sycl_select_default_device(void);
 
#endif
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
/*=============================================================================
 * Public C++ function prototypes and definitions.
 *============================================================================*/
 
#ifdef __cplusplus
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
#if defined(HAVE_ACCEL)
 
template<typename T>
static inline void
cs_set_alloc_mode_r(T*                &host_ptr,
                    cs_alloc_mode_t    mode)
{
  void *p = host_ptr;
  cs_set_alloc_mode(&p, mode);
  host_ptr = (T *)p;
}
 
#else
 
#define cs_set_alloc_mode_r(_host_ptr, mode);
 
#endif
 
/*----------------------------------------------------------------------------*/
 
#endif /* defined(__cplusplus) */
 
#endif /* __CS_BASE_ACCEL_H__ */