Arcane  v3.15.3.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
IParallelNonBlockingCollective.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2022 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/* IParallelNonBlockingCollective.h (C) 2000-2015 */
9/* */
10/* Interface des opérations parallèles collectives non bloquantes. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_IPARALLELNONBLOCKINGCOLLECTIVE_H
13#define ARCANE_IPARALLELNONBLOCKINGCOLLECTIVE_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
18
19#include "arcane/Parallel.h"
20#include "arcane/VariableTypedef.h"
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24/*!
25 * NOTE:
26 * Le but est est IParallelNonBlockingCollective possède les
27 * mêmes méthodes collectives que IParallelMng. Cependant, certaines
28 * méthodes collectives de IParallleMng font en fait appel dans leur
29 * implémentation à plusieurs appels collectifs. Il n'est donc pas
30 * possible de transformer cela directement en opérations collectives.
31 * Pour implémenter cela avec MPI, il faudrait pouvoir associer un callback
32 * à chaque requête (ce callback serait appelé lorsque la requête est terminée)
33 * qui permettrait de poursuivre les opérations. Mais cela
34 * n'est pas disponible actuellement (peut-être cela est-il possible
35 * avec les requêtes généralisées).
36 * En attendant, on supprime de l'interface ces appels en les protégeant
37 * par un define _NEED_ADVANCED_NBC.
38 */
39/*---------------------------------------------------------------------------*/
40/*---------------------------------------------------------------------------*/
41
42ARCANE_BEGIN_NAMESPACE
43
44/*---------------------------------------------------------------------------*/
45/*---------------------------------------------------------------------------*/
46
47class IParallelMng;
48
49/*---------------------------------------------------------------------------*/
50/*---------------------------------------------------------------------------*/
51/*!
52 * \ingroup Parallel
53 * \brief Interface des opérations parallèles collectives non bloquantes.
54 */
55class ARCANE_CORE_EXPORT IParallelNonBlockingCollective
56{
57 public:
58
59 virtual ~IParallelNonBlockingCollective() {} //!< Libère les ressources.
60
61 public:
62
65
66 public:
67
68 //! Construit l'instance.
69 virtual void build() =0;
70
71 public:
72
73 //! Gestionnaire de parallélisme associé.
74 virtual IParallelMng* parallelMng() const =0;
75
76 public:
77
78 //! @name allGather
79 //@{
80 /*!
81 * \brief Effectue un regroupement sur tous les processeurs.
82 * Il s'agit d'une opération collective. Le tableau \a send_buf
83 * doit avoir la même taille, notée \a n, pour tous les processeurs et
84 * le tableau \a recv_buf doit avoir une taille égale au nombre
85 * de processeurs multiplié par \a n.
86 */
101#ifdef ARCANE_REAL_NOT_BUILTIN
103#endif
109 //virtual Request allGather(ISerializer* send_serializer,ISerializer* recv_serializer) =0;
110 //@}
111
112 //! @name gather
113 //@{
114 /*!
115 * \brief Effectue un regroupement sur un processeurs.
116 * Il s'agit d'une opération collective. Le tableau \a send_buf
117 * doit avoir la même taille, notée \a n, pour tous les processeurs et
118 * le tableau \a recv_buf pour le processeur \a rank doit avoir une taille égale au nombre
119 * de processeurs multiplié par \a n. Ce tableau \a recv_buf est inutilisé pour
120 * les autres rangs que \a rank.
121 */
125 virtual Request gather(ConstArrayView<int> send_buf,ArrayView<int> recv_buf,Integer rank) =0;
127 virtual Request gather(ConstArrayView<short> send_buf,ArrayView<short> recv_buf,Integer rank) =0;
129 virtual Request gather(ConstArrayView<long> send_buf,ArrayView<long> recv_buf,Integer rank) =0;
133 virtual Request gather(ConstArrayView<float> send_buf,ArrayView<float> recv_buf,Integer rank) =0;
134 virtual Request gather(ConstArrayView<double> send_buf,ArrayView<double> recv_buf,Integer rank) =0;
136#ifdef ARCANE_REAL_NOT_BUILTIN
137 virtual Request gather(ConstArrayView<Real> send_buf,ArrayView<Real> recv_buf,Integer rank) =0;
138#endif
139 virtual Request gather(ConstArrayView<Real2> send_buf,ArrayView<Real2> recv_buf,Integer rank) =0;
140 virtual Request gather(ConstArrayView<Real3> send_buf,ArrayView<Real3> recv_buf,Integer rank) =0;
143 virtual Request gather(ConstArrayView<HPReal> send_buf,ArrayView<HPReal> recv_buf,Integer rank) =0;
144 //virtual void gather(ISerializer* send_serializer,ISerializer* recv_serializer,Integer rank) =0;
145 //@}
146
147 //! @name allGather variable
148 //@{
149
150#if _NEED_ADVANCED_NBC
151 /*!
152 * \brief Effectue un regroupement sur tous les processeurs.
153 *
154 * Il s'agit d'une opération collective. Le nombre d'éléments du tableau
155 * \a send_buf peut être différent pour chaque processeur. Le tableau
156 * \a recv_buf contient en sortie la concaténation des tableaux \a send_buf
157 * de chaque processeur. Ce tableau \a recv_buf est éventuellement redimensionné
158 * pour le processeurs de rang \a rank.
159 */
160 virtual Request gatherVariable(ConstArrayView<char> send_buf,
161 Array<char>& recv_buf,Integer rank) =0;
162 virtual Request gatherVariable(ConstArrayView<signed char> send_buf,
163 Array<signed char>& recv_buf,Integer rank) =0;
164 virtual Request gatherVariable(ConstArrayView<unsigned char> send_buf,
165 Array<unsigned char>& recv_buf,Integer rank) =0;
166 virtual Request gatherVariable(ConstArrayView<int> send_buf,
167 Array<int>& recv_buf,Integer rank) =0;
168 virtual Request gatherVariable(ConstArrayView<unsigned int> send_buf,
169 Array<unsigned int>& recv_buf,Integer rank) =0;
170 virtual Request gatherVariable(ConstArrayView<short> send_buf,
171 Array<short>& recv_buf,Integer rank) =0;
172 virtual Request gatherVariable(ConstArrayView<unsigned short> send_buf,
173 Array<unsigned short>& recv_buf,Integer rank) =0;
174 virtual Request gatherVariable(ConstArrayView<long> send_buf,
175 Array<long>& recv_buf,Integer rank) =0;
176 virtual Request gatherVariable(ConstArrayView<unsigned long> send_buf,
177 Array<unsigned long>& recv_buf,Integer rank) =0;
178 virtual Request gatherVariable(ConstArrayView<long long> send_buf,
179 Array<long long>& recv_buf,Integer rank) =0;
181 Array<unsigned long long>& recv_buf,Integer rank) =0;
182 virtual Request gatherVariable(ConstArrayView<float> send_buf,
183 Array<float>& recv_buf,Integer rank) =0;
184 virtual Request gatherVariable(ConstArrayView<double> send_buf,
185 Array<double>& recv_buf,Integer rank) =0;
186 virtual Request gatherVariable(ConstArrayView<long double> send_buf,
187 Array<long double>& recv_buf,Integer rank) =0;
188#ifdef ARCANE_REAL_NOT_BUILTIN
189 virtual Request gatherVariable(ConstArrayView<Real> send_buf,
190 Array<Real>& recv_buf,Integer rank) =0;
191#endif
192 virtual Request gatherVariable(ConstArrayView<Real2> send_buf,
193 Array<Real2>& recv_buf,Integer rank) =0;
194 virtual Request gatherVariable(ConstArrayView<Real3> send_buf,
195 Array<Real3>& recv_buf,Integer rank) =0;
196 virtual Request gatherVariable(ConstArrayView<Real2x2> send_buf,
197 Array<Real2x2>& recv_buf,Integer rank) =0;
198 virtual Request gatherVariable(ConstArrayView<Real3x3> send_buf,
199 Array<Real3x3>& recv_buf,Integer rank) =0;
200 virtual Request gatherVariable(ConstArrayView<HPReal> send_buf,
201 Array<HPReal>& recv_buf,Integer rank) =0;
202 //@}
203#endif
204
205 //! @name allGather variable
206 //@{
207
208#if _NEED_ADVANCED_NBC
209 /*!
210 * \brief Effectue un regroupement sur tous les processeurs.
211 *
212 * Il s'agit d'une opération collective. Le nombre d'éléments du tableau
213 * \a send_buf peut être différent pour chaque processeur. Le tableau
214 * \a recv_buf contient en sortie la concaténation des tableaux \a send_buf
215 * de chaque processeur. Ce tableau \a recv_buf est éventuellement redimensionné.
216 */
217 virtual Request allGatherVariable(ConstArrayView<char> send_buf,
219 virtual Request allGatherVariable(ConstArrayView<signed char> send_buf,
221 virtual Request allGatherVariable(ConstArrayView<unsigned char> send_buf,
223 virtual Request allGatherVariable(ConstArrayView<int> send_buf,
224 Array<int>& recv_buf) =0;
225 virtual Request allGatherVariable(ConstArrayView<unsigned int> send_buf,
227 virtual Request allGatherVariable(ConstArrayView<short> send_buf,
229 virtual Request allGatherVariable(ConstArrayView<unsigned short> send_buf,
231 virtual Request allGatherVariable(ConstArrayView<long> send_buf,
233 virtual Request allGatherVariable(ConstArrayView<unsigned long> send_buf,
235 virtual Request allGatherVariable(ConstArrayView<long long> send_buf,
237 virtual Request allGatherVariable(ConstArrayView<unsigned long long> send_buf,
239 virtual Request allGatherVariable(ConstArrayView<float> send_buf,
241 virtual Request allGatherVariable(ConstArrayView<double> send_buf,
243 virtual Request allGatherVariable(ConstArrayView<long double> send_buf,
245#ifdef ARCANE_REAL_NOT_BUILTIN
246 virtual Request allGatherVariable(ConstArrayView<Real> send_buf,
248#endif
249 virtual Request allGatherVariable(ConstArrayView<Real2> send_buf,
251 virtual Request allGatherVariable(ConstArrayView<Real3> send_buf,
253 virtual Request allGatherVariable(ConstArrayView<Real2x2> send_buf,
255 virtual Request allGatherVariable(ConstArrayView<Real3x3> send_buf,
257 virtual Request allGatherVariable(ConstArrayView<HPReal> send_buf,
259 //@}
260#endif
261
262#if _NEED_ADVANCED_NBC
263 //! @name opérations de réduction sur un scalaire
264 //@{
265 /*!
266 * \brief Scinde un tableau sur plusieurs processeurs.
267 */
268 virtual Request scatterVariable(ConstArrayView<char> send_buf,
269 ArrayView<char> recv_buf,Integer root) =0;
270 virtual Request scatterVariable(ConstArrayView<signed char> send_buf,
271 ArrayView<signed char> recv_buf,Integer root) =0;
272 virtual Request scatterVariable(ConstArrayView<unsigned char> send_buf,
273 ArrayView<unsigned char> recv_buf,Integer root) =0;
274 virtual Request scatterVariable(ConstArrayView<int> send_buf,
275 ArrayView<int> recv_buf,Integer root) =0;
276 virtual Request scatterVariable(ConstArrayView<unsigned int> send_buf,
277 ArrayView<unsigned int> recv_buf,Integer root) =0;
278 virtual Request scatterVariable(ConstArrayView<long> send_buf,
279 ArrayView<long> recv_buf,Integer root) =0;
280 virtual Request scatterVariable(ConstArrayView<unsigned long> send_buf,
281 ArrayView<unsigned long> recv_buf,Integer root) =0;
282 virtual Request scatterVariable(ConstArrayView<long long> send_buf,
283 ArrayView<long long> recv_buf,Integer root) =0;
286 virtual Request scatterVariable(ConstArrayView<float> send_buf,
287 ArrayView<float> recv_buf,Integer root) =0;
288 virtual Request scatterVariable(ConstArrayView<double> send_buf,
289 ArrayView<double> recv_buf,Integer root) =0;
290 virtual Request scatterVariable(ConstArrayView<long double> send_buf,
291 ArrayView<long double> recv_buf,Integer root) =0;
292#ifdef ARCANE_REAL_NOT_BUILTIN
293 virtual Request scatterVariable(ConstArrayView<Real> send_buf,
294 ArrayView<Real> recv_buf,Integer root) =0;
295#endif
296 virtual Request scatterVariable(ConstArrayView<Real2> send_buf,
297 ArrayView<Real2> recv_buf,Integer root) =0;
298 virtual Request scatterVariable(ConstArrayView<Real3> send_buf,
299 ArrayView<Real3> recv_buf,Integer root) =0;
300 virtual Request scatterVariable(ConstArrayView<Real2x2> send_buf,
301 ArrayView<Real2x2> recv_buf,Integer root) =0;
302 virtual Request scatterVariable(ConstArrayView<Real3x3> send_buf,
303 ArrayView<Real3x3> recv_buf,Integer root) =0;
304 virtual Request scatterVariable(ConstArrayView<HPReal> send_buf,
305 ArrayView<HPReal> recv_buf,Integer root) =0;
306 //@}
307#endif
308
309 //! @name opérations de réduction sur un tableau
310 //@{
311 /*!
312 * \brief Effectue la réduction de type \a rt sur le tableau \a send_buf et
313 * stoque le résultat dans \a recv_buf.
314 */
329#ifdef ARCANE_REAL_NOT_BUILTIN
331#endif
337 //@}
338
339 /*!
340 * @name opérations de broadcast
341 *
342 * \brief Envoie un tableau de valeurs sur tous les sous-domaines.
343 *
344 * Cette opération envoie le tableau de valeur \a send_buf sur tous
345 * les sous-domaines. Le tableau utilisé est celui dont le rang (commRank) est \a rank.
346 * Tous les sous-domaines participants doivent appelés cette méthode avec
347 * le même paramètre \a rank et avoir un tableau \a send_buf
348 * contenant le même nombre d'éléments.
349 */
350 //@{
351 virtual Request broadcast(ArrayView<char> send_buf,Integer rank) =0;
352 virtual Request broadcast(ArrayView<signed char> send_buf,Integer rank) =0;
353 virtual Request broadcast(ArrayView<unsigned char> send_buf,Integer rank) =0;
354 virtual Request broadcast(ArrayView<short> send_buf,Integer rank) =0;
355 virtual Request broadcast(ArrayView<unsigned short> send_buf,Integer rank) =0;
356 virtual Request broadcast(ArrayView<int> send_buf,Integer rank) =0;
357 virtual Request broadcast(ArrayView<unsigned int> send_buf,Integer rank) =0;
358 virtual Request broadcast(ArrayView<long> send_buf,Integer rank) =0;
359 virtual Request broadcast(ArrayView<unsigned long> send_buf,Integer rank) =0;
360 virtual Request broadcast(ArrayView<long long> send_buf,Integer rank) =0;
361 virtual Request broadcast(ArrayView<unsigned long long> send_buf,Integer rank) =0;
362 virtual Request broadcast(ArrayView<float> send_buf,Integer rank) =0;
363 virtual Request broadcast(ArrayView<double> send_buf,Integer rank) =0;
364 virtual Request broadcast(ArrayView<long double> send_buf,Integer rank) =0;
365#ifdef ARCANE_REAL_NOT_BUILTIN
366 virtual Request broadcast(ArrayView<Real> send_buf,Integer rank) =0;
367#endif
368 virtual Request broadcast(ArrayView<Real2> send_buf,Integer rank) =0;
369 virtual Request broadcast(ArrayView<Real3> send_buf,Integer rank) =0;
370 virtual Request broadcast(ArrayView<Real2x2> send_buf,Integer rank) =0;
371 virtual Request broadcast(ArrayView<Real3x3> send_buf,Integer rank) =0;
372 virtual Request broadcast(ArrayView<HPReal> send_buf,Integer rank) =0;
373 //virtual Request broadcastString(String& str,Integer rank) =0;
374
375 //virtual Request broadcastSerializer(ISerializer* values,Integer rank) =0;
376 /*! \brief Effectue un broadcast d'une zone mémoire.
377 *
378 * Le processeur qui effectue le broacast est donnée par \id. Le tableau
379 * envoyé est alors donnée par \a bytes. Les processeurs réceptionnent
380 * le tableau dans \a bytes. Ce tableau est alloué automatiquement, les processeurs
381 * réceptionnant n'ont pas besoin de connaitre le nombre d'octets devant être envoyés.
382 *
383 */
384 //virtual Request broadcastMemoryBuffer(ByteArray& bytes,Integer rank) =0;
385 //@}
386
388 Integer count) =0;
390 Integer count) =0;
392 Integer count) =0;
393 virtual Request allToAll(ConstArrayView<int> send_buf,ArrayView<int> recv_buf,Integer count) =0;
395 Integer count) =0;
396 virtual Request allToAll(ConstArrayView<short> send_buf,ArrayView<short> recv_buf,Integer count) =0;
398 Integer count) =0;
399 virtual Request allToAll(ConstArrayView<long> send_buf,ArrayView<long> recv_buf,Integer count) =0;
401 Integer count) =0;
403 Integer count) =0;
405 ArrayView<unsigned long long> recv_buf,Integer count) =0;
407 Integer count) =0;
409 Integer count) =0;
411 Integer count) =0;
412#ifdef ARCANE_REAL_NOT_BUILTIN
414 Integer count) =0;
415#endif
417 Integer count) =0;
419 Integer count) =0;
421 Integer count) =0;
423 Integer count) =0;
425 Integer count) =0;
426
427
428 /*! @name allToAll variable
429 *
430 * \brief Effectue un allToAll variable
431 *
432 */
433 //@{
476#ifdef ARCANE_REAL_NOT_BUILTIN
480#endif
496 //@}
497
498 //! @name opérations de synchronisation et opérations asynchrones
499 //@{
500 //! Effectue une barière
501 virtual Request barrier() =0;
502 //@}
503
504 /*!
505 * \brief Indique si l'implémentation autorise les réductions sur les types
506 * dérivés.
507 *
508 * Les version de OpenMPI jusqu'à la version 1.8.4 incluses semblent avoir
509 * un bug (qui se traduit par un plantage) avec les réductions non bloquantes
510 * lorsque l'opérateur de réduction est redéfini. C'est le cas avec les
511 * types dérivés tels que Real3, Real2, ...
512 */
513 virtual bool hasValidReduceForDerivedType() const =0;
514};
515
516/*---------------------------------------------------------------------------*/
517/*---------------------------------------------------------------------------*/
518
519ARCANE_END_NAMESPACE
520
521/*---------------------------------------------------------------------------*/
522/*---------------------------------------------------------------------------*/
523
524#endif
525
Déclarations des types utilisés dans Arcane.
Interface du gestionnaire de parallélisme pour un sous-domaine.
Interface des opérations parallèles collectives non bloquantes.
virtual Request barrier()=0
Effectue une barière.
virtual void build()=0
Construit l'instance.
virtual Request allGather(ConstArrayView< char > send_buf, ArrayView< char > recv_buf)=0
Effectue un regroupement sur tous les processeurs. Il s'agit d'une opération collective....
virtual bool hasValidReduceForDerivedType() const =0
Indique si l'implémentation autorise les réductions sur les types dérivés.
virtual IParallelMng * parallelMng() const =0
Gestionnaire de parallélisme associé.
virtual ~IParallelNonBlockingCollective()
Libère les ressources.
virtual Request allReduce(eReduceType rt, ConstArrayView< char > send_buf, ArrayView< char > recv_buf)=0
Effectue la réduction de type rt sur le tableau send_buf et stoque le résultat dans recv_buf.
virtual Request gather(ConstArrayView< char > send_buf, ArrayView< char > recv_buf, Integer rank)=0
Effectue un regroupement sur un processeurs. Il s'agit d'une opération collective....
virtual Request allToAll(ConstArrayView< char > send_buf, ArrayView< char > recv_buf, Integer count)=0
Effectue un broadcast d'une zone mémoire.
Vue constante d'un tableau de type T.
Requête d'un message.
Definition Request.h:77
Référence à une instance.
eReduceType
Types des réductions supportées.