cs_numbering.h

Go to the documentation of this file.

#ifndef CS_NUMBERING_H
#define CS_NUMBERING_H
 
/*============================================================================
 * Numbering information for vectorization or multithreading
 *============================================================================*/
 
/*
  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.
*/
 
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "base/cs_defs.h"
#include "base/cs_base.h"
#include "base/cs_log.h"
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
/* SIMD unit length */
/*------------------*/
 
#if defined(__NEC__) && defined(__ve__)  /* For NEC Aurora series */
 
#  define CS_NUMBERING_SIMD_SIZE 256
 
#elif defined(SX) && defined(_SX)        /* For NEC SX series (at least SX-9) */
 
#  define CS_NUMBERING_SIMD_SIZE 256
 
#elif defined(__AVX512F__)               /* For Intel with AVX 512 */
 
#  define CS_NUMBERING_SIMD_SIZE 64
 
#elif defined(HAVE_CUDA)                 /* For CUDA devices (warp size) */
 
#  define CS_NUMBERING_SIMD_SIZE 32
 
#elif defined(HAVE_HIP)                 /* For HIP devices (use warp size) */
 
#if defined(__GFX8__) || defined(__GFX9__)
#  define CS_NUMBERING_SIMD_SIZE 64
#else
#  define CS_NUMBERING_SIMD_SIZE 32
#endif
 
#else
 
#  define CS_NUMBERING_SIMD_SIZE 4       /* Most current platforms */
 
#endif
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
/* Renumbering types */
 
typedef enum {
 
  CS_NUMBERING_DEFAULT,    /* Default numbering */
  CS_NUMBERING_VECTORIZE,  /* Numbered for vectorization */
  CS_NUMBERING_THREADS     /* Numbered for threads */
 
} cs_numbering_type_t;
 
/* Renumbering structure */
 
typedef struct {
 
  cs_numbering_type_t   type;     /* Numbering type */
 
  int   vector_size;              /* Vector size if vectorized, 1 otherwise */
 
  int   n_threads;                /* Number of threads */
  int   n_groups;                 /* Number of associated groups */
 
  int   n_no_adj_halo_groups;     /* number of groups for which only non-ghost
                                     entities are adjacent */
 
  cs_lnum_t  n_no_adj_halo_elts;  /* Number of elements not adjacent to
                                     halo elements */
 
  cs_lnum_t *group_index;         /* For thread t and group g, the start and
                                     past-the-end ids for entities in a given
                                     group and thread are respectively:
                                     group_index[t*n_groups*2 + g] and
                                     group_index[t*n_groups*2 + g + 1].
                                     (size: n_groups * n_threads * 2) */
 
} cs_numbering_t;
 
/*=============================================================================
 * Global variable definitions
 *============================================================================*/
 
/* Names for numbering types */
 
extern const char  *cs_numbering_type_name[];
 
/*=============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline size_t
cs_numbering_simd_size(cs_lnum_t  n_elts,
                       size_t     type_size)
{
  size_t simd_bytes = CS_NUMBERING_SIMD_SIZE * 8;
  size_t elt_bytes = n_elts * type_size;
  size_t n_ceil = (((elt_bytes-1)/simd_bytes+1)*simd_bytes);
  return n_ceil / type_size;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_numbering_t *
cs_numbering_create_default(cs_lnum_t  n_elts);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_numbering_t *
cs_numbering_create_vectorized(cs_lnum_t  n_elts,
                               int        vector_size);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_numbering_t *
cs_numbering_create_threaded(int        n_threads,
                             int        n_groups,
                             cs_lnum_t  group_index[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_numbering_destroy(cs_numbering_t  **numbering);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_numbering_log_info(cs_log_t               log,
                      const char            *description,
                      const cs_numbering_t  *numbering);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_numbering_dump(const cs_numbering_t  *numbering);
 
/*----------------------------------------------------------------------------*/
 
#endif /* CS_NUMBERING_H */