Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
Concurrency.h
Go to the documentation of this file.
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/* Concurrency.h (C) 2000-2025 */
9/* */
10/* Classes managing concurrency (tasks, parallel loops, ...) */
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#include <algorithm>
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
30namespace Arcane::impl
31{
32inline Int32
33adaptGrainSize(const ForLoopRunInfo& run_info)
34{
35 const std::optional<ParallelLoopOptions>& options = run_info.options();
36 Int32 grain_size = AbstractItemRangeFunctor::DEFAULT_GRAIN_SIZE;
37 if (options.has_value())
38 if (options.value().hasGrainSize())
39 grain_size = options.value().grainSize();
40 return grain_size;
41}
42} // namespace Arcane::impl
43
44namespace Arcane
45{
46
47/*---------------------------------------------------------------------------*/
48/*---------------------------------------------------------------------------*/
49
56template <typename InstanceType, typename ItemType> inline void
57arcaneParallelForeach(const ItemVectorView& items_view, const ForLoopRunInfo& run_info,
58 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
59{
60 Int32 grain_size = impl::adaptGrainSize(run_info);
61 ItemRangeFunctorT<InstanceType, ItemType> ipf(items_view, instance, function, grain_size);
62
63 ForLoopRunInfo adapted_run_info(run_info);
64 ParallelLoopOptions loop_opt(run_info.options().value_or(TaskFactory::defaultParallelLoopOptions()));
65 loop_opt.setGrainSize(ipf.blockGrainSize());
66 adapted_run_info.addOptions(loop_opt);
67
68 ParallelFor1DLoopInfo loop_info(0, ipf.nbBlock(), &ipf, adapted_run_info);
69 TaskFactory::executeParallelFor(loop_info);
70}
71
72/*---------------------------------------------------------------------------*/
73/*---------------------------------------------------------------------------*/
74
80template <typename LambdaType> inline void
81arcaneParallelForeach(const ItemVectorView& items_view, const ForLoopRunInfo& run_info,
82 const LambdaType& lambda_function)
83{
84 Int32 grain_size = impl::adaptGrainSize(run_info);
85 LambdaItemRangeFunctorT<LambdaType> ipf(items_view, lambda_function, grain_size);
86
87 ForLoopRunInfo adapted_run_info(run_info);
88 ParallelLoopOptions loop_opt(run_info.options().value_or(TaskFactory::defaultParallelLoopOptions()));
89 loop_opt.setGrainSize(ipf.blockGrainSize());
90 adapted_run_info.addOptions(loop_opt);
91
92 ParallelFor1DLoopInfo loop_info(0, ipf.nbBlock(), &ipf, adapted_run_info);
93 TaskFactory::executeParallelFor(loop_info);
94}
95
96/*---------------------------------------------------------------------------*/
97/*---------------------------------------------------------------------------*/
98
105template <typename InstanceType, typename ItemType> inline void
106arcaneParallelForeach(const ItemVectorView& items_view, const ParallelLoopOptions& options,
107 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
108{
109 arcaneParallelForeach(items_view, ForLoopRunInfo(options), instance, function);
110}
111
118template <typename InstanceType, typename ItemType> inline void
119arcaneParallelForeach(const ItemGroup& items, const ForLoopRunInfo& run_info,
120 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
121{
122 arcaneParallelForeach(items._paddedView(), run_info, instance, function);
123}
124
130template <typename InstanceType, typename ItemType> inline void
131arcaneParallelForeach(const ItemVectorView& items_view,
132 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
133{
134 arcaneParallelForeach(items_view, ForLoopRunInfo(), instance, function);
135}
136
142template <typename InstanceType, typename ItemType> inline void
143arcaneParallelForeach(const ItemGroup& items,
144 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
145{
146 arcaneParallelForeach(items._paddedView(), ForLoopRunInfo(), instance, function);
147}
148
154template <typename LambdaType> inline void
155arcaneParallelForeach(const ItemVectorView& items_view, const ParallelLoopOptions& options,
156 const LambdaType& lambda_function)
157{
158 arcaneParallelForeach(items_view, ForLoopRunInfo(options), lambda_function);
159}
160
166template <typename LambdaType> inline void
167arcaneParallelForeach(const ItemGroup& items, const ParallelLoopOptions& options,
168 const LambdaType& lambda_function)
169{
170 arcaneParallelForeach(items._paddedView(), ForLoopRunInfo(options), lambda_function);
171}
172
178template <typename LambdaType> inline void
179arcaneParallelForeach(const ItemVectorView& items_view, const LambdaType& lambda_function)
180{
181 arcaneParallelForeach(items_view, ForLoopRunInfo(), lambda_function);
182}
183
189template <typename LambdaType> inline void
190arcaneParallelForeach(const ItemGroup& items, const LambdaType& lambda_function)
191{
192 arcaneParallelForeach(items._paddedView(), lambda_function);
193}
194
195/*---------------------------------------------------------------------------*/
196/*---------------------------------------------------------------------------*/
202template <typename InstanceType> inline void
203arcaneParallelFor(Integer i0, Integer size, InstanceType* itype,
204 void (InstanceType::*lambda_function)(Integer i0, Integer size))
205{
206 RangeFunctorT<InstanceType> ipf(itype, lambda_function);
207 ParallelFor1DLoopInfo loop_info(i0, size, &ipf);
208 TaskFactory::executeParallelFor(loop_info);
209}
210
216template <typename LambdaType> inline void
217arcaneParallelFor(Integer i0, Integer size, const ForLoopRunInfo& options,
218 const LambdaType& lambda_function)
219{
220 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
221 ParallelFor1DLoopInfo loop_info(i0, size, &ipf, options);
222 TaskFactory::executeParallelFor(loop_info);
223}
224
230template <typename LambdaType> inline void
231arcaneParallelFor(Integer i0, Integer size, const ParallelLoopOptions& options,
232 const LambdaType& lambda_function)
233{
234 arcaneParallelFor(i0, size, ForLoopRunInfo(options), lambda_function);
235}
236
241template <typename LambdaType> inline void
242arcaneParallelFor(Integer i0, Integer size, const LambdaType& lambda_function)
243{
244 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
245 ParallelFor1DLoopInfo loop_info(i0, size, &ipf);
246 TaskFactory::executeParallelFor(loop_info);
247}
248
249/*---------------------------------------------------------------------------*/
250/*---------------------------------------------------------------------------*/
251
257template <typename LambdaType, typename... Views> inline void
258arcaneParallelForVa(const ForLoopRunInfo& run_info, const LambdaType& lambda_function, Views... views)
259{
260 // Asserting every views have the size
261 typename std::tuple_element_t<0, std::tuple<Views...>>::size_type sizes[] = { views.size()... };
262 if (!std::all_of(std::begin(sizes), std::end(sizes), [&sizes](auto cur) { return cur == sizes[0]; }))
263 ARCANE_FATAL("Every views must have the same size");
264
265 LambdaRangeFunctorTVa<LambdaType, Views...> ipf(views..., lambda_function);
266
267 ParallelFor1DLoopInfo loop_info(0, sizes[0], &ipf, run_info);
268 TaskFactory::executeParallelFor(loop_info);
269}
270
271/*---------------------------------------------------------------------------*/
272/*---------------------------------------------------------------------------*/
273
281namespace Parallel
282{
286 template <typename InstanceType, typename ItemType>
287 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
288 Foreach(const ItemVectorView& items_view, const ParallelLoopOptions& options,
289 InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
290 {
291 ItemRangeFunctorT<InstanceType, ItemType> ipf(items_view, instance, function, options.grainSize());
292 // Recopie \a options et utilise la valeur de 'grain_size' retournée par \a ifp
293 ParallelLoopOptions loop_opt(options);
294 loop_opt.setGrainSize(ipf.blockGrainSize());
295 TaskFactory::executeParallelFor(0, ipf.nbBlock(), loop_opt, &ipf);
296 }
297
301 template <typename InstanceType, typename ItemType>
302 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
303 Foreach(const ItemGroup& items, const ParallelLoopOptions& options, InstanceType* instance,
304 void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
305 {
306 Foreach(items._paddedView(), options, instance, function);
307 }
308
312 template <typename InstanceType, typename ItemType>
313 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
314 Foreach(const ItemVectorView& items_view, InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
315 {
316 ItemRangeFunctorT<InstanceType, ItemType> ipf(items_view, instance, function);
317 TaskFactory::executeParallelFor(0, ipf.nbBlock(), ipf.blockGrainSize(), &ipf);
318 }
319
323 template <typename InstanceType, typename ItemType>
324 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
325 Foreach(const ItemGroup& items, InstanceType* instance, void (InstanceType::*function)(ItemVectorViewT<ItemType> items))
326 {
327 Foreach(items._paddedView(), instance, function);
328 }
329
333 template <typename LambdaType>
334 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
335 Foreach(const ItemVectorView& items_view, const ParallelLoopOptions& options, const LambdaType& lambda_function)
336 {
337 LambdaItemRangeFunctorT<LambdaType> ipf(items_view, lambda_function, options.grainSize());
338 // Recopie \a options et utilise la valeur de 'grain_size' retournée par \a ifp
339 ParallelLoopOptions loop_opt(options);
340 loop_opt.setGrainSize(ipf.blockGrainSize());
341 TaskFactory::executeParallelFor(0, ipf.nbBlock(), loop_opt, &ipf);
342 }
343
347 template <typename LambdaType>
348 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
349 Foreach(const ItemGroup& items, const ParallelLoopOptions& options, const LambdaType& lambda_function)
350 {
351 Foreach(items._paddedView(), options, lambda_function);
352 }
353
357 template <typename LambdaType>
358 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
359 Foreach(const ItemVectorView& items_view, const LambdaType& lambda_function)
360 {
361 LambdaItemRangeFunctorT<LambdaType> ipf(items_view, lambda_function);
362 TaskFactory::executeParallelFor(0, ipf.nbBlock(), ipf.blockGrainSize(), &ipf);
363 }
364
368 template <typename LambdaType>
369 [[deprecated("Year2021: Use Arcane::arcaneParallelForeach() instead")]] inline void
370 Foreach(const ItemGroup& items, const LambdaType& lambda_function)
371 {
372 Foreach(items._paddedView(), lambda_function);
373 }
374
378 template <typename InstanceType> ARCANE_DEPRECATED_122 inline void
379 For(Integer i0, Integer size, Integer grain_size, InstanceType* itype,
380 void (InstanceType::*lambda_function)(Integer i0, Integer size))
381 {
382 RangeFunctorT<InstanceType> ipf(itype, lambda_function);
383 TaskFactory::executeParallelFor(i0, size, grain_size, &ipf);
384 }
385
389 template <typename InstanceType>
390 [[deprecated("Year2021: Use Arcane::arcaneParallelFor() instead")]] inline void
391 For(Integer i0, Integer size, const ParallelLoopOptions& options, InstanceType* itype,
392 void (InstanceType::*lambda_function)(Integer i0, Integer size))
393 {
394 RangeFunctorT<InstanceType> ipf(itype, lambda_function);
395 TaskFactory::executeParallelFor(i0, size, options, &ipf);
396 }
397
401 template <typename LambdaType> ARCANE_DEPRECATED_122 inline void
402 For(Integer i0, Integer size, Integer grain_size, const LambdaType& lambda_function)
403 {
404 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
405 TaskFactory::executeParallelFor(i0, size, grain_size, &ipf);
406 }
407
411 template <typename InstanceType>
412 [[deprecated("Year2021: Use Arcane::arcaneParallelFor() instead")]] inline void
413 For(Integer i0, Integer size, InstanceType* itype,
414 void (InstanceType::*lambda_function)(Integer i0, Integer size))
415 {
416 RangeFunctorT<InstanceType> ipf(itype, lambda_function);
417 TaskFactory::executeParallelFor(i0, size, &ipf);
418 }
419
423 template <typename LambdaType>
424 [[deprecated("Year2021: Use Arcane::arcaneParallelFor() instead")]] inline void
425 For(Integer i0, Integer size, const ParallelLoopOptions& options, const LambdaType& lambda_function)
426 {
427 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
428 TaskFactory::executeParallelFor(i0, size, options, &ipf);
429 }
430
434 template <typename LambdaType>
435 [[deprecated("Year2021: Use Arcane::arcaneParallelFor() instead")]] inline void
436 For(Integer i0, Integer size, const LambdaType& lambda_function)
437 {
438 LambdaRangeFunctorT<LambdaType> ipf(lambda_function);
439 TaskFactory::executeParallelFor(i0, size, &ipf);
440 }
441
442} // End namespace Parallel
443
444/*---------------------------------------------------------------------------*/
445/*---------------------------------------------------------------------------*/
446
447} // End namespace Arcane
448
449/*---------------------------------------------------------------------------*/
450/*---------------------------------------------------------------------------*/
451
452#endif
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro throwing a FatalErrorException.
Definition ArcaneGlobal.h:749
ConcurrencyUtils.h
Classes, Types, and macros for managing concurrency.
Arcane::AbstractItemRangeFunctor::nbBlock
Int32 nbBlock() const
Number of blocks.
Definition ItemFunctor.h:53
Arcane::AbstractItemRangeFunctor::blockGrainSize
Int32 blockGrainSize() const
Desired size of an iteration interval.
Definition ItemFunctor.h:56
Arcane::ForLoopRunInfo
Loop execution information.
Definition ForLoopRunInfo.h:38
Arcane::ItemGroup
Mesh entity group.
Definition ItemGroup.h:51
Arcane::ItemGroup::_paddedView
ItemVectorView _paddedView() const
View of the group entities with padding for vectorization.
Definition ItemGroup.cc:589
Arcane::ItemRangeFunctorT
Functor for iterating over a list of entities.
Definition ItemFunctor.h:81
Arcane::ItemVectorViewT
View on a typed array of entities.
Definition ItemVectorView.h:420
Arcane::ItemVectorView
View on a vector of entities.
Definition ItemVectorView.h:240
Arcane::LambdaItemRangeFunctorT
Functor on an iteration interval instantiated via a lambda function.
Definition ItemFunctor.h:124
Arcane::LambdaRangeFunctorTVa
Functor over an iteration interval instantiated via a lambda function.
Definition arccore/src/base/arccore/base/RangeFunctor.h:137
Arcane::LambdaRangeFunctorT
Functor over an iteration interval instantiated via a lambda function.
Definition arccore/src/base/arccore/base/RangeFunctor.h:73
Arcane::ParallelFor1DLoopInfo
Characteristics of a multi-thread 1D loop.
Definition ParallelFor.h:35
Arcane::ParallelLoopOptions
Execution options for a parallel loop in multi-threading.
Definition arccore/src/base/arccore/base/ParallelLoopOptions.h:35
Arcane::ParallelLoopOptions::grainSize
Integer grainSize() const
Size of an iteration interval.
Definition arccore/src/base/arccore/base/ParallelLoopOptions.h:103
Arcane::ParallelLoopOptions::setGrainSize
void setGrainSize(Integer v)
Sets the size (approximate) of an iteration interval.
Definition arccore/src/base/arccore/base/ParallelLoopOptions.h:105
Arcane::RangeFunctorT
Functor over an iteration interval.
Definition arccore/src/base/arccore/base/RangeFunctor.h:36
Arcane::TaskFactory::defaultParallelLoopOptions
static const ParallelLoopOptions & defaultParallelLoopOptions()
Default parallel loop execution options.
Definition TaskFactory.h:230
Arcane::TaskFactory::executeParallelFor
static void executeParallelFor(Integer begin, Integer size, const ParallelLoopOptions &options, IRangeFunctor *f)
Executes the functor f in parallel.
Definition TaskFactory.h:97
Arcane::arcaneParallelForeach
void arcaneParallelForeach(const ItemVectorView &items_view, const ForLoopRunInfo &run_info, InstanceType *instance, void(InstanceType::*function)(ItemVectorViewT< ItemType > items))
Applies the method function of the instance instance concurrently on the view items_view with the opt...
Definition Concurrency.h:57
Arcane::arcaneParallelForVa
void arcaneParallelForVa(const ForLoopRunInfo &run_info, const LambdaType &lambda_function, Views... views)
Applies the lambda function lambda_function instance concurrently on the container views views with t...
Definition Concurrency.h:258
Arcane::arcaneParallelFor
void arcaneParallelFor(Integer i0, Integer size, InstanceType *itype, void(InstanceType::*lambda_function)(Integer i0, Integer size))
Applies the lambda function lambda_function concurrently over the iteration range [i0,...
Definition Concurrency.h:203
Arcane::Parallel
Concurrency implementation.
Definition Concurrency.h:282
Arcane::Parallel::Foreach
void Foreach(const ItemVectorView &items_view, const ParallelLoopOptions &options, InstanceType *instance, void(InstanceType::*function)(ItemVectorViewT< ItemType > items))
Definition Concurrency.h:288
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:379
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37
Arcane::Integer
Int32 Integer
Type representing an integer.
Definition ArccoreGlobal.h:293
Arcane::Int32
std::int32_t Int32
Signed integer type of 32 bits.
Definition ArccoreGlobal.h:233