Zoltan2
Loading...
Searching...
No Matches
Zoltan2_AlgSarma.hpp
Go to the documentation of this file.
1
5#pragma once
6
7#include <Teuchos_ParameterEntryValidator.hpp>
11#include <Zoltan2_Util.hpp>
12#include <Zoltan2_TPLTraits.hpp>
13
14#ifndef HAVE_ZOLTAN2_SARMA
15
16namespace Zoltan2 {
17 template<typename Adapter>
18 class AlgSarma : public Algorithm<Adapter> {
19 public:
20 using base_adapter_t = typename Adapter::base_adapter_t;
21
22 AlgSarma(const RCP<const Environment> &/* env */,
23 const RCP<const Comm<int> > &/* problemComm */,
24 const RCP<const base_adapter_t> &/* adapter */) {
25 throw std::runtime_error("SARMA requested but not enabled into Zoltan2\n"
26 "Please set CMake flag TPL_ENABLE_SARMA:BOOL=ON");
27 }
28 };
29}
30
31#else
32
33#include <map>
34#include <utility>
35#include <vector>
36#include <iostream>
37#include <fstream>
38#include <sarma/sarma.hpp>
39
40namespace Zoltan2 {
41 template<typename Adapter>
42 class AlgSarma : public Algorithm<Adapter> {
43 public:
44 using base_adapter_t = typename Adapter::base_adapter_t;
45 using lno_t = typename Adapter::lno_t;
46 using gno_t = typename Adapter::gno_t;
47 using offset_t = typename Adapter::offset_t;
48 using scalar_t = typename Adapter::scalar_t;
49 using part_t = typename Adapter::part_t;
50 using user_t = typename Adapter::user_t;
51 using userCoord_t = typename Adapter::userCoord_t;
52
53 private:
54 const offset_t *offsets;
55 const gno_t *colids;
56 const scalar_t *vals;
57 size_t offsize;
58 size_t nnz;
59
60 public:
61 AlgSarma(const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
62 const RCP<const IdentifierAdapter <user_t> > &adapter)
63 : env(env), comm(comm), adapter(adapter),
64 algs(sarma::get_algorithm_map<Ordinal, Value>()), orders(sarma::get_order_map()) {
65 throw std::runtime_error("Cannot build SARMA from IdentifierAdapter");
66 }
67
68 AlgSarma(const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
69 const RCP<const VectorAdapter <user_t> > &adapter)
70 : env(env), comm(comm), adapter(adapter),
71 algs(sarma::get_algorithm_map<Ordinal, Value>()), orders(sarma::get_order_map()) {
72 throw std::runtime_error("Cannot build SARMA from VectorAdapter");
73
74 }
75
76 AlgSarma(const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
77 const RCP<const GraphAdapter <user_t, userCoord_t> > &adapter)
78 : env(env), comm(comm), adapter(adapter),
79 algs(sarma::get_algorithm_map<Ordinal, Value>()), orders(sarma::get_order_map()) {
80 throw std::runtime_error("Cannot build SARMA from GraphAdapter");
81 }
82
83 AlgSarma(const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
84 const RCP<const MeshAdapter <user_t> > &adapter)
85 : env(env), comm(comm), adapter(adapter),
86 algs(sarma::get_algorithm_map<Ordinal, Value>()), orders(sarma::get_order_map()) {
87
88 throw std::runtime_error("Cannot build SARMA from MeshAdapter");
89 }
90
91 AlgSarma(const RCP<const Environment> &env, const RCP<const Comm<int> > &comm,
92 const RCP<const MatrixAdapter <user_t, userCoord_t> > &adapter)
93 : env(env), comm(comm), adapter(adapter),
94 offsize(1 + adapter->getLocalNumRows()), nnz(adapter->getLocalNumEntries()),
95 algs(sarma::get_algorithm_map<Ordinal, Value>()), orders(sarma::get_order_map()) {
96 getParams();
97 if (adapter->CRSViewAvailable()) {
98 offsets = new offset_t[offsize]();
99 colids = new gno_t[nnz]();
100 vals = new scalar_t[nnz]();
101 adapter->getCRSView(offsets, colids, vals);
102 } else
103 throw std::runtime_error("NO CRS Available");
104 }
105
106 static void getValidParameters(ParameterList &pl) {
107 RCP<const Teuchos::ParameterEntryValidator> validator;
108 pl.set("sarma_parameters", ParameterList(), "Sarma options", validator);
109 }
110
111 void partition(const RCP <PartitioningSolution<Adapter>> &solution);
112 private:
113 const RCP<const Environment> env;
114 const RCP<const Comm<int> > comm;
115 const RCP<const base_adapter_t> adapter;
116 RCP<const CoordinateModel <base_adapter_t> > model;
117
118 struct Parameters {
119 std::string alg = "pal";
120 sarma::Order order_type = sarma::Order::NAT;
121 std::string order_str = "nat";
122 Ordinal row_parts = 8, col_parts = 0;
123 Value max_load = 0;
124 int seed = 2147483647;
125 double sparsify = 1.0;
126 bool triangular = false, use_data = false;
127 };
128
129 std::map <std::string, std::pair<std::function < std::pair < std::vector < Ordinal>, std::vector<Ordinal>>(
130 const sarma::Matrix <Ordinal, Value> &, const Ordinal, const Ordinal, const Value, const int)>, bool>>
131 algs;
132 std::map <std::string, sarma::Order> orders;
133 Parameters config;
134
135// void buildModel(modelFlag_t &flags);
136 void getParams();
137
138 };
139
140 template<typename Adapter>
141 void AlgSarma<Adapter>::getParams() {
142 const Teuchos::ParameterList &pl = env->getParameters();
143 const Teuchos::ParameterList &sparams = pl.sublist("sarma_parameters");
144
145 // Set Params
146 const Teuchos::ParameterEntry *pe = sparams.getEntryPtr("alg");
147 if (pe)
148 config.alg = pe->getValue(&config.alg);
149 pe = sparams.getEntryPtr("order");
150 if (pe) {
151 std::string s;
152 s = pe->getValue(&s);
153 if (orders.find(s) == orders.end()) {
154 throw std::logic_error("Wrong order type.");
155 }
156 config.order_type = orders.at(s);
157 config.order_str = s;
158 }
159 pe = sparams.getEntryPtr("row_parts"); // row_cut
160 if (pe)
161 config.row_parts = pe->getValue(&config.row_parts);
162 pe = sparams.getEntryPtr("col_parts"); //col_cut
163 if (pe)
164 config.col_parts = pe->getValue(&config.col_parts);
165 pe = sparams.getEntryPtr("max_load"); // max_load
166 if (pe)
167 config.max_load = pe->getValue(&config.max_load);
168 pe = sparams.getEntryPtr("sparsify");
169 if (pe)
170 config.sparsify = pe->getValue(&config.sparsify);
171 pe = sparams.getEntryPtr("triangular");
172 if (pe)
173 config.triangular = pe->getValue(&config.triangular);
174 pe = sparams.getEntryPtr("use_data");
175 if (pe)
176 config.use_data = pe->getValue(&config.use_data);
177 pe = sparams.getEntryPtr("seed");
178 if (pe)
179 config.seed = pe->getValue(&config.seed);
180 }
181
182 template<typename Adapter>
183 void AlgSarma<Adapter>::partition(const RCP <PartitioningSolution<Adapter>> &solution) {
184
185 std::ofstream null;
186 null.setstate(std::ios_base::badbit);
187 auto M = std::make_shared<sarma::Matrix<Ordinal, Value> >(std::move(std::vector<Ordinal>(offsets, offsets + offsize)),
188 std::move(std::vector<Ordinal>(colids, colids + nnz)), std::move(std::vector<Value>(vals, vals + nnz)),
189 1 + *std::max_element(colids, colids + nnz));
190 auto parts = sarma::Run<Ordinal, Value>(algs.at(config.alg).first, null, M, config.order_type, config.row_parts,
191 config.col_parts, config.max_load, config.triangular, false, config.sparsify,
192 algs.at(config.alg).second, config.use_data, config.seed);
193
194 unsigned result_size = parts.first.size() + parts.second.size();
195 auto partl = ArrayRCP<int>(new int[result_size], 0, result_size, true);
196 for (size_t i = 0; i < parts.first.size(); ++i) partl[i] = parts.first[i];
197 for (size_t i = parts.first.size(); i < result_size; ++i)
198 partl[i] = parts.second[i - parts.first.size()];
199
200 solution->setParts(partl);
201 }
202}
203
204#endif
Defines the CoordinateModel classes.
Defines the PartitioningSolution class.
Traits class to handle conversions between gno_t/lno_t and TPL data types (e.g., ParMETIS's idx_t,...
A gathering of useful namespace methods.
AlgSarma(const RCP< const Environment > &, const RCP< const Comm< int > > &, const RCP< const base_adapter_t > &)
typename Adapter::base_adapter_t base_adapter_t
Algorithm defines the base class for all algorithms.
virtual void partition(const RCP< PartitioningSolution< Adapter > > &)
Partitioning method.
Adapter::scalar_t scalar_t
map_t::local_ordinal_type lno_t
map_t::global_ordinal_type gno_t
Created by mbenlioglu on Aug 31, 2020.
SparseMatrixAdapter_t::part_t part_t