VTK
vtkPBGLGraphAdapter.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkPBGLGraphAdapter.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================*/
15/*
16 * Copyright (C) 2008 The Trustees of Indiana University.
17 * Use, modification and distribution is subject to the Boost Software
18 * License, Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt)
19 */
29#ifndef vtkPBGLGraphAdapter_h
30#define vtkPBGLGraphAdapter_h
31
32#include "vtkBoostGraphAdapter.h" // for the sequential BGL adapters
33
34#include <map> // required for Boost 1.54.0
35#include <boost/graph/use_mpi.hpp>
36#include <boost/graph/distributed/mpi_process_group.hpp>
37#include <boost/graph/properties.hpp>
38#include <boost/graph/parallel/container_traits.hpp>
39#include <boost/property_map/parallel/local_property_map.hpp>
40#include <boost/property_map/parallel/distributed_property_map.hpp>
41#include <boost/serialization/base_object.hpp>
42#include <boost/functional/hash.hpp>
43
46
47namespace boost {
48
49// Define specializations of class template property_map for
50// vtkDirectedGraph and vtkUndirectedGraph, based on the
51// specialization for vtkGraph.
52#define SUBCLASS_PROPERTY_MAP_SPECIALIZATIONS(Property) \
53 template<> \
54 struct property_map<vtkDirectedGraph *, Property> \
55 : property_map<vtkGraph *, Property> { }; \
56 \
57 template<> \
58 struct property_map<vtkUndirectedGraph *, Property> \
59 : property_map<vtkGraph *, Property> { }; \
60 \
61 template<> \
62 struct property_map<vtkDirectedGraph * const, Property> \
63 : property_map<vtkGraph *, Property> { }; \
64 \
65 template<> \
66 struct property_map<vtkUndirectedGraph * const, Property> \
67 : property_map<vtkGraph *, Property> { }
68
69 // Property map from a vertex descriptor to the owner of the vertex
71 {
72 // Default-construct an empty (useless!) vertex-owner map
74
75 // Construct a vertex-owner map for a specific vtkGraph
76 explicit vtkVertexOwnerMap(vtkGraph* graph)
77 : helper(graph? graph->GetDistributedGraphHelper() : 0) { }
78
79 // The distributed graph helper that will aid in mapping vertices
80 // to their owners.
82 };
83
84 // Property map traits for the vertex-owner map
85 template<>
87 {
91 typedef readable_property_map_tag category;
92 };
93
94 // Retrieve the owner of the given vertex (the key)
97 vtkVertexOwnerMap owner_map,
99 {
100 return owner_map.helper->GetVertexOwner(key);
101 }
102
103 // State that the vertex owner property map of a vtkGraph is the
104 // vtkVertexOwnerMap
105 template<>
106 struct property_map<vtkGraph*, vertex_owner_t>
107 {
110 };
111
113
114 // Retrieve the vertex-owner property map from a vtkGraph
115 inline vtkVertexOwnerMap
116 get(vertex_owner_t, vtkGraph* graph)
117 {
118 return vtkVertexOwnerMap(graph);
119 }
120
121 // Property map from a vertex descriptor to the local descriptor of
122 // the vertex
124 {
125 // Default-construct an empty (useless!) vertex-local map
127
128 // Construct a vertex-local map for a specific vtkGraph
130 : helper(graph? graph->GetDistributedGraphHelper() : 0) { }
131
132 // The distributed graph helper that will aid in mapping vertices
133 // to their locals.
135 };
136
137 // Property map traits for the vertex-local map
138 template<>
140 {
141 typedef int value_type;
142 typedef int reference;
144 typedef readable_property_map_tag category;
145 };
146
147 // Retrieve the local descriptor of the given vertex (the key)
150 vtkVertexLocalMap local_map,
152 {
153 return local_map.helper->GetVertexIndex(key);
154 }
155
156 // State that the vertex local property map of a vtkGraph is the
157 // vtkVertexLocalMap
158 template<>
159 struct property_map<vtkGraph*, vertex_local_t>
160 {
163 };
164
166
167 // Retrieve the vertex-local property map from a vtkGraph
168 inline vtkVertexLocalMap
169 get(vertex_local_t, vtkGraph* graph)
170 {
171 return vtkVertexLocalMap(graph);
172 }
173
174 // Map from vertex descriptor to (owner, local descriptor)
176 {
178
180 : helper(graph? graph->GetDistributedGraphHelper() : 0) { }
181
183 };
184
185 template<>
187 {
188 typedef std::pair<int, vtkIdType> value_type;
191 typedef readable_property_map_tag category;
192 };
193
196 vtkVertexGlobalMap global_map,
198 {
199 return std::pair<int,vtkIdType>(global_map.helper->GetVertexOwner(key),
200 global_map.helper->GetVertexIndex(key));
201 }
202
203 //
204 template<>
205 struct property_map<vtkGraph*, vertex_global_t>
206 {
209 };
210
212
213 inline vtkVertexGlobalMap
214 get(vertex_global_t, vtkGraph* graph)
215 {
216 return vtkVertexGlobalMap(graph);
217 }
218
219 // Map from edge descriptor to (owner, local descriptor)
221 {
223
224 explicit vtkEdgeGlobalMap(vtkGraph* graph)
225 : helper(graph? graph->GetDistributedGraphHelper() : 0) { }
226
228 };
229
230 template<>
232 {
233 typedef std::pair<int, vtkIdType> value_type;
236 typedef readable_property_map_tag category;
237 };
238
241 vtkEdgeGlobalMap global_map,
243 {
244 return std::pair<int, vtkIdType>
245 (global_map.helper->GetEdgeOwner(key.Id), key.Id);
246 }
247
248 //
249 template<>
250 struct property_map<vtkGraph*, edge_global_t>
251 {
254 };
255
257
258 inline vtkEdgeGlobalMap
259 get(edge_global_t, vtkGraph* graph)
260 {
261 return vtkEdgeGlobalMap(graph);
262 }
263
264#undef SUBCLASS_PROPERTY_MAP_SPECIALIZATIONS
265
266 //===========================================================================
267 // Hash functions
268 template<>
269 struct hash<vtkEdgeType>
270 {
271 std::size_t operator()(const vtkEdgeType& edge) const
272 {
273 return hash_value(edge.Id);
274 }
275 };
276
277} // namespace boost
278
279//----------------------------------------------------------------------------
280// Extract the process group from a vtkGraph
281//----------------------------------------------------------------------------
282
283namespace boost { namespace graph { namespace parallel {
284 template<>
285 struct process_group_type<vtkGraph *>
286 {
287 typedef boost::graph::distributed::mpi_process_group type;
288 };
289
290 template<>
291 struct process_group_type<vtkDirectedGraph *>
293
294 template<>
295 struct process_group_type<vtkUndirectedGraph *>
297
298 template<>
299 struct process_group_type<vtkDirectedGraph * const>
301
302 template<>
303 struct process_group_type<vtkUndirectedGraph * const>
305} } } // end namespace boost::graph::parallel
306
307boost::graph::distributed::mpi_process_group process_group(vtkGraph *graph);
308
309inline boost::graph::distributed::mpi_process_group
311{
312 return process_group(static_cast<vtkGraph *>(graph));
313}
314
315inline boost::graph::distributed::mpi_process_group
317{
318 return process_group(static_cast<vtkGraph *>(graph));
319}
320
321//----------------------------------------------------------------------------
322// Serialization support for simple VTK structures
323//----------------------------------------------------------------------------
324
325//----------------------------------------------------------------------------
326template<typename Archiver>
327void serialize(Archiver& ar, vtkEdgeBase& edge, const unsigned int)
328{
329 ar & edge.Id;
330}
331
332template<typename Archiver>
333void serialize(Archiver& ar, vtkOutEdgeType& edge, const unsigned int)
334{
335 ar & boost::serialization::base_object<vtkEdgeBase>(edge)
336 & edge.Target;
337}
338
339template<typename Archiver>
340void serialize(Archiver& ar, vtkInEdgeType& edge, const unsigned int)
341{
342 ar & boost::serialization::base_object<vtkEdgeBase>(edge)
343 & edge.Source;
344}
345
346template<typename Archiver>
347void serialize(Archiver& ar, vtkEdgeType& edge, const unsigned int)
348{
349 ar & boost::serialization::base_object<vtkEdgeBase>(edge)
350 & edge.Source
351 & edge.Target;
352}
353
354//----------------------------------------------------------------------------
355// Simplified tools to build distributed property maps
356//----------------------------------------------------------------------------
357
365typedef boost::local_property_map<boost::graph::distributed::mpi_process_group,
369
371
376{
378 if (!helper)
379 {
380 vtkErrorWithObjectMacro(graph, "A vtkGraph without a distributed graph helper is not a distributed graph");
382 }
384
387 if (!pbglHelper)
388 {
389 vtkErrorWithObjectMacro(graph, "A vtkGraph with a non-Parallel BGL distributed graph helper cannot be used with the Parallel BGL");
391 }
392
396}
397
399
403template<typename DataArray>
405{
406 typedef boost::parallel::distributed_property_map<
407 boost::graph::distributed::mpi_process_group,
409 DataArray*> type;
410};
412
417template<typename DataArray>
420{
422
424 if (!helper)
425 {
426 vtkErrorWithObjectMacro(graph, "A vtkGraph without a distributed graph helper is not a distributed graph");
427 return MapType();
428 }
429
432 if (!pbglHelper)
433 {
434 vtkErrorWithObjectMacro(graph, "A vtkGraph with a non-Parallel BGL distributed graph helper cannot be used with the Parallel BGL");
435 return MapType();
436 }
437
438 return MapType(pbglHelper->GetProcessGroup(),
440 array);
441}
442
444
448template<typename DataArray>
450{
451 typedef boost::parallel::distributed_property_map<
452 boost::graph::distributed::mpi_process_group,
454 DataArray*> type;
455};
457
462template<typename DataArray>
465{
467
469 if (!helper)
470 {
471 vtkErrorWithObjectMacro(graph, "A vtkGraph without a distributed graph helper is not a distributed graph");
472 return MapType();
473 }
474
477 if (!pbglHelper)
478 {
479 vtkErrorWithObjectMacro(graph, "A vtkGraph with a non-Parallel BGL distributed graph helper cannot be used with the Parallel BGL");
480 return MapType();
481 }
482
483 return MapType(pbglHelper->GetProcessGroup(),
485 array);
486}
487
488#endif // vtkPBGLGraphAdapter_h
489// VTK-HeaderTest-Exclude: vtkPBGLGraphAdapter.h
A directed graph.
helper for the vtkGraph class that allows the graph to be distributed across multiple memory spaces.
vtkIdType GetEdgeOwner(vtkIdType e_id) const
Returns owner of edge with ID e_id, by extracting top ceil(log2 P) bits of e_id.
vtkIdType GetVertexOwner(vtkIdType v) const
Returns owner of vertex v, by extracting top ceil(log2 P) bits of v.
vtkIdType GetVertexIndex(vtkIdType v) const
Returns local index of vertex v, by masking off top ceil(log2 P) bits of v.
Base class for graph data types.
Definition: vtkGraph.h:288
vtkDistributedGraphHelper * GetDistributedGraphHelper()
Retrieves the distributed graph helper for this graph.
end namespace boost::graph::distributed
boost::graph::distributed::mpi_process_group GetProcessGroup()
Return the process group associated with this distributed graph.
static vtkPBGLDistributedGraphHelper * SafeDownCast(vtkObjectBase *o)
An undirected graph.
Forward declaration required for Boost serialization.
double get(vtkDataArray *const &arr, vtkIdType key)
SUBCLASS_PROPERTY_MAP_SPECIALIZATIONS(vertex_owner_t)
@ key
Definition: vtkX3D.h:257
boost::graph::distributed::mpi_process_group type
std::size_t operator()(const vtkEdgeType &edge) const
vtkDistributedGraphHelper * helper
vtkEdgeGlobalMap(vtkGraph *graph)
vtkVertexGlobalMap(vtkGraph *graph)
vtkDistributedGraphHelper * helper
vtkVertexLocalMap(vtkGraph *graph)
vtkDistributedGraphHelper * helper
vtkVertexOwnerMap(vtkGraph *graph)
vtkDistributedGraphHelper * helper
Retrieves the type of the distributed property map indexed by the edges of a distributed graph.
boost::parallel::distributed_property_map< boost::graph::distributed::mpi_process_group, boost::vtkEdgeGlobalMap, DataArray * > type
Retrieves the type of the distributed property map indexed by the vertices of a distributed graph.
boost::parallel::distributed_property_map< boost::graph::distributed::mpi_process_group, boost::vtkVertexGlobalMap, DataArray * > type
vtkIdType Id
Definition: vtkGraph.h:255
vtkIdType Target
Definition: vtkGraph.h:284
vtkIdType Source
Definition: vtkGraph.h:283
vtkIdType Source
Definition: vtkGraph.h:273
vtkIdType Target
Definition: vtkGraph.h:264
vtkGraphDistributedVertexIndexMap MakeDistributedVertexIndexMap(vtkGraph *graph)
Creates the distributed vertex index property map for a vtkGraph.
boost::graph::distributed::mpi_process_group process_group(vtkGraph *graph)
vtkDistributedEdgePropertyMapType< DataArray >::type MakeDistributedEdgePropertyMap(vtkGraph *graph, DataArray *array)
Build a distributed property map indexed by the edges of the given graph, using storage from the give...
void serialize(Archiver &ar, vtkEdgeBase &edge, const unsigned int)
vtkDistributedVertexPropertyMapType< DataArray >::type MakeDistributedVertexPropertyMap(vtkGraph *graph, DataArray *array)
Build a distributed property map indexed by the vertices of the given graph, using storage from the g...
boost::local_property_map< boost::graph::distributed::mpi_process_group, boost::vtkVertexGlobalMap, boost::vtkGraphIndexMap > vtkGraphDistributedVertexIndexMap
A property map used as the vertex index map for distributed vtkGraphs.
int vtkIdType
Definition: vtkType.h:287