Zoltan2
TPLTraits.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 
47 // Unit test for Zoltan2_TPLTraits.hpp
48 // Passes various zgno_t types to ASSIGN.
49 // Some combinations should work without error;
50 // for these, this test FAILS if ASSIGN throws an error.
51 // Some combinations should throw an error;
52 // for these, this test says it is GOOD if ASSIGN throws an error.
53 
54 #include <Teuchos_GlobalMPISession.hpp>
55 #include <Teuchos_RCP.hpp>
56 #include <Zoltan2_Environment.hpp>
57 #include <Zoltan2_TPLTraits.hpp>
58 
59 #define MAX(a,b) ((a) > (b) ? (a) : (b))
60 
61 #ifdef HAVE_ZOLTAN2_SCOTCH
62 // stdint.h for int64_t in scotch header
63 #include <stdint.h>
64 extern "C"{
65 #ifndef HAVE_ZOLTAN2_MPI
66 #include "scotch.h"
67 #else
68 #include "ptscotch.h"
69 #endif
70 }
71 #endif // HAVE_ZOLTAN2_SCOTCH
72 
73 #ifdef HAVE_ZOLTAN2_PARMETIS
74 
75 extern "C"{
76 #include "parmetis.h"
77 }
78 
79 #define PARMETIS_IS_OK 1
80 
81 #endif // HAVE_ZOLTAN2_MPI
82 
83 
84 #define PRINTMSG(s) \
85  std::cout << (s) << " " << __FILE__ << ":" << __LINE__ << std::endl
86 
87 int main(int argc, char *argv[])
88 {
89  Teuchos::GlobalMPISession session(&argc, &argv);
90 
91  int ierr = 0;
92 
94  // Test conversions into integers
95 
96  // Assignments that should always work
97  // (since the zgno value fits in an integer)
98  int intIdx;
99  try {
100  int zgno = 123;
102  }
103  catch (std::exception &e) {
104  PRINTMSG("FAIL: int to int");
105  ierr++;
106  }
107 
108  try {
109  unsigned int zgno = 123;
111  }
112  catch (std::exception &e) {
113  PRINTMSG("FAIL: unsigned int to int");
114  ierr++;
115  }
116 
117  try {
118  long zgno = 123;
120  }
121  catch (std::exception &e) {
122  PRINTMSG("FAIL: long to int");
123  ierr++;
124  }
125 
126  try {
127  size_t zgno = 123;
129  }
130  catch (std::exception &e) {
131  PRINTMSG("FAIL: size_t to int");
132  ierr++;
133  }
134 
135  // Assignments that should not work
136  try {
137  long long zgno = (long long)1 << 40;
139  }
140  catch (std::exception &e) {
141  PRINTMSG("GOOD: big long long to int throws exception");
142  }
143 
144  try {
145  size_t zgno = (size_t)1 << 40;
147  }
148  catch (std::exception &e) {
149  PRINTMSG("GOOD: big size_t to int throws exception");
150  }
151 
152  try {
153  unsigned zgno = (1 << 31) + 1;
155  }
156  catch (std::exception &e) {
157  PRINTMSG("GOOD: huge unsigned to int throws exception");
158  }
159 
161  // Test conversions into size_t
162 
163  // Assignments that should always work
164 
165  size_t sizetIdx;
166  try {
167  long long zgno = (long long)1 << 40;
169  }
170  catch (std::exception &e) {
171  PRINTMSG("FAIL: big long long to size_t");
172  ierr++;
173  }
174 
175  try {
176  size_t zgno = (size_t)1 << 40;
178  }
179  catch (std::exception &e) {
180  PRINTMSG("FAIL: big size_t to size_t");
181  ierr++;
182  }
183 
185  // Test conversions into int64_t
186 
187  // Assignments that should always work
188 
189  int64_t int64Idx;
190  try {
191  long long zgno = (long long)1 << 40;
193  }
194  catch (std::exception &e) {
195  PRINTMSG("FAIL: big long long to int64_t");
196  ierr++;
197  }
198 
199  try {
200  size_t zgno = (size_t)1 << 40;
202  }
203  catch (std::exception &e) {
204  PRINTMSG("FAIL: big size_t to int64_t");
205  ierr++;
206  }
207 
208  // Assignments that should not work
209  try {
210  size_t zgno = ((size_t)1 << 63) + 1 ;
212  }
213  catch (std::exception &e) {
214  PRINTMSG("GOOD: huge size_t to int64_t threw exception");
215  }
216 
217 #ifdef HAVE_ZOLTAN2_SCOTCH
218  // Test conversions into SCOTCH_Num
220 
221  SCOTCH_Num scotchIdx;
222 
223  // Assignments that should always work
224  // (since the zgno value fits in an integer)
225  try {
226  int zgno = 123;
228  }
229  catch (std::exception &e) {
230  PRINTMSG("FAIL: int to SCOTCH_Num");
231  ierr++;
232  }
233 
234  try {
235  unsigned int zgno = 123;
237  }
238  catch (std::exception &e) {
239  PRINTMSG("FAIL: unsigned int to SCOTCH_Num");
240  ierr++;
241  }
242 
243  try {
244  long zgno = 123;
246  }
247  catch (std::exception &e) {
248  PRINTMSG("FAIL: long to SCOTCH_Num");
249  ierr++;
250  }
251 
252  try {
253  size_t zgno = 123;
255  }
256  catch (std::exception &e) {
257  PRINTMSG("FAIL: size_t to SCOTCH_Num");
258  ierr++;
259  }
260 
261  if (sizeof(SCOTCH_Num) == 8) {
262 
263  try {
264  long long zgno = (long long)1 << 40;
266  }
267  catch (std::exception &e) {
268  PRINTMSG("FAIL: big unsigned int to SCOTCH_Num");
269  ierr++;
270  }
271 
272  try {
273  size_t zgno = (size_t)1 << 40;
275  }
276  catch (std::exception &e) {
277  PRINTMSG("FAIL: big size_t to SCOTCH_Num");
278  ierr++;
279  }
280  }
281 
282  // Assignments that should not work
283  if (sizeof(SCOTCH_Num) == 4) {
284  try {
285  long long zgno = (long long)1 << 40;
287  }
288  catch (std::exception &e) {
289  PRINTMSG("GOOD: big long long to 4-byte SCOTCH_Num throws exception");
290  }
291 
292  try {
293  size_t zgno = (size_t)1 << 40;
295  }
296  catch (std::exception &e) {
297  PRINTMSG("GOOD: big size_t to 4-byte SCOTCH_Num throws exception");
298  }
299  }
300 
301 #endif // HAVE_ZOLTAN2_SCOTCH
302 
303 #ifdef PARMETIS_IS_OK
304  // Test conversions into ParMETIS' idx_t
306 
307  idx_t parmetisIdx;
308 
309  // Assignments that should always work
310  // (since the zgno value fits in an integer)
311  try {
312  int zgno = 123;
313  Zoltan2::TPL_Traits<idx_t,int>::ASSIGN(parmetisIdx, zgno);
314  }
315  catch (std::exception &e) {
316  PRINTMSG("FAIL: int to ParMETIS' idx_t");
317  ierr++;
318  }
319 
320  try {
321  unsigned int zgno = 123;
323  }
324  catch (std::exception &e) {
325  PRINTMSG("FAIL: unsigned int to ParMETIS' idx_t");
326  ierr++;
327  }
328 
329  try {
330  long zgno = 123;
331  Zoltan2::TPL_Traits<idx_t,long>::ASSIGN(parmetisIdx, zgno);
332  }
333  catch (std::exception &e) {
334  PRINTMSG("FAIL: long to ParMETIS' idx_t");
335  ierr++;
336  }
337 
338  try {
339  size_t zgno = 123;
341  }
342  catch (std::exception &e) {
343  PRINTMSG("FAIL: size_t to ParMETIS' idx_t");
344  ierr++;
345  }
346 
347  if (sizeof(idx_t) == 8) {
348 
349  try {
350  long long zgno = (long long)1 << 40;
352  }
353  catch (std::exception &e) {
354  PRINTMSG("FAIL: big unsigned int to ParMETIS' idx_t");
355  ierr++;
356  }
357 
358  try {
359  size_t zgno = (size_t)1 << 40;
361  }
362  catch (std::exception &e) {
363  PRINTMSG("FAIL: big size_t to ParMETIS' idx_t");
364  ierr++;
365  }
366  }
367 
368  // Assignments that should not work
369  if (sizeof(idx_t) == 4) {
370  try {
371  long long zgno = (long long)1 << 40;
373  }
374  catch (std::exception &e) {
375  PRINTMSG("GOOD: big long long to 4-byte ParMETIS' idx_t throws exception");
376  }
377 
378  try {
379  size_t zgno = (size_t)1 << 40;
381  }
382  catch (std::exception &e) {
383  PRINTMSG("GOOD: big size_t to 4-byte ParMETIS' idx_t throws exception");
384  }
385  }
386 #endif
387 
389  // Test conversions into and from ZOLTAN_ID_PTR
390 
391  ZOLTAN_ID_PTR zoltanGID = new ZOLTAN_ID_TYPE[4];
392 
393  {
394  typedef char test_t;
395  test_t zgno = 'a';
396  zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
397 
398  int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
400  PRINTMSG("FAIL: NUM_ID wrong for char");
401  ierr++;
402  }
403 
405  if (zoltanGID[0] != ZOLTAN_ID_TYPE(zgno) || zoltanGID[1] != 0 ||
406  zoltanGID[2] != 0 || zoltanGID[3] != 0) {
407  PRINTMSG("FAIL: char to ZOLTAN_ID_PTR");
408  ierr++;
409  }
410 
411  test_t back;
413  if (back != zgno) {
414  PRINTMSG("FAIL: ZOLTAN_ID_PTR to char");
415  ierr++;
416  }
417  }
418 
419  {
420  typedef short test_t;
421  test_t zgno = 63;
422  zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
423 
424  int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
426  PRINTMSG("FAIL: NUM_ID wrong for short");
427  ierr++;
428  }
429 
431  if (zoltanGID[0] != ZOLTAN_ID_TYPE(zgno) || zoltanGID[1] != 0 ||
432  zoltanGID[2] != 0 || zoltanGID[3] != 0) {
433  PRINTMSG("FAIL: short to ZOLTAN_ID_PTR");
434  ierr++;
435  }
436 
437  test_t back;
439  if (back != zgno) {
440  PRINTMSG("FAIL: ZOLTAN_ID_PTR to short");
441  ierr++;
442  }
443  }
444 
445  {
446  typedef int test_t;
447  test_t zgno = 123;
448  zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
449 
450  int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
452  PRINTMSG("FAIL: NUM_ID wrong for int");
453  ierr++;
454  }
455 
457  if (zoltanGID[0] != ZOLTAN_ID_TYPE(zgno) || zoltanGID[1] != 0 ||
458  zoltanGID[2] != 0 || zoltanGID[3] != 0) {
459  PRINTMSG("FAIL: int to ZOLTAN_ID_PTR");
460  ierr++;
461  }
462 
463  test_t back;
465  if (back != zgno) {
466  PRINTMSG("FAIL: ZOLTAN_ID_PTR to int");
467  ierr++;
468  }
469  }
470 
471  {
472  typedef unsigned int test_t;
473  test_t zgno = 456;
474  zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
475 
476  int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
478  PRINTMSG("FAIL: NUM_ID wrong for unsigned int");
479  ierr++;
480  }
481 
483  if (zoltanGID[0] != zgno || zoltanGID[1] != 0 ||
484  zoltanGID[2] != 0 || zoltanGID[3] != 0) {
485  PRINTMSG("FAIL: unsigned int to ZOLTAN_ID_PTR");
486  ierr++;
487  }
488 
489  test_t back;
491  if (back != zgno) {
492  PRINTMSG("FAIL: ZOLTAN_ID_PTR to unsigned int");
493  ierr++;
494  }
495  }
496 
497  {
498  typedef long long test_t;
499  test_t zgno = ((test_t)1 << 34) + (test_t)17;
500  zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
501 
502  int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
504  PRINTMSG("FAIL: NUM_ID wrong for long long");
505  ierr++;
506  }
507 
509  if (sizeof(ZOLTAN_ID_TYPE) == sizeof(unsigned int)) {
510  if (zoltanGID[0] != 17 || zoltanGID[1] != 4 ||
511  zoltanGID[2] != 0 || zoltanGID[3] != 0) {
512  PRINTMSG("FAIL: long long to ZOLTAN_ID_PTR");
513  ierr++;
514  }
515  }
516  else if (sizeof(ZOLTAN_ID_TYPE) == sizeof(unsigned long long)) {
517  if (test_t(zoltanGID[0]) != zgno || zoltanGID[1] != 0 ||
518  zoltanGID[2] != 0 || zoltanGID[3] != 0) {
519  PRINTMSG("FAIL: long long to ZOLTAN_ID_PTR");
520  ierr++;
521  }
522  }
523  else {
524  // should never get here
525  PRINTMSG("FAIL: unknown sizeof(ZOLTAN_ID_TYPE)");
526  ierr++;
527  }
528 
529 
530  test_t back;
532  if (back != zgno) {
533  std::cout << "back " << back << " != zgno " << zgno << std::endl;
534  PRINTMSG("FAIL: ZOLTAN_ID_PTR to long long");
535  ierr++;
536  }
537  }
538 
539  {
540  typedef unsigned long long test_t;
541  test_t zgno = ((test_t)1 << 36) + (test_t)25;
542  zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
543 
544  int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
546  PRINTMSG("FAIL: NUM_ID wrong for unsigned long long");
547  ierr++;
548  }
549 
551  if (sizeof(ZOLTAN_ID_TYPE) == sizeof(unsigned int)) {
552  if (zoltanGID[0] != 25 || zoltanGID[1] != 16 ||
553  zoltanGID[2] != 0 || zoltanGID[3] != 0) {
554  PRINTMSG("FAIL: unsigned long long to ZOLTAN_ID_PTR");
555  ierr++;
556  }
557  }
558  else if (sizeof(ZOLTAN_ID_TYPE) == sizeof(unsigned long long)) {
559  if (zoltanGID[0] != zgno || zoltanGID[1] != 0 ||
560  zoltanGID[2] != 0 || zoltanGID[3] != 0) {
561  PRINTMSG("FAIL: long long to ZOLTAN_ID_PTR");
562  ierr++;
563  }
564  }
565  else {
566  // should never get here
567  PRINTMSG("FAIL: unknown sizeof(ZOLTAN_ID_TYPE)");
568  ierr++;
569  }
570 
571 
572 
573  test_t back;
575  if (back != zgno) {
576  std::cout << "back " << back << " != zgno " << zgno << std::endl;
577  PRINTMSG("FAIL: ZOLTAN_ID_PTR to unsigned long long");
578  ierr++;
579  }
580  }
581 
582  {
583  typedef size_t test_t;
584  test_t zgno = 0;
585  for (size_t i = 0; i < 8*sizeof(test_t); i++) zgno += (test_t)1<<i;
586  zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
587 
588  int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
590  PRINTMSG("FAIL: NUM_ID wrong for size_t");
591  ierr++;
592  }
593 
595  for (int i = 0; i < num_gid; i++)
596  if (zoltanGID[i] != std::numeric_limits<ZOLTAN_ID_TYPE>::max()) {
597  PRINTMSG("FAIL: size_t to ZOLTAN_ID_PTR");
598  ierr++;
599  }
600  for (int i = num_gid; i < 4; i++)
601  if (zoltanGID[i] != 0) {
602  PRINTMSG("FAIL: size_t to ZOLTAN_ID_PTR");
603  ierr++;
604  }
605 
606  test_t back;
608  if (back != zgno) {
609  std::cout << "back " << back << " != zgno " << zgno << std::endl;
610  PRINTMSG("FAIL: ZOLTAN_ID_PTR to size_t");
611  ierr++;
612  }
613  }
614  delete [] zoltanGID;
615 
617 
618  if (ierr == 0)
619  std::cout << "PASS" << std::endl;
620  else
621  std::cout << "FAIL" << std::endl;
622 
623  return 0;
624 }
625 
int main(int argc, char *argv[])
Definition: TPLTraits.cpp:87
#define MAX(a, b)
Definition: TPLTraits.cpp:59
#define PRINTMSG(s)
Definition: TPLTraits.cpp:84
static void ASSIGN(first_t &a, second_t b)
Traits class to handle conversions between gno_t/lno_t and TPL data types (e.g., ParMETIS&#39;s idx_t...
Defines the Environment class.