Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
MatConcurrency.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/* MatConcurrency.h (C) 2000-2021 */
9/* */
10/* Classes managing concurrency for materials. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_MATERIALS_MATCONCURRENCY_H
13#define ARCANE_MATERIALS_MATCONCURRENCY_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/UtilsTypes.h"
18#include "arcane/utils/RangeFunctor.h"
19#include "arcane/utils/FatalErrorException.h"
20
21#include "arcane/core/Concurrency.h"
22
23#include "arcane/materials/MatItemEnumerator.h"
24#include "arcane/materials/ComponentItemVectorView.h"
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
29namespace Arcane::Materials
30{
31
32/*---------------------------------------------------------------------------*/
33/*---------------------------------------------------------------------------*/
34
41template <typename ViewType, typename LambdaType>
42class LambdaMatItemRangeFunctorT
43: public IRangeFunctor
44{
45 public:
46
47 LambdaMatItemRangeFunctorT(ViewType items_view, const LambdaType& lambda_function)
48 : m_items(items_view)
49 , m_lambda_function(lambda_function)
50 {
51 }
52
53 public:
54
55 virtual void executeFunctor(Integer begin, Integer size)
56 {
57 ViewType sub_view(m_items._subView(begin, size));
58 m_lambda_function(sub_view);
59 }
60
61 private:
62
63 ViewType m_items;
64 const LambdaType& m_lambda_function;
65};
66
67/*---------------------------------------------------------------------------*/
68/*---------------------------------------------------------------------------*/
69
70} // End namespace Arcane::Materials
71
72/*---------------------------------------------------------------------------*/
73/*---------------------------------------------------------------------------*/
74
75namespace Arcane
76{
77using namespace Materials;
78
79/*---------------------------------------------------------------------------*/
80/*---------------------------------------------------------------------------*/
81
87template <typename LambdaType> inline void
88arcaneParallelForeach(const ComponentItemVectorView& items_view, const LambdaType& lambda_function)
89{
90 LambdaMatItemRangeFunctorT<ComponentItemVectorView, LambdaType> ipf(items_view, lambda_function);
91 TaskFactory::executeParallelFor(0, items_view.nbItem(), &ipf);
92}
93
99template <typename LambdaType> inline void
100arcaneParallelForeach(const ComponentItemVectorView& items_view, const ParallelLoopOptions& options,
101 const LambdaType& lambda_function)
102{
103 LambdaMatItemRangeFunctorT<ComponentItemVectorView, LambdaType> ipf(items_view, lambda_function);
104 TaskFactory::executeParallelFor(0, items_view.nbItem(), options, &ipf);
105}
106
112template <typename LambdaType> inline void
113arcaneParallelForeach(const EnvItemVectorView& items_view, const LambdaType& lambda_function)
114{
115 LambdaMatItemRangeFunctorT<EnvItemVectorView, LambdaType> ipf(items_view, lambda_function);
116 TaskFactory::executeParallelFor(0, items_view.nbItem(), &ipf);
117}
118
124template <typename LambdaType> inline void
125arcaneParallelForeach(const EnvItemVectorView& items_view, const ParallelLoopOptions& options,
126 const LambdaType& lambda_function)
127{
128 LambdaMatItemRangeFunctorT<EnvItemVectorView, LambdaType> ipf(items_view, lambda_function);
129 TaskFactory::executeParallelFor(0, items_view.nbItem(), options, &ipf);
130}
131
137template <typename LambdaType> inline void
138arcaneParallelForeach(const MatItemVectorView& items_view, const LambdaType& lambda_function)
139{
140 LambdaMatItemRangeFunctorT<MatItemVectorView, LambdaType> ipf(items_view, lambda_function);
141 TaskFactory::executeParallelFor(0, items_view.nbItem(), &ipf);
142}
143
149template <typename LambdaType> inline void
150arcaneParallelForeach(const MatItemVectorView& items_view, const ParallelLoopOptions& options,
151 const LambdaType& lambda_function)
152{
153 LambdaMatItemRangeFunctorT<MatItemVectorView, LambdaType> ipf(items_view, lambda_function);
154 TaskFactory::executeParallelFor(0, items_view.nbItem(), options, &ipf);
155}
156} // End namespace Arcane
157
158/*---------------------------------------------------------------------------*/
159/*---------------------------------------------------------------------------*/
160
161namespace Arcane::Parallel
162{
163using namespace Materials;
164using namespace Arcane;
165
171template <typename LambdaType> inline void
172Foreach(const ComponentItemVectorView& items_view, const LambdaType& lambda_function)
173{
174 arcaneParallelForeach(items_view, lambda_function);
175}
176
182template <typename LambdaType> inline void
183Foreach(const ComponentItemVectorView& items_view, const ParallelLoopOptions& options,
184 const LambdaType& lambda_function)
185{
186 arcaneParallelForeach(items_view, options, lambda_function);
187}
188
194template <typename LambdaType> inline void
195Foreach(const EnvItemVectorView& items_view, const LambdaType& lambda_function)
196{
197 arcaneParallelForeach(items_view, lambda_function);
198}
199
205template <typename LambdaType> inline void
206Foreach(const EnvItemVectorView& items_view, const ParallelLoopOptions& options,
207 const LambdaType& lambda_function)
208{
209 arcaneParallelForeach(items_view, options, lambda_function);
210}
211
217template <typename LambdaType> inline void
218Foreach(const MatItemVectorView& items_view, const LambdaType& lambda_function)
219{
220 arcaneParallelForeach(items_view, lambda_function);
221}
222
228template <typename LambdaType> inline void
229Foreach(const MatItemVectorView& items_view, const ParallelLoopOptions& options,
230 const LambdaType& lambda_function)
231{
232 arcaneParallelForeach(items_view, options, lambda_function);
233}
234
235/*---------------------------------------------------------------------------*/
236/*---------------------------------------------------------------------------*/
237
238} // End namespace Arcane::Parallel
239
240/*---------------------------------------------------------------------------*/
241/*---------------------------------------------------------------------------*/
242
243#endif
Concurrency.h
Classes, Types, and macros for managing concurrency.
UtilsTypes.h
Declarations of types used in Arcane.
Arcane::IRangeFunctor
Interface of a functor on an iteration interval.
Definition arccore/src/base/arccore/base/IRangeFunctor.h:33
Arcane::Materials::ComponentItemVectorView
View over a vector of entities of a component.
Definition core/materials/ComponentItemVectorView.h:52
Arcane::Materials::ComponentItemVectorView::nbItem
Integer nbItem() const
Number of entities in the view.
Definition core/materials/ComponentItemVectorView.h:108
Arcane::Materials::EnvItemVectorView
View over a vector of entities of an environment.
Definition core/materials/ComponentItemVectorView.h:227
Arcane::Materials::LambdaMatItemRangeFunctorT
Functor over an iteration interval instantiated via a lambda function.
Definition MatConcurrency.h:44
Arcane::Materials::LambdaMatItemRangeFunctorT::executeFunctor
virtual void executeFunctor(Integer begin, Integer size)
Executes the associated method.
Definition MatConcurrency.h:55
Arcane::Materials::MatItemVectorView
View over a vector of entities of a material.
Definition core/materials/ComponentItemVectorView.h:165
Arcane::ParallelLoopOptions
Execution options for a parallel loop in multi-threading.
Definition arccore/src/base/arccore/base/ParallelLoopOptions.h:35
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::Materials
Always enables tracing in Arcane parts concerning materials.
Definition RunCommandMaterialEnumerate.h:34
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
-- 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
Materials
Set of classes ensuring the management of materials and media.