Tulip 5.7.1
Large graphs analysis and drawing
Loading...
Searching...
No Matches
GraphParallelTools.h
1/*
2 *
3 * This file is part of Tulip (https://tulip.labri.fr)
4 *
5 * Authors: David Auber and the Tulip development Team
6 * from LaBRI, University of Bordeaux
7 *
8 * Tulip is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation, either version 3
11 * of the License, or (at your option) any later version.
12 *
13 * Tulip is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 * See the GNU General Public License for more details.
17 *
18 */
19
20#ifndef GRAPH_PARALLEL_TOOLS_H
21#define GRAPH_PARALLEL_TOOLS_H
22
23#include <tulip/Graph.h>
24#include <tulip/ParallelTools.h>
25
26namespace tlp {
27
28// ===================================================================================
29
30template <typename NodeIndexFunction>
31void inline TLP_MAP_NODES_AND_INDICES(const tlp::Graph *graph,
32 const NodeIndexFunction &nodeIndexFunction) {
33 unsigned int i = 0;
34 for (auto n : graph->nodes()) {
35 nodeIndexFunction(n, i++);
36 }
37}
38
39// ===================================================================================
40
41/**
42 * Template function to ease the creation of OpenMP parallel jobs taking
43 * a graph node as parameter.
44 *
45 * @since Tulip 5.2
46 *
47 * @param graph the graph on which to run job on the nodes
48 * @param nodeFunction callable object (e.g. lambda function) taking a tlp::node as parameter
49 *
50 * Example of use:
51 *
52 * @code
53 * auto computationIntensiveTask = [&](const tlp::node &n) {
54 * double result = 0;
55 * ...
56 * return result;
57 * };
58 * tlp::NodeStaticProperty<double> result(graph);
59 * TLP_PARALLEL_MAP_NODES(graph, [&](const tlp::node &n) {
60 * // run task in a thread
61 * result[n] = computationIntensiveTask(n);
62 * });
63 * @endcode
64 */
65template <typename NodeFunction>
66void inline TLP_PARALLEL_MAP_NODES(const tlp::Graph *graph, const NodeFunction &nodeFunction) {
67 TLP_PARALLEL_MAP_VECTOR<tlp::node, NodeFunction>(graph->nodes(), nodeFunction);
68}
69
70// ===================================================================================
71
72/**
73 * Template function to ease the creation of OpenMP parallel jobs taking
74 * a graph node and its iteration index as parameter.
75 *
76 * @since Tulip 5.2
77 *
78 * @param graph the graph on which to run job on the nodes
79 * @param nodeIndexFunction callable object (e.g. lambda function) taking a tlp::node and
80 * and unsigned integer as parameter
81 *
82 * Example of use:
83 *
84 * @code
85 * auto computationIntensiveTask = [&](const tlp::node &n, unsigned int i) {
86 * double result = 0;
87 * ...
88 * return result;
89 * };
90 * tlp::NodeStaticProperty<double> result(graph);
91 * TLP_PARALLEL_MAP_EDGES(graph, [&](const tlp::node &n, unsigned int i) {
92 * // run task in a thread
93 * result[n] = computationIntensiveTask(n, i);
94 * });
95 * @endcode
96 */
97template <typename NodeFunction>
99 const NodeFunction &nodeFunction) {
100 TLP_PARALLEL_MAP_VECTOR_AND_INDICES<tlp::node, NodeFunction>(graph->nodes(), nodeFunction);
101}
102
103// ===================================================================================
104
105template <typename EdgeIndexFunction>
106void inline TLP_MAP_EDGES_AND_INDICES(const tlp::Graph *graph,
107 const EdgeIndexFunction &edgeIndexFunction) {
108 unsigned int i = 0;
109 for (auto e : graph->edges()) {
110 edgeIndexFunction(e, i++);
111 }
112}
113
114// ===================================================================================
115
116/**
117 * Template function to ease the creation of OpenMP parallel jobs taking
118 * a graph edge as parameter.
119 *
120 * @since Tulip 5.2
121 *
122 * @param graph the graph on which to run job on the edges
123 * @param edgeFunction callable object (e.g. lambda function) taking a tlp::edge as parameter
124 *
125 * Example of use:
126 *
127 * @code
128 * auto computationIntensiveTask = [&](const tlp::edge &e) {
129 * double result = 0;
130 * ...
131 * return result;
132 * };
133 * tlp::EdgeStaticProperty<double> result(graph);
134 * TLP_PARALLEL_MAP_EDGES(graph, [&](const tlp::edge &e) {
135 * // run task in a thread
136 * result[e] = computationIntensiveTask(e);
137 * });
138 * @endcode
139 */
140template <typename EdgeFunction>
141void inline TLP_PARALLEL_MAP_EDGES(const tlp::Graph *graph, const EdgeFunction &edgeFunction) {
142 TLP_PARALLEL_MAP_VECTOR<tlp::edge, EdgeFunction>(graph->edges(), edgeFunction);
143}
144
145// ===================================================================================
146
147/**
148 * Template function to ease the creation of OpenMP parallel jobs taking
149 * a graph edge and its iteration index as parameter.
150 *
151 * @since Tulip 5.2
152 *
153 * @param graph the graph on which to run job on the edges
154 * @param edgeIndexFunction callable object (e.g. lambda function) taking a tlp::edge and
155 * and unsigned integer as parameter
156 *
157 * Example of use:
158 *
159 * @code
160 * auto computationIntensiveTask = [&](const tlp::edge &e, unsigned int i) {
161 * double result = 0;
162 * ...
163 * return result;
164 * };
165 * tlp::EdgeStaticProperty<double> result(graph);
166 * TLP_PARALLEL_MAP_EDGES(graph, [&](const tlp::edge &e, unsigned int i) {
167 * // run task in a thread
168 * result[e] = computationIntensiveTask(e, i);
169 * });
170 * @endcode
171 */
172template <typename EdgeFunction>
174 const EdgeFunction &edgeFunction) {
175 TLP_PARALLEL_MAP_VECTOR_AND_INDICES<tlp::edge, EdgeFunction>(graph->edges(), edgeFunction);
176}
177} // namespace tlp
178
179#endif
virtual const std::vector< edge > & edges() const =0
Return a const reference on the vector of edges of the graph It is the fastest way to access to edges...
virtual const std::vector< node > & nodes() const =0
Return a const reference on the vector of nodes of the graph It is the fastest way to access to nodes...
void TLP_PARALLEL_MAP_EDGES(const tlp::Graph *graph, const EdgeFunction &edgeFunction)
void TLP_PARALLEL_MAP_EDGES_AND_INDICES(const tlp::Graph *graph, const EdgeFunction &edgeFunction)
void TLP_PARALLEL_MAP_NODES_AND_INDICES(const tlp::Graph *graph, const NodeFunction &nodeFunction)
void TLP_PARALLEL_MAP_NODES(const tlp::Graph *graph, const NodeFunction &nodeFunction)