cs_defs.h

Go to the documentation of this file.

#ifndef CS_DEFS_H
#define CS_DEFS_H
 
/*============================================================================
 * Base macro and typedef definitions for system portability
 *============================================================================*/
 
/*
  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.
*/
 
/*----------------------------------------------------------------------------*/
 
/*============================================================================
 * Autoconf-defined macros
 *============================================================================*/
 
#if defined(HAVE_CONFIG_H)
#  include "base/cs_config.h"
#endif
 
#include <type_traits>
#include <utility>
 
/*============================================================================
 * Internationalization
 *============================================================================*/
 
extern "C" {
 
#if defined(ENABLE_NLS) && defined(HAVE_GETTEXT)
 
#  include <libintl.h>
#  define _(String) dgettext(PACKAGE, String)
#  ifdef gettext_noop
#    define N_(String) gettext_noop(String)
#  else
#    define N_(String) String
#  endif /* gettext_noop */
 
#else
 
#  define _LIBINTL_H /* Prevent inclusion of <libintl.h> by other files
                        with incorrect or missing checks;
                        TODO locate files causing issues to avoid
                        requiring this workaround */
 
#  define _(String) (String)
#  define N_(String) String
#  define textdomain(String) (String)
#  define gettext(String) (String)
#  define dgettext(Domain,String) (String)
#  define dcgettext(Domain,String,Type) (String)
#  define bindtextdomain(Domain, Directory) (Domain)
 
#endif /* ENABLE_NLS && HAVE_GETTEXT */
 
}
 
/*============================================================================
 * Parallelism
 *============================================================================*/
 
#if defined(HAVE_MPI) && !defined(CS_IGNORE_MPI)
 
#  include <mpi.h>
 
#  if !defined(MPI_VERSION) /* Defined in up-to-date MPI versions */
#    define MPI_VERSION 1
#  endif
 
#  if MPI_VERSION == 1
#    define MPI_Info       int
#    define MPI_INFO_NULL  0
#  endif
 
#endif
 
#if defined(HAVE_OPENMP)
 
#  include <omp.h>
 
#if _OPENMP >= 201307     /* simd construct available from OpenMP 4.0 */
#undef HAVE_OPENMP_SIMD
#define HAVE_OPENMP_SIMD 1
#endif
 
#else
 
// The compiler may sometimes use OpenMP in adapters to external libraries
// even when OpenMP is disabled for code_saturne due to propagation of
// compiler flags for external libraries. Filtering those flags would
// be complex with the current build system, so here the macro
// defined directly by the compiler is disabled. Note that this could affect
// external including calls to code_saturne, so a filtering of compiler
// flags would be preferrable.
#undef _OPENMP
 
#endif
 
/* Do we have accelerator support ? */
 
#if defined(HAVE_CUDA)
#define HAVE_ACCEL 1
#elif defined(HAVE_HIP)
#define HAVE_ACCEL 1
#elif defined(HAVE_SYCL)
#define HAVE_ACCEL 1
#elif defined(HAVE_OPENMP_TARGET)
#define HAVE_ACCEL 1
#endif
 
/*----------------------------------------------------------------------------
 * Accelerator stream definitions
 *----------------------------------------------------------------------------*/
 
#if defined(HAVE_CUDA) && defined(__CUDACC__)
using cs_stream_t = cudaStream_t;
#elif defined(HAVE_HIP) && defined(__HIPCC__)
using cs_stream_t = hipStream_t;
#else
using cs_stream_t = void *;
#endif
 
/*============================================================================
 * Qualifiers and macros
 *============================================================================*/
 
#  if defined(__GNUC__) || defined(__clang__) || defined (__NVCC__)
#    define restrict __restrict__
#  elif defined(_MSC_VER)
#    define restrict __restrict
#  else
#    ifndef HAVE_RESTRICT /* Must be provided by caller */
#      define restrict
#    endif
#  endif
 
