Debian Codegraph @

src/atlas/grid/detail/partitioner/Partitioner.cc

raw
1 /*
2 * (C) Copyright 2013 ECMWF.
3 *
4 * This software is licensed under the terms of the Apache Licence Version 2.0
5 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
6 * In applying this licence, ECMWF does not waive the privileges and immunities
7 * granted to it by virtue of its status as an intergovernmental organisation
8 * nor does it submit to any jurisdiction.
9 */
10
11 // file deepcode ignore CppMemoryLeak: static pointers for global registry are OK and will be cleaned up at end
12
13 #include "atlas/grid/detail/partitioner/Partitioner.h"
14
15 #include <map>
16 #include <string>
17
18 #include "eckit/thread/AutoLock.h"
19 #include "eckit/thread/Mutex.h"
20
21 #include "atlas/grid/Distribution.h"
22 #include "atlas/grid/Partitioner.h"
23 #include "atlas/grid/detail/distribution/DistributionArray.h"
24 #include "atlas/grid/detail/partitioner/BandsPartitioner.h"
25 #include "atlas/grid/detail/partitioner/CheckerboardPartitioner.h"
26 #include "atlas/grid/detail/partitioner/CubedSpherePartitioner.h"
27 #include "atlas/grid/detail/partitioner/EqualBandsPartitioner.h"
28 #include "atlas/grid/detail/partitioner/EqualRegionsPartitioner.h"
29 #include "atlas/grid/detail/partitioner/MatchingFunctionSpacePartitionerLonLatPolygon.h"
30 #include "atlas/grid/detail/partitioner/MatchingMeshPartitioner.h"
31 #include "atlas/grid/detail/partitioner/MatchingMeshPartitionerBruteForce.h"
32 #include "atlas/grid/detail/partitioner/MatchingMeshPartitionerCubedSphere.h"
33 #include "atlas/grid/detail/partitioner/MatchingMeshPartitionerLonLatPolygon.h"
34 #include "atlas/grid/detail/partitioner/MatchingMeshPartitionerSphericalPolygon.h"
35 #include "atlas/grid/detail/partitioner/RegularBandsPartitioner.h"
36 #include "atlas/grid/detail/partitioner/SerialPartitioner.h"
37 #include "atlas/library/config.h"
38 #include "atlas/parallel/mpi/mpi.h"
39 #include "atlas/runtime/Exception.h"
40 #include "atlas/runtime/Log.h"
41 #include "atlas/util/Config.h"
42
43 #if ATLAS_HAVE_TRANS
44 #include "atlas/grid/detail/partitioner/TransPartitioner.h"
45 #endif
46
47 namespace {
48
49 static eckit::Mutex* local_mutex = nullptr;
50 static std::map<std::string, atlas::grid::detail::partitioner::PartitionerFactory*>* m = nullptr;
51 static pthread_once_t once = PTHREAD_ONCE_INIT;
52
53 static void init() {
54 local_mutex = new eckit::Mutex();
55 m = new std::map<std::string, atlas::grid::detail::partitioner::PartitionerFactory*>();
56 }
57 } // namespace
58
59 namespace atlas {
60 namespace grid {
61 namespace detail {
62 namespace partitioner {
63
64 int Partitioner::extract_nb_partitions(const eckit::Parametrisation& config) {
65 int N;
66 if (config.has("mpi_comm")) {
67 std::string mpi_comm;
68 config.get("mpi_comm",mpi_comm);
69 N = mpi::comm(mpi_comm).size();
70 }
71 else {
72 N = mpi::size();
73 }
74 config.get("partitions",N);
75 config.get("nb_partitions",N);
76 config.get("nb_parts",N);
77 return N;
78 }
79 std::string Partitioner::extract_mpi_comm(const eckit::Parametrisation& config) {
80 if (config.has("mpi_comm")) {
81 std::string mpi_comm;
82 config.get("mpi_comm",mpi_comm);
83 return mpi_comm;
84 }
85 return mpi::comm().name();
86 }
87
88
89 Partitioner::Partitioner():
90 Partitioner(util::NoConfig()) {
91 }
92
93 Partitioner::Partitioner(const idx_t nb_partitions, const eckit::Parametrisation& config):
94 nb_partitions_(nb_partitions),
95 mpi_comm_(extract_mpi_comm(config)) {
96 }
97
98 Partitioner::Partitioner(const eckit::Parametrisation& config) :
99 nb_partitions_(extract_nb_partitions(config)),
100 mpi_comm_(extract_mpi_comm(config)) {
101 }
102
103 Partitioner::~Partitioner() = default;
104
105 idx_t Partitioner::nb_partitions() const {
106 return nb_partitions_;
107 }
108
109 Distribution Partitioner::partition(const Grid& grid) const {
110 return new distribution::DistributionArray{grid, atlas::grid::Partitioner(this)};
111 }
112
113 std::string Partitioner::mpi_comm() const { return mpi_comm_; }
114
115 namespace {
116
117 template <typename T>
118 void load_builder() {
119 PartitionerBuilder<T>("tmp");
120 }
121
122 struct force_link {
123 force_link() {
124 load_builder<EqualRegionsPartitioner>();
125 load_builder<CheckerboardPartitioner>();
126 load_builder<CubedSpherePartitioner>();
127 load_builder<BandsPartitioner>();
128 load_builder<EqualBandsPartitioner>();
129 load_builder<RegularBandsPartitioner>();
130 load_builder<SerialPartitioner>();
131 #if ATLAS_HAVE_TRANS
132 load_builder<TransPartitioner>();
133 #endif
134 }
135 };
136
137 } // namespace
138
139 PartitionerFactory::PartitionerFactory(const std::string& name): name_(name) {
140 pthread_once(&once, init);
141
142 eckit::AutoLock<eckit::Mutex> lock(local_mutex);
143
144 if (m->find(name) != m->end()) {
145 throw_Exception("Partitioner with name [" + name + "] is already registered.", Here());
146 }
147 (*m)[name] = this;
148 }
149
150 PartitionerFactory::~PartitionerFactory() {
151 eckit::AutoLock<eckit::Mutex> lock(local_mutex);
152 m->erase(name_);
153 }
154
155 void PartitionerFactory::list(std::ostream& out) {
156 pthread_once(&once, init);
157
158 eckit::AutoLock<eckit::Mutex> lock(local_mutex);
159
160 static force_link static_linking;
161
162 const char* sep = "";
163 for (std::map<std::string, PartitionerFactory*>::const_iterator j = m->begin(); j != m->end(); ++j) {
164 out << sep << (*j).first;
165 sep = ", ";
166 }
167 }
168
169 bool PartitionerFactory::has(const std::string& name) {
170 pthread_once(&once, init);
171
172 eckit::AutoLock<eckit::Mutex> lock(local_mutex);
173
174 static force_link static_linking;
175
176 return (m->find(name) != m->end());
177 }
178
179 Partitioner* PartitionerFactory::build(const std::string& name) {
180 pthread_once(&once, init);
181
182 eckit::AutoLock<eckit::Mutex> lock(local_mutex);
183
184 static force_link static_linking;
185
186 std::map<std::string, PartitionerFactory*>::const_iterator j = m->find(name);
187
188 Log::debug() << "Looking for PartitionerFactory [" << name << "]" << std::endl;
189
190 if (j == m->end()) {
191 Log::error() << "No PartitionerFactory for [" << name << "]" << '\n';
192 Log::error() << "PartitionerFactories are:" << '\n';
193 for (j = m->begin(); j != m->end(); ++j) {
194 Log::error() << " " << (*j).first << '\n';
195 }
196 Log::error() << std::flush;
197 throw_Exception(std::string("No PartitionerFactory called ") + name);
198 }
199
200 return (*j).second->make();
201 }
202
203 Partitioner* PartitionerFactory::build(const std::string& name, const idx_t nb_partitions) {
204 return build(name, nb_partitions, util::NoConfig());
205 }
206
207 Partitioner* PartitionerFactory::build(const std::string& name, const idx_t nb_partitions,
208 const eckit::Parametrisation& config) {
209 pthread_once(&once, init);
210
211 eckit::AutoLock<eckit::Mutex> lock(local_mutex);
212
213 static force_link static_linking;
214
215 std::map<std::string, PartitionerFactory*>::const_iterator j = m->find(name);
216
217 Log::debug() << "Looking for PartitionerFactory [" << name << "]" << '\n';
218
219 if (j == m->end()) {
220 Log::error() << "No PartitionerFactory for [" << name << "]" << '\n';
221 Log::error() << "PartitionerFactories are:" << '\n';
222 for (j = m->begin(); j != m->end(); ++j) {
223 Log::error() << " " << (*j).first << '\n';
224 }
225 throw_Exception(std::string("No PartitionerFactory called ") + name);
226 }
227
228 return (*j).second->make(nb_partitions, config);
229 }
230
231 Partitioner* PartitionerFactory::build(const std::string& name,
232 const eckit::Parametrisation& config) {
233 pthread_once(&once, init);
234
235 eckit::AutoLock<eckit::Mutex> lock(local_mutex);
236
237 static force_link static_linking;
238
239 std::map<std::string, PartitionerFactory*>::const_iterator j = m->find(name);
240
241 Log::debug() << "Looking for PartitionerFactory [" << name << "]" << '\n';
242
243 if (j == m->end()) {
244 Log::error() << "No PartitionerFactory for [" << name << "]" << '\n';
245 Log::error() << "PartitionerFactories are:" << '\n';
246 for (j = m->begin(); j != m->end(); ++j) {
247 Log::error() << " " << (*j).first << '\n';
248 }
249 throw_Exception(std::string("No PartitionerFactory called ") + name);
250 }
251
252 return (*j).second->make(config);
253 }
254
255
256
257 Partitioner* MatchingPartitionerFactory::build(const std::string& type, const Mesh& partitioned, const eckit::Parametrisation& config) {
258 if (type == MatchingMeshPartitionerSphericalPolygon::static_type()) {
259 return new MatchingMeshPartitionerSphericalPolygon(partitioned, config);
260 }
261 else if (type == MatchingMeshPartitionerLonLatPolygon::static_type()) {
262 return new MatchingMeshPartitionerLonLatPolygon(partitioned, config);
263 }
264 else if (type == MatchingMeshPartitionerBruteForce::static_type()) {
265 return new MatchingMeshPartitionerBruteForce(partitioned, config);
266 }
267 else if (type == MatchingMeshPartitionerCubedSphere::static_type()) {
268 return new MatchingMeshPartitionerCubedSphere(partitioned, config);
269 }
270 else {
271 ATLAS_NOTIMPLEMENTED;
272 }
273 }
274
275 Partitioner* MatchingPartitionerFactory::build(const std::string& type, const FunctionSpace& partitioned, const eckit::Parametrisation& config) {
276 if (type == MatchingFunctionSpacePartitionerLonLatPolygon::static_type()) {
277 return new MatchingFunctionSpacePartitionerLonLatPolygon(partitioned, config);
278 }
279 else {
280 ATLAS_NOTIMPLEMENTED;
281 }
282 }
283
284 } // namespace partitioner
285 } // namespace detail
286 } // namespace grid
287 } // namespace atlas