Arcane  v3.16.6.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
MachineMemoryWindow.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 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/* MachineMemoryWindow.h (C) 2000-2025 */
9/* */
10/* Classe permettant de créer une fenêtre mémoire partagée entre les */
11/* processus d'un même noeud. */
12/*---------------------------------------------------------------------------*/
13
14#ifndef ARCANE_CORE_MACHINEMEMORYWINDOW_H
15#define ARCANE_CORE_MACHINEMEMORYWINDOW_H
16
17/*---------------------------------------------------------------------------*/
18/*---------------------------------------------------------------------------*/
19
21#include "arcane/core/MachineMemoryWindowBase.h"
22#include "arcane/utils/Ref.h"
23
24#include "arccore/base/Span.h"
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
29namespace Arcane
30{
31
32/*---------------------------------------------------------------------------*/
33/*---------------------------------------------------------------------------*/
34
35/*!
36 * \brief Classe permettant de créer une fenêtre mémoire partagée entre les
37 * sous-domaines d'un même noeud.
38 * Les segments de cette fenêtre seront contigüs en mémoire.
39 *
40 * \tparam Type Le type des éléments de la fenêtre.
41 */
42template <class Type>
44{
45 public:
46
47 /*!
48 * \brief Constructeur.
49 * \param pm Le ParallelMng contenant les processus du noeud.
50 * \param nb_elem_segment Le nombre d'éléments pour le segment de ce sous-domaine.
51 */
53 : m_impl(pm, nb_elem_segment, static_cast<Int32>(sizeof(Type)))
54 {}
55
56 public:
57
58 /*!
59 * \brief Méthode permettant d'obtenir une vue sur notre segment de fenêtre
60 * mémoire.
61 *
62 * \return Une vue.
63 */
65 {
66 return asSpan<Type>(m_impl.segmentView());
67 }
68
69 /*!
70 * \brief Méthode permettant d'obtenir une vue sur le segment de fenêtre
71 * mémoire d'un autre sous-domaine du noeud.
72 *
73 * \param rank Le rang du sous-domaine.
74 * \return Une vue.
75 */
77 {
78 return asSpan<Type>(m_impl.segmentView(rank));
79 }
80
81 /*!
82 * \brief Méthode permettant d'obtenir une vue sur toute la fenêtre mémoire.
83 *
84 * \return Une vue.
85 */
87 {
88 return asSpan<Type>(m_impl.windowView());
89 }
90
91 /*!
92 * \brief Méthode permettant d'obtenir une vue constante sur notre segment
93 * de fenêtre mémoire.
94 *
95 * \return Une vue constante.
96 */
98 {
99 return asSpan<const Type>(m_impl.segmentView());
100 }
101
102 /*!
103 * \brief Méthode permettant d'obtenir une vue constante sur le segment de
104 * fenêtre mémoire d'un autre sous-domaine du noeud.
105 *
106 * \param rank Le rang du sous-domaine.
107 * \return Une vue constante.
108 */
110 {
111 return asSpan<const Type>(m_impl.segmentView(rank));
112 }
113
114 /*!
115 * \brief Méthode permettant d'obtenir une vue constante sur toute la fenêtre
116 * mémoire.
117 *
118 * \return Une vue constante.
119 */
121 {
122 return asSpan<const Type>(m_impl.windowView());
123 }
124
125 /*!
126 * \brief Méthode permettant de redimensionner les segments de la fenêtre.
127 * Appel collectif.
128 *
129 * La taille totale de la fenêtre doit être inférieure ou égale à la taille
130 * d'origine.
131 *
132 * \param new_nb_elem La nouvelle taille de notre segment.
133 */
134 void resizeSegment(Integer new_nb_elem) const
135 {
136 m_impl.resizeSegment(new_nb_elem);
137 }
138
139 /*!
140 * \brief Méthode permettant d'obtenir les rangs qui possèdent un segment
141 * dans la fenêtre.
142 *
143 * L'ordre des processus de la vue retournée correspond à l'ordre des
144 * segments dans la fenêtre.
145 *
146 * \return Une vue contenant les ids des rangs.
147 */
149 {
150 return m_impl.machineRanks();
151 }
152
153 /*!
154 * \brief Méthode permettant d'attendre que tous les processus/threads
155 * du noeud appellent cette méthode pour continuer l'exécution.
156 */
157 void barrier() const
158 {
159 m_impl.barrier();
160 }
161
162 private:
163
165};
166
167/*---------------------------------------------------------------------------*/
168/*---------------------------------------------------------------------------*/
169
170} // End namespace Arcane
171
172/*---------------------------------------------------------------------------*/
173/*---------------------------------------------------------------------------*/
174
175#endif
Déclarations des types généraux de Arcane.
Vue constante d'un tableau de type T.
Interface du gestionnaire de parallélisme pour un sous-domaine.
Classe permettant de créer une fenêtre mémoire partagée entre les sous-domaines d'un même noeud....
void barrier() const
Méthode permettant d'attendre que tous les processus/threads du noeud appellent cette méthode pour co...
Span< const Type > windowConstView() const
Méthode permettant d'obtenir une vue constante sur toute la fenêtre mémoire.
MachineMemoryWindow(IParallelMng *pm, Int64 nb_elem_segment)
Constructeur.
Span< Type > windowView() const
Méthode permettant d'obtenir une vue sur toute la fenêtre mémoire.
Span< Type > segmentView(Int32 rank) const
Méthode permettant d'obtenir une vue sur le segment de fenêtre mémoire d'un autre sous-domaine du noe...
ConstArrayView< Int32 > machineRanks() const
Méthode permettant d'obtenir les rangs qui possèdent un segment dans la fenêtre.
Span< Type > segmentView() const
Méthode permettant d'obtenir une vue sur notre segment de fenêtre mémoire.
Span< const Type > segmentConstView(Int32 rank) const
Méthode permettant d'obtenir une vue constante sur le segment de fenêtre mémoire d'un autre sous-doma...
void resizeSegment(Integer new_nb_elem) const
Méthode permettant de redimensionner les segments de la fenêtre. Appel collectif.
Span< const Type > segmentConstView() const
Méthode permettant d'obtenir une vue constante sur notre segment de fenêtre mémoire.
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
Span< DataType > asSpan(Span< std::byte, Extent > bytes)
Converti un Span<std::byte> en un Span<DataType>.
Definition Span.h:976
std::int32_t Int32
Type entier signé sur 32 bits.