Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
Concurrency.h
Aller à la documentation de ce fichier.
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2024 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/* Concurrency.h (C) 2000-2024 */
9/* */
10/* Classes gérant la concurrence (tâches, boucles parallèles, ...) */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_CONCURRENCY_H
13#define ARCANE_CORE_CONCURRENCY_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/ConcurrencyUtils.h"
18
19#include "arcane/core/Item.h"
20#include "arcane/core/ItemFunctor.h"
21#include "arcane/core/ItemGroup.h"
22
23#include <arcane/core/materials/MatItem.h>
24
25/*---------------------------------------------------------------------------*/
26/*---------------------------------------------------------------------------*/
27
28namespace Arcane::impl
29{
30inline Int32
31adaptGrainSize(const ForLoopRunInfo& run_info)
32{
33 const std::optional<ParallelLoopOptions>& options = run_info.options();
34 Int32 grain_size = AbstractItemRangeFunctor::DEFAULT_GRAIN_SIZE;
35 if (options.has_value())
36 if (options.value().hasGrainSize())
37 grain_size = options.value().grainSize();
38 return grain_size;
39}
40} // namespace Arcane::impl
41
42namespace Arcane
43{
44
45/*---------------------------------------------------------------------------*/
46/*---------------------------------------------------------------------------*/
53template <typename InstanceType, typename ItemType> inline void
54arcaneParallelForeach(const ItemVectorView& items_view, const ForLoopRunInfo& run_info,
55 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
56{
57 Int32 grain_size = impl::adaptGrainSize(run_info);
58 ItemRangeFunctorT<InstanceType, ItemType> ipf(items_view, instance, function, grain_size);
59
60 ForLoopRunInfo adapted_run_info(run_info);
61 ParallelLoopOptions loop_opt(run_info.options().value_or(TaskFactory::defaultParallelLoopOptions()));
62 loop_opt.setGrainSize(ipf.blockGrainSize());
63 adapted_run_info.addOptions(loop_opt);
64
65 ParallelFor1DLoopInfo loop_info(0, ipf.nbBlock(), &ipf, adapted_run_info);
66 TaskFactory::executeParallelFor(loop_info);
67}
68
69/*---------------------------------------------------------------------------*/
70/*---------------------------------------------------------------------------*/
76template <typename LambdaType> inline void
77arcaneParallelForeach(const ItemVectorView& items_view, const ForLoopRunInfo& run_info,
78 const LambdaType& lambda_function)
79{
80 Int32 grain_size = impl::adaptGrainSize(run_info);
81 LambdaItemRangeFunctorT<LambdaType> ipf(items_view, lambda_function, grain_size);
82
83 ForLoopRunInfo adapted_run_info(run_info);
84 ParallelLoopOptions loop_opt(run_info.options().value_or(TaskFactory::defaultParallelLoopOptions()));
85 loop_opt.setGrainSize(ipf.blockGrainSize());
86 adapted_run_info.addOptions(loop_opt);
87
88 ParallelFor1DLoopInfo loop_info(0, ipf.nbBlock(), &ipf, adapted_run_info);
89 TaskFactory::executeParallelFor(loop_info);
90}
91
92/*---------------------------------------------------------------------------*/
93/*---------------------------------------------------------------------------*/
94
101template <typename InstanceType, typename ItemType> inline void
102arcaneParallelForeach(const ItemVectorView& items_view, const ParallelLoopOptions& options,
103 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
104{
105 arcaneParallelForeach(items_view, ForLoopRunInfo(options), instance, function);
106}
107
114template <typename InstanceType, typename ItemType> inline void
115arcaneParallelForeach(const ItemGroup& items, const ForLoopRunInfo& run_info,
116 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
117{
118 arcaneParallelForeach(items._paddedView(), run_info, instance, function);
119}
120
126template <typename InstanceType, typename ItemType> inline void
127arcaneParallelForeach(const ItemVectorView& items_view,
128 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
129{
130 arcaneParallelForeach(items_view, ForLoopRunInfo(), instance, function);
131}
132
138template <typename InstanceType, typename ItemType> inline void
139arcaneParallelForeach(const ItemGroup& items,
140 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
141{
142 arcaneParallelForeach(items._paddedView(), ForLoopRunInfo(), instance, function);
143}
144
150template <typename LambdaType> inline void
151arcaneParallelForeach(const ItemVectorView& items_view, const ParallelLoopOptions& options,
152 const LambdaType& lambda_function)
153{
154 arcaneParallelForeach(items_view, ForLoopRunInfo(options), lambda_function);
155}
156
162template <typename LambdaType> inline void
163arcaneParallelForeach(const ItemGroup& items, const ParallelLoopOptions& options,
164 const LambdaType& lambda_function)
165{
166 arcaneParallelForeach(items._paddedView(), ForLoopRunInfo(options), lambda_function);
167}
168
174template <typename LambdaType> inline void
175arcaneParallelForeach(const ItemVectorView& items_view, const LambdaType& lambda_function)
176{
177 arcaneParallelForeach(items_view, ForLoopRunInfo(), lambda_function);
178}
179
185template <typename LambdaType> inline void
186arcaneParallelForeach(const ItemGroup& items, const LambdaType& lambda_function)
187{
188 arcaneParallelForeach(items._paddedView(), lambda_function);
189}
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
198template <typename InstanceType> inline void
199arcaneParallelFor(Integer i0, Integer size, InstanceType* itype,
200 void (InstanceType::*lambda_function)(Integer i0, Integer size))
201{
202 RangeFunctorT<InstanceType> ipf(itype, lambda_function);
203 ParallelFor1DLoopInfo loop_info(i0, size, &ipf);
204 TaskFactory::executeParallelFor(loop_info);
205}
206
212template <typename LambdaType> inline void
213arcaneParallelFor(Integer i0, Integer size, const ForLoopRunInfo& options,
214 const LambdaType& lambda_function)
215{
216 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
217 ParallelFor1DLoopInfo loop_info(i0, size, &ipf, options);
218 TaskFactory::executeParallelFor(loop_info);
219}
220
226template <typename LambdaType> inline void
227arcaneParallelFor(Integer i0, Integer size, const ParallelLoopOptions& options,
228 const LambdaType& lambda_function)
229{
230 arcaneParallelFor(i0, size, ForLoopRunInfo(options),lambda_function);
231}
232
237template <typename LambdaType> inline void
238arcaneParallelFor(Integer i0, Integer size, const LambdaType& lambda_function)
239{
240 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
241 ParallelFor1DLoopInfo loop_info(i0, size, &ipf);
242 TaskFactory::executeParallelFor(loop_info);
243}
244
245/*---------------------------------------------------------------------------*/
246/*---------------------------------------------------------------------------*/
252template <typename LambdaType, typename... Views> inline void
253arcaneParallelForVa(const ForLoopRunInfo& run_info, const LambdaType& lambda_function, Views... views)
254{
255 // Asserting every views have the size
256 typename std::tuple_element_t<0, std::tuple<Views...>>::size_type sizes[] = {views.size()...};
257 if (!std::all_of(std::begin(sizes), std::end(sizes),[&sizes](auto cur){return cur == sizes[0];}))
258 ARCANE_FATAL("Every views must have the same size");
259
260 LambdaRangeFunctorTVa<LambdaType, Views...> ipf(views..., lambda_function);
261
262 ParallelFor1DLoopInfo loop_info(0, sizes[0], &ipf, run_info);
263 TaskFactory::executeParallelFor(loop_info);
264}
265
266/*---------------------------------------------------------------------------*/
267/*---------------------------------------------------------------------------*/
276namespace Parallel
277{
281 template <typename InstanceType, typename ItemType>
282 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
283 Foreach(const ItemVectorView& items_view, const ParallelLoopOptions& options,
284 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
285 {
286 ItemRangeFunctorT<InstanceType, ItemType> ipf(items_view, instance, function, options.grainSize());
287 // Recopie \a options et utilise la valeur de 'grain_size' retournée par \a ifp
288 ParallelLoopOptions loop_opt(options);
289 loop_opt.setGrainSize(ipf.blockGrainSize());
290 TaskFactory::executeParallelFor(0, ipf.nbBlock(), loop_opt, &ipf);
291 }
292
296 template <typename InstanceType, typename ItemType>
297 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
298 Foreach(const ItemGroup& items, const ParallelLoopOptions& options, InstanceType* instance,
299 void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
300 {
301 Foreach(items._paddedView(), options, instance, function);
302 }
303
307 template <typename InstanceType, typename ItemType>
308 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
309 Foreach(const ItemVectorView& items_view, InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
310 {
311 ItemRangeFunctorT<InstanceType, ItemType> ipf(items_view, instance, function);
312 TaskFactory::executeParallelFor(0, ipf.nbBlock(), ipf.blockGrainSize(), &ipf);
313 }
314
318 template <typename InstanceType, typename ItemType>
319 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
320 Foreach(const ItemGroup& items, InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
321 {
322 Foreach(items._paddedView(), instance, function);
323 }
324
328 template <typename LambdaType>
329 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
330 Foreach(const ItemVectorView& items_view, const ParallelLoopOptions& options, const LambdaType& lambda_function)
331 {
332 LambdaItemRangeFunctorT<LambdaType> ipf(items_view, lambda_function, options.grainSize());
333 // Recopie \a options et utilise la valeur de 'grain_size' retournée par \a ifp
334 ParallelLoopOptions loop_opt(options);
335 loop_opt.setGrainSize(ipf.blockGrainSize());
336 TaskFactory::executeParallelFor(0, ipf.nbBlock(), loop_opt, &ipf);
337 }
338
342 template <typename LambdaType>
343 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
344 Foreach(const ItemGroup& items, const ParallelLoopOptions& options, const LambdaType& lambda_function)
345 {
346 Foreach(items._paddedView(), options, lambda_function);
347 }
348
352 template <typename LambdaType>
353 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
354 Foreach(const ItemVectorView& items_view, const LambdaType& lambda_function)
355 {
356 LambdaItemRangeFunctorT<LambdaType> ipf(items_view, lambda_function);
357 TaskFactory::executeParallelFor(0, ipf.nbBlock(), ipf.blockGrainSize(), &ipf);
358 }
359
363 template <typename LambdaType>
364 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
365 Foreach(const ItemGroup& items, const LambdaType& lambda_function)
366 {
367 Foreach(items._paddedView(), lambda_function);
368 }
369
373 template <typename InstanceType> ARCANE_DEPRECATED_122 inline void
374 For(Integer i0, Integer size, Integer grain_size, InstanceType* itype,
375 void (InstanceType::*lambda_function)(Integer i0, Integer size))
376 {
377 RangeFunctorT<InstanceType> ipf(itype, lambda_function);
378 TaskFactory::executeParallelFor(i0, size, grain_size, &ipf);
379 }
380
384 template <typename InstanceType>
385 [[deprecated("Year2021: Use Arcane::arcaneParallelFor() instead")]] inline void
386 For(Integer i0, Integer size, const ParallelLoopOptions& options, InstanceType* itype,
387 void (InstanceType::*lambda_function)(Integer i0, Integer size))
388 {
389 RangeFunctorT<InstanceType> ipf(itype, lambda_function);
390 TaskFactory::executeParallelFor(i0, size, options, &ipf);
391 }
392
396 template <typename LambdaType> ARCANE_DEPRECATED_122 inline void
397 For(Integer i0, Integer size, Integer grain_size, const LambdaType& lambda_function)
398 {
399 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
400 TaskFactory::executeParallelFor(i0, size, grain_size, &ipf);
401 }
402
406 template <typename InstanceType>
407 [[deprecated("Year2021: Use Arcane::arcaneParallelFor() instead")]] inline void
408 For(Integer i0, Integer size, InstanceType* itype,
409 void (InstanceType::*lambda_function)(Integer i0, Integer size))
410 {
411 RangeFunctorT<InstanceType> ipf(itype, lambda_function);
412 TaskFactory::executeParallelFor(i0, size, &ipf);
413 }
414
418 template <typename LambdaType>
419 [[deprecated("Year2021: Use Arcane::arcaneParallelFor() instead")]] inline void
420 For(Integer i0, Integer size, const ParallelLoopOptions& options, const LambdaType& lambda_function)
421 {
422 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
423 TaskFactory::executeParallelFor(i0, size, options, &ipf);
424 }
425
429 template <typename LambdaType>
430 [[deprecated("Year2021: Use Arcane::arcaneParallelFor() instead")]] inline void
431 For(Integer i0, Integer size, const LambdaType& lambda_function)
432 {
433 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
434 TaskFactory::executeParallelFor(i0, size, &ipf);
435 }
436
437} // End namespace Parallel
438
439/*---------------------------------------------------------------------------*/
440/*---------------------------------------------------------------------------*/
441
442} // End namespace Arcane
443
444/*---------------------------------------------------------------------------*/
445/*---------------------------------------------------------------------------*/
446
447#endif
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:764
ConcurrencyUtils.h
Classes, Types et macros pour gérer la concurrence.
Arcane::AbstractItemRangeFunctor::nbBlock
Int32 nbBlock() const
Nombre de blocs.
Definition ItemFunctor.h:52
Arcane::AbstractItemRangeFunctor::blockGrainSize
Int32 blockGrainSize() const
Taille souhaitée d'un intervalle d'itération.
Definition ItemFunctor.h:55
Arcane::ForLoopRunInfo
Informations d'exécution d'une boucle.
Definition ConcurrencyUtils.h:56
Arcane::ItemGroup
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Arcane::ItemGroup::_paddedView
ItemVectorView _paddedView() const
Vue sur les entités du groupe avec padding pour la vectorisation.
Definition ItemGroup.cc:591
Arcane::ItemRangeFunctorT
Fonctor pour itérer sur une liste d'entités.
Definition ItemFunctor.h:79
Arcane::ItemVectorViewT
Vue sur un tableau typé d'entités.
Definition ItemVectorView.h:406
Arcane::ItemVectorView
Vue sur un vecteur d'entités.
Definition ItemVectorView.h:227
Arcane::LambdaItemRangeFunctorT
Fonctor sur un interval d'itération instancié via une lambda fonction.
Definition ItemFunctor.h:119
Arcane::LambdaRangeFunctorTVa
Fonctor sur un interval d'itération instancié via une lambda fonction.
Definition RangeFunctor.h:125
Arcane::LambdaRangeFunctorT
Fonctor sur un interval d'itération instancié via une lambda fonction.
Definition RangeFunctor.h:67
Arcane::ParallelFor1DLoopInfo
Caractéristiques d'un boucle 1D multi-thread.
Definition ConcurrencyUtils.h:611
Arcane::ParallelLoopOptions
Options d'exécution d'une boucle parallèle en multi-thread.
Definition ParallelLoopOptions.h:35
Arcane::ParallelLoopOptions::grainSize
Integer grainSize() const
Taille d'un intervalle d'itération.
Definition ParallelLoopOptions.h:106
Arcane::ParallelLoopOptions::setGrainSize
void setGrainSize(Integer v)
Positionne la taille (approximative) d'un intervalle d'itération.
Definition ParallelLoopOptions.h:108
Arcane::RangeFunctorT
Fonctor sur un interval d'itération.
Definition RangeFunctor.h:34
Arcane::TaskFactory::defaultParallelLoopOptions
static const ParallelLoopOptions & defaultParallelLoopOptions()
Valeurs par défaut d'exécution d'une boucle parallèle.
Definition ConcurrencyUtils.h:523
Arcane::TaskFactory::executeParallelFor
static void executeParallelFor(Integer begin, Integer size, const ParallelLoopOptions &options, IRangeFunctor *f)
Exécute le fonctor f en concurrence.
Definition ConcurrencyUtils.h:391
Arcane::arcaneParallelForeach
void arcaneParallelForeach(const ItemVectorView &items_view, const ForLoopRunInfo &run_info, InstanceType *instance, void(InstanceType::*function)(ItemVectorViewT< ItemType > items))
Applique en concurrence la méthode function de l'instance instance sur la vue items_view avec les opt...
Definition Concurrency.h:54
Arcane::arcaneParallelForVa
void arcaneParallelForVa(const ForLoopRunInfo &run_info, const LambdaType &lambda_function, Views... views)
Applique en concurrence la fonction lambda lambda_function instance sur les vues des containers views...
Definition Concurrency.h:253
Arcane::arcaneParallelFor
void arcaneParallelFor(Integer i0, Integer size, InstanceType *itype, void(InstanceType::*lambda_function)(Integer i0, Integer size))
Applique en concurrence la fonction lambda lambda_function sur l'intervalle d'itération [i0,...
Definition Concurrency.h:199
Arcane::Parallel
Implémentation de la concurrence.
Definition Concurrency.h:277
Arcane::Parallel::Foreach
void Foreach(const ItemVectorView &items_view, const ParallelLoopOptions &options, InstanceType *instance, void(InstanceType::*function)(ItemVectorViewT< ItemType > items))
Definition Concurrency.h:283
Arcane::Parallel::For
ARCANE_DEPRECATED_122 void For(Integer i0, Integer size, Integer grain_size, InstanceType *itype, void(InstanceType::*lambda_function)(Integer i0, Integer size))
Definition Concurrency.h:374
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184