Zoltan2
Loading...
Searching...
No Matches
BasicVectorInput.cpp
Go to the documentation of this file.
1// @HEADER
2//
3// ***********************************************************************
4//
5// Zoltan2: A package of combinatorial algorithms for scientific computing
6// Copyright 2012 Sandia Corporation
7//
8// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9// the U.S. Government retains certain rights in this software.
10//
11// Redistribution and use in source and binary forms, with or without
12// modification, are permitted provided that the following conditions are
13// met:
14//
15// 1. Redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer.
17//
18// 2. Redistributions in binary form must reproduce the above copyright
19// notice, this list of conditions and the following disclaimer in the
20// documentation and/or other materials provided with the distribution.
21//
22// 3. Neither the name of the Corporation nor the names of the
23// contributors may be used to endorse or promote products derived from
24// this software without specific prior written permission.
25//
26// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37//
38// Questions? Contact Karen Devine (kddevin@sandia.gov)
39// Erik Boman (egboman@sandia.gov)
40// Siva Rajamanickam (srajama@sandia.gov)
41//
42// ***********************************************************************
43//
44// @HEADER
45//
46// Test for Zoltan2::BasicVectorAdapter
47
50
51#include <Teuchos_DefaultComm.hpp>
52#include <Teuchos_RCP.hpp>
53#include <Teuchos_CommHelpers.hpp>
54
55
57
59 Zoltan2::BasicVectorAdapter<userTypes_t> *ia, int len, int glen,
60 zgno_t *ids, int mvdim, const zscalar_t **values, int *valueStrides,
61 int wdim, const zscalar_t **weights, int *weightStrides)
62{
63 int fail = 0;
64 bool strideOne = false;
65
66 if (valueStrides == NULL) strideOne = true;
67
68 if (ia->getNumEntriesPerID() != mvdim)
69 fail = 100;
70
71 if (!fail && ia->getNumWeightsPerID() != wdim)
72 fail = 101;
73
74 if (!fail && ia->getLocalNumIDs() != size_t(len))
75 fail = 102;
76
77 const zgno_t *idList;
78 ia->getIDsView(idList);
79 for (int i=0; !fail && i < len; i++)
80 if (!fail && idList[i] != ids[i])
81 fail = 107;
82
83 for (int v=0; !fail && v < mvdim; v++){
84 const zscalar_t *vals;
85 int correctStride = (strideOne ? 1 : valueStrides[v]);
86 int stride;
87
88 ia->getEntriesView(vals, stride, v);
89
90 if (!fail && stride != correctStride)
91 fail = 105;
92
93 for (int i=0; !fail && i < len; i++){
94// TODO fix values check
95// if (vals[stride*i] != values[v][correctStride*i])
96// fail = 106;
97 }
98 }
99
100 for (int w=0; !fail && w < wdim; w++){
101 const zscalar_t *wgts;
102 int stride;
103
104 ia->getWeightsView(wgts, stride, w);
105
106 if (!fail && stride != weightStrides[w])
107 fail = 109;
108
109 for (int i=0; !fail && i < len; i++){
110 if (wgts[stride*i] != weights[w][weightStrides[w]*i])
111 fail = 110;
112 }
113 }
114
115 return fail;
116}
117
118
119int main(int narg, char *arg[])
120{
121 Tpetra::ScopeGuard tscope(&narg, &arg);
122 Teuchos::RCP<const Teuchos::Comm<int> > comm = Tpetra::getDefaultComm();
123
124 int rank = comm->getRank();
125 int nprocs = comm->getSize();
126 int fail = 0;
127
128 // Create a single vector and a strided multi-vector with
129 // strided multi-weights.
130
131 zlno_t numLocalIds = 10;
132 zgno_t *myIds = new zgno_t[numLocalIds];
133 zgno_t myFirstId = rank * numLocalIds;
134
135 int wdim = 2;
136 zscalar_t *weights = new zscalar_t [numLocalIds*wdim];
137 int *weightStrides = new int [wdim];
138 const zscalar_t **weightPtrs = new const zscalar_t * [wdim];
139
140 int mvdim = 3;
141 zscalar_t *v_values= new zscalar_t [numLocalIds];
142 zscalar_t *mv_values= new zscalar_t [mvdim * numLocalIds];
143 int *valueStrides = new int [mvdim];
144 const zscalar_t **valuePtrs = new const zscalar_t * [mvdim];
145
146 for (zlno_t i=0; i < numLocalIds; i++){
147 myIds[i] = myFirstId+i;
148
149 for (int w=0; w < wdim; w++)
150 weights[w*numLocalIds + i] = w + 1 + nprocs - rank;
151
152 v_values[i] = numLocalIds-i;
153
154 for (int v=0; v < mvdim; v++)
155 mv_values[i*mvdim + v] = (v+1) * (nprocs-rank) / (i+1);
156 }
157
158 for (int w=0; w < wdim; w++){
159 weightStrides[w] = 1;
160 weightPtrs[w] = weights + numLocalIds*w;
161 }
162
163 for (int v=0; v < mvdim; v++){
164 valueStrides[v] = mvdim;
165 valuePtrs[v] = mv_values + v;
166 }
167
169
170 {
171 // A Zoltan2::BasicVectorAdapter object with one vector and no weights
172
173 std::vector<const zscalar_t *> weightValues;
174 std::vector<int> strides;
175
176 try{
177 ia = new Zoltan2::BasicVectorAdapter<userTypes_t>(numLocalIds, myIds,
178 v_values, 1);
179 }
180 catch (std::exception &e){
181 fail = 1;
182 }
183
184 TEST_FAIL_AND_RETURN_VALUE(*comm, fail==0, "constructor 1", fail);
185
186 fail = checkBasicVector(ia, numLocalIds, numLocalIds*nprocs,
187 myIds, 1, valuePtrs, NULL, 0, NULL, NULL);
188
189 delete ia;
190
191 TEST_FAIL_AND_RETURN_VALUE(*comm, fail==0, "check vector 1", fail);
192 }
193
194 {
195 // A Zoltan2::BasicVectorAdapter object with one vector and weights
196
197 std::vector<const zscalar_t *> weightValues;
198 std::vector<int> strides;
199
200 weightValues.push_back(weightPtrs[0]);
201 weightValues.push_back(weightPtrs[1]);
202 strides.push_back(1);
203 strides.push_back(1);
204
205 try{
206 ia = new Zoltan2::BasicVectorAdapter<userTypes_t>(numLocalIds, myIds,
207 v_values, 1, true, weightPtrs[0], 1);
208 }
209 catch (std::exception &e){
210 fail = 1;
211 }
212
213 TEST_FAIL_AND_RETURN_VALUE(*comm, fail==0, "constructor 2", fail);
214
215 fail = checkBasicVector(ia, numLocalIds, numLocalIds*nprocs,
216 myIds, 1, valuePtrs, NULL, 1, weightPtrs, weightStrides);
217
218 delete ia;
219
220 TEST_FAIL_AND_RETURN_VALUE(*comm, fail==0, "check vector 2", fail);
221 }
222
223 {
224 // A Zoltan2::BasicVectorAdapter object with a multivector and no weights
225
226 std::vector<const zscalar_t *> weightValues, values;
227 std::vector<int> wstrides, vstrides;
228
229 for (int dim=0; dim < mvdim; dim++){
230 values.push_back(valuePtrs[dim]);
231 vstrides.push_back(mvdim);
232 }
233
234
235 try{
237 numLocalIds, myIds, values, vstrides, weightValues, wstrides);
238 }
239 catch (std::exception &e){
240 fail = 1;
241 }
242
243 TEST_FAIL_AND_RETURN_VALUE(*comm, fail==0, "constructor 3", fail);
244
245 fail = checkBasicVector(ia, numLocalIds, numLocalIds*nprocs,
246 myIds, mvdim, valuePtrs, valueStrides, 0, NULL, NULL);
247
248 delete ia;
249
250 TEST_FAIL_AND_RETURN_VALUE(*comm, fail==0, "check vector 3", fail);
251 }
252
253 {
254 // A Zoltan2::BasicVectorAdapter object with a multivector with weights
255
256 std::vector<const zscalar_t *> weightValues, values;
257 std::vector<int> wstrides, vstrides;
258
259 for (int dim=0; dim < wdim; dim++){
260 weightValues.push_back(weightPtrs[dim]);
261 wstrides.push_back(1);
262 }
263
264 for (int dim=0; dim < mvdim; dim++){
265 values.push_back(valuePtrs[dim]);
266 vstrides.push_back(mvdim);
267 }
268
269 try{
271 numLocalIds, myIds, values, vstrides, weightValues, wstrides);
272
273 }
274 catch (std::exception &e){
275 fail = 1;
276 }
277
278 TEST_FAIL_AND_RETURN_VALUE(*comm, fail==0, "constructor 4", fail);
279
280 fail = checkBasicVector(ia, numLocalIds, numLocalIds*nprocs,
281 myIds, mvdim, valuePtrs, valueStrides,
282 wdim, weightPtrs, weightStrides);
283
284 delete ia;
285
286 TEST_FAIL_AND_RETURN_VALUE(*comm, fail==0, "check vector 4", fail);
287 }
288
289 if (rank == 0)
290 std::cout << "PASS" << std::endl;
291
292 delete [] myIds;
293 delete [] weights;
294 delete [] weightStrides;
295 delete [] weightPtrs;
296 delete [] v_values;
297 delete [] mv_values;
298 delete [] valueStrides;
299 delete [] valuePtrs;
300
301 return fail;
302}
303
int checkBasicVector(Zoltan2::BasicVectorAdapter< userTypes_t > *ia, int len, int glen, zgno_t *ids, int mvdim, const zscalar_t **values, int *valueStrides, int wdim, const zscalar_t **weights, int *weightStrides)
#define TEST_FAIL_AND_RETURN_VALUE(comm, ok, s, rc)
Defines the BasicVectorAdapter class.
common code used by tests
float zscalar_t
Tpetra::Map ::local_ordinal_type zlno_t
Tpetra::Map ::global_ordinal_type zgno_t
int main()
A simple class that can be the User template argument for an InputAdapter.
BasicVectorAdapter represents a vector (plus optional weights) supplied by the user as pointers to st...
static const std::string fail
Zoltan2::BasicUserTypes< zscalar_t, zlno_t, zgno_t > userTypes_t
static ArrayRCP< ArrayRCP< zscalar_t > > weights