/* Macros for locally suppressing warnings from external libraries */
#if (defined(__GNUC__) || defined(__clang__)) \
  && !defined(CS_DONT_SUPPRESS_EXTERNAL_WARNINGS)
#  define DO_PRAGMA(x) _Pragma (#x)
#  define DISABLE_WARNING_PUSH _Pragma("GCC diagnostic push")
#  define DISABLE_WARNING(warningName) \
     DO_PRAGMA(GCC diagnostic ignored #warningName)
#  define DISABLE_WARNING_POP _Pragma("GCC diagnostic pop")
// Define LLVM only warnings suppression (needed for clang/oneapi compilers
#  if defined(__llvm__)
#     define DISABLE_WARNING_LLVM(warningName) \
        DISABLE_WARNING(warningName)
#  else
#     define DISABLE_WARNING_LLVM(warningName)
#  endif
#else
#  define DISABLE_WARNING_PUSH
#  define DISABLE_WARNING(warningName)
#  define DISABLE_WARNING_POP
#  define DISABLE_WARNING_LLVM(warningName)
#endif
 
/*============================================================================
 * Definitions that may not always be provided directly by the system
 *============================================================================*/
 
/*
 * Obtain definitions such as that of size_t through stddef.h (C99 standard)
 * if available (preferred method), or through stdlib.h (which defines
 * malloc() and family and so must define size_t some way) otherwise.
 */
 
#if HAVE_STDDEF_H
#  include <stddef.h>
#else
#  include <stdlib.h>
#endif
 
/*
 * Usually stdint.h is included by inttypes.h, but only inttypes.h exists
 * on certain systems, such as Tru64Unix.
 */
 
#if HAVE_STDINT_H
#  include <stdint.h>
#elif HAVE_INTTYPES_H
#  include <inttypes.h>
#endif
 
/*
 * Obtain the definition of off_t.
 */
 
#if defined(HAVE_SYS_TYPES_H)
#include <sys/types.h>
#endif
 
/* C++ assert necessary for template */
#include <typeinfo>
#include "assert.h"
 
/* int32_t type */
 
#if !defined(HAVE_INT32_T)
#  if (SIZEOF_INT == 4)
typedef int int32_t;
#  elif (SIZEOF_SHORT == 4)
typedef short int32_t;
#  else
#    error
#  endif
#endif
 
/* int64_t type */
 
#if !defined(HAVE_INT64_T)
#  if (SIZEOF_INT == 8)
typedef int int64_t;
#  elif (SIZEOF_LONG == 8)
typedef long int64_t;
#  elif (HAVE_LONG_LONG == 8)  /* SIZEOF_LONG_LONG not generally available */
typedef long long int64_t;
#  else
#    error
#  endif
#endif
 
/* uint32_t type */
 
#if !defined(HAVE_UINT32_T)
#  if (SIZEOF_INT == 4)
typedef unsigned uint32_t;
#  elif (SIZEOF_SHORT == 4)
typedef unsigned short uint32_t;
#  else
#    error
#  endif
#endif
 
/* uint64_t type */
 
#if !defined(HAVE_UINT64_T)
#  if (SIZEOF_INT == 8)
typedef unsigned uint64_t;
#  elif (SIZEOF_LONG == 8)
typedef unsigned long uint64_t;
#  elif (HAVE_LONG_LONG) /* SIZEOF_LONG_LONG not generally available */
typedef unsigned long long uint64_t;
#  else
#    error
#  endif
#endif
 
/* __has_builtin is missing in some cases (e.g. nvcc) */
 
#ifndef __has_builtin
  #define __has_builtin(x) 0
#endif
 
/* Legacy Intel compiler (retired) reports having
 *  __builtin_FILE() and __builtin_LINE() but generates code calling
 *  nonexisting functions with those names, leading to link errors. */
#if defined(__INTEL_COMPILER)
#  if __INTEL_COMPILER <= 2000
#    define __has_builtin(x) 0
#  endif
#endif
 
/*============================================================================
 * General types and macros used throughout code_saturne
 *============================================================================*/
 
extern "C" {
 
/*----------------------------------------------------------------------------
 * Variable value type.
 *----------------------------------------------------------------------------*/
 
typedef enum {
 
  CS_DATATYPE_NULL,      /* empty datatype */
  CS_CHAR,               /* character values */
  CS_FLOAT,              /* 4-byte floating point values */
  CS_DOUBLE,             /* 8-byte floating point values */
  CS_UINT16,             /* 2-byte unsigned integer values */
  CS_INT32,              /* 4-byte signed integer values */
  CS_INT64,              /* 8-byte signed integer values */
  CS_UINT32,             /* 4-byte unsigned integer values */
  CS_UINT64              /* 8-byte unsigned integer values */
 
} cs_datatype_t;
 
/*----------------------------------------------------------------------------
 * Basic types used by code_saturne
 * They may be modified here to better map to a given library, with the
 * following constraints:
 *  - cs_lnum_t must be signed
 *  - cs_gnum_t may be signed or unsigned
 *----------------------------------------------------------------------------*/
 
/* Global integer index or number */
 
#if defined(HAVE_LONG_GNUM)
  typedef uint64_t  cs_gnum_t;
#else
  typedef unsigned  cs_gnum_t;
#endif
 
/* Local integer index or number */
 
#if defined(HAVE_LONG_LNUM)
  typedef int64_t  cs_lnum_t;
#else
  typedef int  cs_lnum_t;
#endif
 
/* Other types */
 
typedef double              cs_coord_t;   /* Real number (coordinate value) */
 
typedef double              cs_real_t;   /* Fortran double precision */
typedef char                cs_byte_t;   /* Byte (untyped memory unit) */
typedef unsigned short int  cs_flag_t;   /* Flag storing metadata */
 
typedef double              cs_nreal_t;  /* Real number (normalized value) */
typedef double              cs_dreal_t;  /* Local distance */
typedef double              cs_rreal_t;  /* Reconstruction distance */
 
/* Vector or array block types */
 
typedef cs_lnum_t  cs_lnum_2_t[2];      /* Vector of 2 local numbers */
typedef cs_lnum_t  cs_lnum_3_t[3];      /* Vector of 3 local numbers */
 
typedef cs_coord_t cs_coord_3_t[3];         /* Vector of 3 real (coordinate)
                                               values */
 
typedef cs_real_t  cs_real_2_t[2];          /* Vector of 2 real values */
typedef cs_real_t  cs_real_3_t[3];          /* Vector of 3 real values */
typedef cs_real_t  cs_real_4_t[4];          /* Vector of 4 real values */
typedef cs_real_t  cs_real_6_t[6];          /* Vector of 6 real values
                                               (for symmetric tensor) */
typedef cs_real_t  cs_real_9_t[9];          /* Vector of 9 real values */
typedef cs_real_t  cs_real_10_t[10];        /* Vector of 10 real values */
 
typedef cs_real_t  cs_real_23_t[2][3];      /* Matrix of 2x3 real values */
 
typedef cs_real_t  cs_real_33_t[3][3];      /* Matrix of 3x3 real values */
typedef cs_real_t  cs_real_66_t[6][6];      /* Matrix of 6x6 real values */
typedef cs_real_t  cs_real_99_t[9][9];      /* Matrix of 9x9 real values */
 
typedef cs_real_t  cs_real_333_t[3][3][3];  /* tensor of 3x3x3 real values */
 
typedef cs_real_t  cs_real_34_t[3][4];      /* Matrix of 3x4 real values */
 
typedef cs_real_t  cs_real_63_t[6][3];      /* Matrix of 6x3 real values */
 
typedef cs_real_t  cs_real_69_t[6][9];      /* Matrix of 6x9 real values */
 
typedef cs_real_33_t  cs_real_332_t[2];     /* vector of 2 3x3 matrices
                                               of real values */
typedef cs_real_66_t  cs_real_662_t[2];     /* vector of 2 6x6 matrices
                                               of real values */
 
typedef cs_nreal_t  cs_nreal_3_t[3];        /* Vector of normalized real values
                                               (i.e. unit vector) */
typedef cs_dreal_t  cs_dreal_3_t[3];        /* Vector joining 2 local coordinates */
typedef cs_rreal_t  cs_rreal_3_t[3];        /* Reconstruction distance Vector */
 
typedef struct {
 
  double   val;  /* Value */
  int      id;   /* Id related to value */
 
} cs_double_int_t;
 
/* Vector-valued quantity stored using its measure (i.e. length) and
   its direction given by a unitary vector */
 
typedef struct {
 
  double  meas;
  double  unitv[3];
 
} cs_nvec3_t;
 
/* Mappings to MPI datatypes */
/*---------------------------*/
 
#if defined(HAVE_MPI) && !defined(CS_IGNORE_MPI)
 
#  define CS_MPI_REAL      MPI_DOUBLE      /* If cs_real_t is a double */
 
/* MPI type for cs_gnum_t integer type (depends on configuration) */
 
#  if defined(HAVE_LONG_GNUM)
#    if (SIZEOF_LONG == 8)
#      define CS_MPI_GNUM     MPI_UNSIGNED_LONG
#    elif (SIZEOF_LONG_LONG == 8)
#      if defined(MPI_UNSIGNED_LONG_LONG)
#        define CS_MPI_GNUM     MPI_UNSIGNED_LONG_LONG
#      elif defined(MPI_LONG_LONG)
#        define CS_MPI_GNUM     MPI_LONG_LONG
#      endif
#    endif
#    if !defined(CS_MPI_GNUM)
#      error
#    endif
#  else
#    define CS_MPI_GNUM       MPI_UNSIGNED
#  endif
 
/* MPI type for cs_lnum_t type */
 
#  if defined(HAVE_LONG_LNUM)
#    define CS_MPI_LNUM     MPI_LONG
#  else
#    define CS_MPI_LNUM     MPI_INT
#  endif
 
#  define CS_MPI_EFLAG    MPI_UNSIGNED       /* MPI type for cs_mflag_t type */
#  define CS_MPI_FLAG     MPI_UNSIGNED_SHORT /* MPI type for cs_flag_t type */
#  define CS_MPI_COORD    MPI_DOUBLE         /* MPI type for cs_coord_t type */
 
#endif /* defined(HAVE_MPI) && !defined(CS_IGNORE_MPI) */
 
/* Mappings to code_saturne datatypes */
/*------------------------------------*/
 
#if defined(HAVE_LONG_GNUM)
# define CS_GNUM_TYPE     CS_UINT64
#elif (SIZEOF_INT == 8)
# define CS_GNUM_TYPE     CS_UINT64
#else
# define CS_GNUM_TYPE     CS_UINT32
#endif
 
#if defined(HAVE_LONG_LNUM)
# if (SIZEOF_LONG == 8)
#  define CS_LNUM_TYPE     CS_INT64
# else
#  define CS_LNUM_TYPE     CS_INT32
# endif
#else
# if (SIZEOF_INT == 8)
#  define CS_LNUM_TYPE     CS_INT64
# else
#  define CS_LNUM_TYPE     CS_INT32
# endif
#endif
 
#if (SIZEOF_INT == 8)
# define CS_INT_TYPE      CS_INT64
#else
# define CS_INT_TYPE      CS_INT32
#endif
 
#if (SIZEOF_INT == 8)
# define CS_UINT_TYPE     CS_UINT64
#else
# define CS_UINT_TYPE     CS_UINT32
#endif
 
#define CS_FLAG_TYPE      CS_UINT16
#define CS_EFLAG_TYPE     CS_UINT_TYPE
#define CS_REAL_TYPE      CS_DOUBLE
#define CS_COORD_TYPE     CS_DOUBLE
 
/* Minimum size for OpenMP loops
 *  (will need benchmarking and tuning for various systems)
 *---------------------------------------------------------*/
 
#define CS_THR_MIN 128
 
/* Cache line size, or multiple thereof */
/*--------------------------------------*/
 
#define CS_CL_SIZE 64
 
/*----------------------------------------------------------------------------
 * Type independent min an max (caution: the argument is evaluated)
 *----------------------------------------------------------------------------*/
 
#define CS_ABS(a)     ((a) <  0  ? -(a) : (a))  
#define CS_MIN(a,b)   ((a) < (b) ?  (a) : (b))  
#define CS_MAX(a,b)   ((a) > (b) ?  (a) : (b))  
/*----------------------------------------------------------------------------
 * Variable interlace type:
 * {x1, y1, z1, x2, y2, z2, ...,xn, yn, zn} if interlaced
 * {x1, x2, ..., xn, y1, y2, ..., yn, z1, z2, ..., zn} if non interlaced
 *----------------------------------------------------------------------------*/
 
typedef enum {
 
  CS_INTERLACE,          /* Variable is interlaced */
  CS_NO_INTERLACE        /* Variable is not interlaced */
 
} cs_interlace_t;
 
/*----------------------------------------------------------------------------
 * Macro used to silence "unused argument" warnings.
 *
 * This is useful when a function must match a given function pointer
 * type, but does not use all possible arguments.
 *----------------------------------------------------------------------------*/
 
#define CS_UNUSED(x) (void)(x)
#define CS_NO_WARN_IF_UNUSED(x) (void)(x)
 
/*----------------------------------------------------------------------------
 * Macros for compilation with a C++ compiler
 *----------------------------------------------------------------------------*/
 
#undef BEGIN_C_DECLS
#undef   END_C_DECLS
 
#define BEGIN_C_DECLS  extern "C" {
#define   END_C_DECLS  }
 
/*----------------------------------------------------------------------------
 * Macro to check if we are compiling for device
 *----------------------------------------------------------------------------*/
 
#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__) \
  || defined(__SYCL_DEVICE_ONLY__)
#define CS_DEVICE_COMPILE
#endif
 
/*----------------------------------------------------------------------------
 * Macros for function type qualifiers
 *----------------------------------------------------------------------------*/
 
#if defined(__CUDACC__) || defined (__HIP_DEVICE_COMPILE__)
 
#define CS_F_HOST __host__
#define CS_F_DEVICE __device__
#define CS_F_HOST_DEVICE __host__ __device__
#define CS_V_CONSTANT __constant__
 
#else
 
#define CS_F_HOST
#define CS_F_DEVICE
#define CS_F_HOST_DEVICE
#define CS_V_CONSTANT static const
 
#endif
 
/*----------------------------------------------------------------------------
 * Macros for lambda specifiers
 *----------------------------------------------------------------------------*/
 
#define CS_LAMBDA [=] CS_F_HOST_DEVICE
#define CS_HOST_LAMBDA [=] CS_F_HOST
#define CS_CLASS_LAMBDA [=, *this] CS_F_HOST_DEVICE
 
/*=============================================================================
 * Global variables
 *============================================================================*/
 
/* Empty but non-null string */
 
extern const char     cs_empty_string[];
 
/* Sizes and names associated with datatypes */
 
extern const size_t   cs_datatype_size[];
extern const char    *cs_datatype_name[];
 
/* MPI Datatypes associated with code_saturne datatypes */
 
#if defined(HAVE_MPI) && !defined(CS_IGNORE_MPI)
 
extern MPI_Datatype   cs_datatype_to_mpi[];
 
#endif
 
/* Global variables indicating task state */
 
extern int  cs_glob_n_threads;     /* Number of threads */
 
extern int  cs_glob_rank_id;       /* Rank in main MPI communicator */
extern int  cs_glob_n_ranks;       /* Size of main MPI communicator */
 
extern int  cs_glob_node_rank_id;  /* Rank on node in main MPI communicator */
extern int  cs_glob_node_n_ranks;  /* Number of ranks on node of main
                                      MPI communicator */
 
#if defined(HAVE_MPI) && !defined(CS_IGNORE_MPI)
 
extern MPI_Comm       cs_glob_mpi_comm;      /* Main MPI intra-communicator */
 
#endif
 
/*----------------------------------------------------------------------------
 * Function pointer types
 *----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
typedef void *
(cs_destructor_t)(void  *s);
 
/*=============================================================================
 * Public functions
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*
 * \brief  Given a base index i, return the next index aligned with a size m.
 *
 * \param[in]  i   base index
 * \param[in]  m   block size to align with
 *
 * \return aligned index
 */
/*----------------------------------------------------------------------------*/
 
inline static cs_lnum_t
cs_align(cs_lnum_t  i,
         cs_lnum_t  m)
{
  return ((i > 0) ? ((i-1)/m+1)*m : 0);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
inline static int
cs_get_thread_id(void)
{
#if defined(HAVE_OPENMP)
  return omp_get_thread_num();
#else
  return 0;
#endif
}
 
/*----------------------------------------------------------------------------*/
 
}  // extern "C"
 
/*=============================================================================
 * Public C++ templates
 *============================================================================*/
 
namespace cs {
 
/*----------------------------------------------------------------------------*/
/*
 * \brief  Return absolute value of a number.
 *
 * This function is overloaded in cs_math.h for floating-point values.
 *
 * \tparam T value type
 *
 * \param[in]  a  value
 *
 * \return absolute value of a
 */
/*----------------------------------------------------------------------------*/
 
template <typename T>
CS_F_HOST_DEVICE inline T
abs(const T  a)
{
  return ((a) <  0  ? -(a) : (a));
}
 
/*----------------------------------------------------------------------------*/
/*
 * \brief  Return minimum of two values.
 *
 * This function is overloaded in cs_math.h for floating-point values.
 *
 * \tparam T value type
 *
 * \param[in]  a   first value
 * \param[in]  b   second value
 *
 * \return minimum of a and b
 */
/*----------------------------------------------------------------------------*/
 
template <typename T>
CS_F_HOST_DEVICE inline T
min(const T  a,
    const T  b)
{
  return ((a) < (b) ?  (a) : (b));
}
 
/*----------------------------------------------------------------------------*/
/*
 * \brief  Return maximum of two values.
 *
 * This function is overloaded in cs_math.h for floating-point values.
 *
 * \tparam T value type
 *
 * \param[in]  a   first value
 * \param[in]  b   second value
 *
 * \return maximum of a and b
 */
/*----------------------------------------------------------------------------*/
 
template <typename T>
CS_F_HOST_DEVICE inline T
max(const T  a,
    const T  b)
{
  return ((a) > (b) ?  (a) : (b));
}
 
/*----------------------------------------------------------------------------*/
/*
 * \brief Clamp function for a given scalar value.
 *
 * This function is overloaded in cs_math.h for floating-point values.
 *
 * \tparam T value type
 *
 * \param[in] x    initial value
 * \param[in] xmin min value for clamping
 * \param[in] xmax max value for clamping
 *
 * \return clamped value which is 'x' if xmin < x < xmax or lower/upper bound
 * otherwise
 */
/*----------------------------------------------------------------------------*/
 
template <typename T>
CS_F_HOST_DEVICE inline T
clamp(const T x,
      const T xmin,
      const T xmax)
{
  T x_tmp = ((xmin) > (x) ?  (xmin) : (x));
  return ((xmax) < (x_tmp) ?  (xmax) : (x_tmp));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template <class... Args>
struct are_integral {
  enum : bool { value = true};
};
 
/*----------------------------------------------------------------------------*/
 
template <typename T, class... Args>
struct are_integral<T, Args...> {
  enum {
    value = (std::is_integral<T>::value || std::is_enum<T>::value)
          && are_integral<Args...>::value
  };
};
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template <typename... Args>
struct always_true : std::true_type {};
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
template <class T>
CS_F_HOST_DEVICE
constexpr
std::enable_if_t<std::is_move_constructible<T>::value &&
                 std::is_move_assignable<T>::value>
swap_objects
(
  T& obj1, 
  T& obj2  
)
{
  T tmp(std::move(obj1));
  obj1 = std::move(obj2);
  obj2 = std::move(tmp);
}
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
template <class T, std::size_t N>
CS_F_HOST_DEVICE
constexpr
void
swap_objects
(
  T (&obj1)[N], 
  T (&obj2)[N]  
)
{
  for (std::size_t i = 0; i < N; ++i)
    swap_objects(obj1[i], obj2[i]);
}
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
template<typename Id1>
CS_F_HOST_DEVICE
inline
unsigned int
number_of_digits
(
  Id1 val 
)
{
  static_assert(std::is_integral<Id1>::value, "Non integral input arguments.");
 
  unsigned int retval = 1;
  while (val >= 10) {
    val /= 10;
    retval += 1;
  }
 
  return retval;
}
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
template<typename Id1>
CS_F_HOST_DEVICE
inline
void
uint_to_char
(
 char *dest, 
 Id1   val   
)
{
  static_assert(std::is_integral<Id1>::value, "Non integral input arguments.");
  assert(val >= 0);
 
  unsigned int n_digits = number_of_digits(val);
  int pos = n_digits - 1;
 
  if (val == 0) {
    dest[0] = '0';
    dest[1] = '\0';
  }
  else {
    Id1 v = val;
    while (v > 0) {
      auto const num = v % 10;
      v /= 10;
      dest[pos] = '0' + num;
      --pos;
    }
  }
}
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
CS_F_HOST_DEVICE
inline
void
concatenate_char
(
  char       *dest, 
  const char *src   
)
{
  int dst_pos = 0;
  while (dest[dst_pos] != 0) {
    dst_pos += 1;
  }
 
  int i = 0;
  while (src[i] != 0) {
    dest[i + dst_pos] = src[i];
    i += 1;
  }
}
 
/*----------------------------------------------------------------------------*/
 
} // namespace cs
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
template <typename T>
struct dependent_false : std::false_type {};
 
template <typename T>
static inline cs_datatype_t
cs_datatype_from_type()
{
  static_assert(dependent_false<T>::value, "Unknown datatype");
  return CS_DATATYPE_NULL;
}
 
/*----------------------------------------------------------------------------*/
/* Specialized versions of the templated function                             */
/*----------------------------------------------------------------------------*/
 
template <>
constexpr inline cs_datatype_t
cs_datatype_from_type<char>()
{
  return CS_CHAR;
}
 
/*----------------------------------------------------------------------------*/
 
template <>
constexpr inline cs_datatype_t
cs_datatype_from_type<float>()
{
  return CS_FLOAT;
}
 
/*----------------------------------------------------------------------------*/
 
template <>
constexpr inline cs_datatype_t
cs_datatype_from_type<double>()
{
  return CS_DOUBLE;
}
 
/*----------------------------------------------------------------------------*/
 
template <>
constexpr inline cs_datatype_t
cs_datatype_from_type<uint16_t>()
{
  return CS_UINT16;
}
 
/*----------------------------------------------------------------------------*/
 
template <>
constexpr inline cs_datatype_t
cs_datatype_from_type<uint32_t>()
{
  return CS_UINT32;
}
 
/*----------------------------------------------------------------------------*/
 
template <>
constexpr inline cs_datatype_t
cs_datatype_from_type<uint64_t>()
{
  return CS_UINT64;
}
 
/*----------------------------------------------------------------------------*/
 
template <>
constexpr inline cs_datatype_t
cs_datatype_from_type<int32_t>()
{
  return CS_INT32;
}
 
/*----------------------------------------------------------------------------*/
 
template <>
constexpr inline cs_datatype_t
cs_datatype_from_type<int64_t>()
{
  return CS_INT64;
}
 
/*----------------------------------------------------------------------------*/
 
#endif /* CS_DEFS_H */