Arcane  v4.1.3.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
StridedLoopRanges.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* StridedLoopRanges.h (C) 2000-2026 */
9/* */
10/* Gestion du lancement des noyaux de calcul sur accélérateur. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCCORE_COMMON_STRIDEDLOOPRANGES_H
13#define ARCCORE_COMMON_STRIDEDLOOPRANGES_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arccore/common/CommonGlobal.h"
18
19/*---------------------------------------------------------------------------*/
20/*---------------------------------------------------------------------------*/
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24
25namespace Arcane::Accelerator::Impl
26{
27
28/*---------------------------------------------------------------------------*/
29/*---------------------------------------------------------------------------*/
30/*!
31 * \brief Classe pour gérer la décomposition d'une boucle en plusieurs parties.
32 */
33class ARCCORE_COMMON_EXPORT StridedLoopRangesBase
34{
35 public:
36
37 constexpr StridedLoopRangesBase(Int32 nb_stride, Int64 nb_orig_element)
38 : m_stride_value((nb_orig_element + (nb_stride - 1)) / nb_stride)
39 , m_nb_original_element(nb_orig_element)
40 , m_nb_stride(nb_stride)
41 {
42 }
43 constexpr StridedLoopRangesBase(Int64 nb_orig_element)
44 : m_stride_value(nb_orig_element)
45 , m_nb_original_element(nb_orig_element)
46 , m_nb_stride(1)
47 {
48 }
49
50 public:
51
52 constexpr Int32 nbStride() const { return m_nb_stride; }
53 constexpr Int64 nbOriginalElement() const { return m_nb_original_element; }
54 constexpr Int64 strideValue() const { return m_stride_value; }
55
56 void setNbStride(Int32 nb_stride) { _setNbStride(nb_stride); }
57
58 private:
59
60 //! Valeur du pas
61 Int64 m_stride_value = 0;
62 //! Nombre d'éléments dans la boucle d'origine
63 Int64 m_nb_original_element = 0;
64 //! Nombre de pas
65 Int32 m_nb_stride = 0;
66
67 private:
68
69 void _setNbStride(Int32 nb_stride)
70 {
71 m_nb_stride = nb_stride;
72 m_stride_value = (m_nb_original_element + (nb_stride - 1)) / nb_stride;
73 }
74};
75
76/*---------------------------------------------------------------------------*/
77/*---------------------------------------------------------------------------*/
78/*!
79 * \brief Classe pour gérer la décomposition d'une boucle en plusieurs parties.
80 */
81template <typename LoopBoundType_>
82class StridedLoopRanges
83: public StridedLoopRangesBase
84{
85 public:
86
87 using LoopBoundType = LoopBoundType_;
88
89 public:
90
91 StridedLoopRanges(Int32 nb_grid_stride, const LoopBoundType& orig_loop)
92 : StridedLoopRangesBase(nb_grid_stride, orig_loop.nbElement())
93 , m_orig_loop(orig_loop)
94 {
95 }
96 StridedLoopRanges(const LoopBoundType& orig_loop)
97 : StridedLoopRangesBase(orig_loop.nbElement())
98 , m_orig_loop(orig_loop)
99 {
100 }
101 constexpr const LoopBoundType& originalLoop() const { return m_orig_loop; }
102
103 private:
104
105 LoopBoundType m_orig_loop;
106};
107
108/*---------------------------------------------------------------------------*/
109/*---------------------------------------------------------------------------*/
110
111template <typename LoopBoundType> ARCCORE_HOST_DEVICE LoopBoundType::LoopIndexType
112arcaneGetLoopIndexCudaHip(StridedLoopRanges<LoopBoundType> loop_bounds, Int32 index)
113{
114 return arcaneGetLoopIndexCudaHip(loop_bounds.originalLoop(), index);
115}
116
117/*---------------------------------------------------------------------------*/
118/*---------------------------------------------------------------------------*/
119
120} // namespace Arcane::Accelerator::Impl
121
122/*---------------------------------------------------------------------------*/
123/*---------------------------------------------------------------------------*/
124
125#endif
Arcane::Accelerator::Impl::StridedLoopRanges
Classe pour gérer la décomposition d'une boucle en plusieurs parties.
Definition StridedLoopRanges.h:84
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:227
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:225