MOAB: Mesh Oriented datABase  (version 5.5.0)
umr_perf.cpp
Go to the documentation of this file.
1 /*This function profiles the performance of the AHF datastructure */
2 #include <iostream>
3 #include <cassert>
4 #include <ctime>
5 #include <vector>
6 #include "moab/Core.hpp"
7 #include "moab/Range.hpp"
8 #include "moab/MeshTopoUtil.hpp"
9 #include "moab/HalfFacetRep.hpp"
10 #include "moab/NestedRefine.hpp"
11 #include "../TestUtil.hpp"
12 #include "moab/CpuTimer.hpp"
13 
14 #ifdef MOAB_HAVE_MPI
15 #include "moab/ParallelComm.hpp"
16 #include "MBParallelConventions.h"
17 #include "moab/FileOptions.hpp"
18 #include "MBTagConventions.hpp"
19 #include "moab_mpi.h"
20 #endif
21 
22 using namespace moab;
23 
24 #ifdef MOAB_HAVE_MPI
25 std::string read_options;
26 #endif
27 
28 int number_tests_successful = 0;
29 int number_tests_failed = 0;
30 
31 struct mesh_mem
32 {
33 
34  /* unsigned long long total_storage;
35  unsigned long long amortized_total_storage;
36  unsigned long long entity_storage;
37  unsigned long long amortized_entity_storage;
38  unsigned long long adjacency_storage;
39  unsigned long long amortized_adjacency_storage;
40  unsigned long long tag_storage;
41  unsigned long long amortized_tag_storage;*/
42 
43  // Total storage
44  unsigned long long total_storage;
45  unsigned long long total_amortized_storage;
46 
47  // Adjacency storage
48  unsigned long long adj_storage;
49  unsigned long long amortized_adj_storage;
50 
51  // Vertex storage
52  unsigned long long vertex_storage;
53  unsigned long long amortized_vertex_storage;
54 
55  // Entity storage
56  unsigned long long entity_storage;
57  unsigned long long amortized_entity_storage;
58 };
59 
60 enum OUTTYPE
61 {
62  TIME = 0,
63  MEM,
64  BOTH
65 };
66 
67 void handle_error_code( ErrorCode rv, int& number_failed, int& number_successful )
68 {
69  if( rv == MB_SUCCESS )
70  {
71 #ifdef MOAB_HAVE_MPI
72  int rank = 0;
73  MPI_Comm_rank( MPI_COMM_WORLD, &rank );
74  if( rank == 0 ) std::cout << "Success";
75 #else
76  std::cout << "Success";
77 #endif
78  number_successful++;
79  }
80  else
81  {
82  std::cout << "Failure";
83  number_failed++;
84  }
85 }
86 
87 ErrorCode umr_perf_test( Core* mb, int* level_degrees, int num_levels, OUTTYPE output )
88 {
89  ErrorCode error;
90  Interface* mbImpl = mb;
91 
92  mesh_mem* umem = new mesh_mem[num_levels + 2];
93 
94  CpuTimer* mt = new CpuTimer;
95  double time_start, time_avg, time_total;
96 
97  // Create ranges of entities in the initial mesh
98  Range inverts, inedges, infaces, incells;
99  error = mbImpl->get_entities_by_dimension( 0, 0, inverts );
100  error = mbImpl->get_entities_by_dimension( 0, 1, inedges );
101  error = mbImpl->get_entities_by_dimension( 0, 2, infaces );
102  error = mbImpl->get_entities_by_dimension( 0, 3, incells );
103 
104  Range init_ents;
105  int dim = 0;
106  if( inedges.size() )
107  {
108  dim = 1;
109  init_ents = inedges;
110  }
111  else if( infaces.size() )
112  {
113  dim = 2;
114  init_ents = infaces;
115  }
116  else if( incells.size() )
117  {
118  dim = 3;
119  init_ents = incells;
120  }
121 
122  std::cout << std::endl;
123  std::cout << "Initial Mesh Size: "
124  << "NV = " << inverts.size() << ", NE = " << init_ents.size() << std::endl;
125 
126  if( output == MEM || output == BOTH )
127  {
128  // Storage Costs before mesh hierarchy generation
129  /* std::cout<<std::endl;
130  unsigned long long sTotS, sTAS, sES, sAES, sAS, sAAS, sTS, sATS;
131  sTotS = sTAS = sES = sAES = sAS = sAAS = sTS = sATS = 0;
132  mbImpl->estimated_memory_use(NULL, 0, &sTotS, &sTAS, &sES, &sAES, &sAS, &sAAS, NULL, 0,
133  &sTS, &sATS);
134 
135  umem[0].total_storage = sTotS;
136  umem[0].amortized_total_storage = sTAS;
137  umem[0].entity_storage = sES;
138  umem[0].amortized_entity_storage = sAES;
139  umem[0].adjacency_storage = sAS;
140  umem[0].amortized_adjacency_storage = sAAS;
141  umem[0].tag_storage = sTS;
142  umem[0].amortized_tag_storage = sATS;*/
143 
144  unsigned long long vTotS, vTAS, vES, vAES, vAS, vAAS, vTS, vATS;
145  vTotS = vTAS = vES = vAES = vAS = vAAS = vTS = vATS = 0;
146  mbImpl->estimated_memory_use( inverts, &vTotS, &vTAS, &vES, &vAES, &vAS, &vAAS, NULL, 0, &vTS, &vATS );
147 
148  unsigned long long eTotS, eTAS, eES, eAES, eAS, eAAS, eTS, eATS;
149  eTotS = eTAS = eES = eAES = eAS = eAAS = eTS = eATS = 0;
150  mbImpl->estimated_memory_use( init_ents, &eTotS, &eTAS, &eES, &eAES, &eAS, &eAAS, NULL, 0, &eTS, &eATS );
151 
152  umem[0].total_storage = vTotS + eTotS;
153  umem[0].vertex_storage = vES;
154  umem[0].entity_storage = eES;
155  // umem[0].tag_storage = vTS+eTS;
156 
157  std::cout << "MEMORY STORAGE:: Initial Mesh" << std::endl;
158  std::cout << std::endl;
159  std::cout << "Total storage = " << umem[0].total_storage << std::endl;
160  std::cout << "Vertex storage = " << umem[0].vertex_storage << std::endl;
161  std::cout << "Entity storage = " << umem[0].entity_storage << std::endl;
162  // std::cout<<"Tag storage = "<< umem[0].tag_storage<<std::endl;
163 
164  /* std::cout<<"Total storage = "<<umem[0].total_storage<<std::endl;
165  std::cout<<"Total amortized storage = "<< umem[0].amortized_total_storage<<std::endl;
166  std::cout<<"Entity storage = "<<umem[0].entity_storage<<std::endl;
167  std::cout<<"Amortized entity storage = "<<umem[0].amortized_entity_storage<<std::endl;
168  std::cout<<"Adjacency storage = "<< umem[0].adjacency_storage <<std::endl;
169  std::cout<<"Amortized adjacency storage = "<<umem[0].amortized_adjacency_storage
170  <<std::endl; std::cout<<"Tag storage = "<< umem[0].tag_storage<<std::endl;
171  std::cout<<"Amortized tag storage = "<<umem[0].amortized_tag_storage <<std::endl;*/
172  std::cout << std::endl;
173  }
174 
175  // Create an hm object and generate the hierarchy
176  std::cout << "Creating a hm object" << std::endl;
177  NestedRefine uref( mb );
178  std::vector< EntityHandle > set;
179 
180  std::cout << "Starting hierarchy generation" << std::endl;
181  time_start = mt->time_elapsed();
182  error = uref.generate_mesh_hierarchy( num_levels, level_degrees, set );CHECK_ERR( error );
183 
184  time_total = mt->time_elapsed() - time_start;
185  std::cout << "Finished hierarchy generation" << std::endl;
186 
187  if( output == TIME || output == BOTH )
188  {
189  std::cout << "Total time in secs:: generate mesh hierarchy:: L = " << num_levels << " :: " << time_total
190  << std::endl;
191  std::cout << std::endl;
192  }
193 
194  // Loop over each mesh level and check its topological properties
195  for( int l = 0; l < num_levels; l++ )
196  {
197  // Get the current mesh level using its meshset
198  Range verts, ents;
199  error = mbImpl->get_entities_by_type( set[l + 1], MBVERTEX, verts );CHECK_ERR( error );
200  error = mbImpl->get_entities_by_dimension( set[l + 1], dim, ents );CHECK_ERR( error );
201 
202  std::cout << "Mesh size for level " << l + 1 << " :: deg = " << level_degrees[l] << " :: NV = " << verts.size()
203  << ", NE = " << ents.size() << std::endl;
204 
205  if( output == MEM || output == BOTH )
206  {
207  // Storage Costs
208  std::cout << std::endl;
209  unsigned long long vTotS, vTAS, vES, vAES, vAS, vAAS, vTS, vATS;
210  vTotS = vTAS = vES = vAES = vAS = vAAS = vTS = vATS = 0;
211  mbImpl->estimated_memory_use( verts, &vTotS, &vTAS, &vES, &vAES, &vAS, &vAAS, NULL, 0, &vTS, &vATS );
212  unsigned long long eTotS, eTAS, eES, eAES, eAS, eAAS, eTS, eATS;
213  eTotS = eTAS = eES = eAES = eAS = eAAS = eTS = eATS = 0;
214  mbImpl->estimated_memory_use( ents, &eTotS, &eTAS, &eES, &eAES, &eAS, &eAAS, NULL, 0, &eTS, &eATS );
215 
216  umem[l + 1].total_storage = vTotS + eTotS;
217  umem[l + 1].vertex_storage = vES;
218  umem[l + 1].entity_storage = eES;
219  // umem[l+1].tag_storage = vTS+eTS;
220 
221  /* umem[l+1].total_storage = vTotS+eTotS;
222  umem[l+1].amortized_total_storage = vTAS+eTAS;
223  umem[l+1].entity_storage = vES+eES;
224  umem[l+1].amortized_entity_storage = vAES+eAES;
225  umem[l+1].adjacency_storage = vAS+eAS;
226  umem[l+1].amortized_adjacency_storage = vAAS+eAAS;
227  umem[l+1].tag_storage = vTS+eTS;
228  umem[l+1].amortized_tag_storage = vATS+eATS;*/
229 
230  std::cout << "MEMORY STORAGE:: Mesh level " << l + 1 << std::endl;
231  std::cout << std::endl;
232  std::cout << "Total storage = " << umem[l + 1].total_storage << std::endl;
233  std::cout << "Vertex storage = " << umem[l + 1].vertex_storage << std::endl;
234  std::cout << "Entity storage = " << umem[l + 1].entity_storage << std::endl;
235  // std::cout<<"Tag storage = "<< umem[l+1].tag_storage<<std::endl;
236 
237  /* std::cout<<"Total storage = "<<umem[l+1].total_storage<<std::endl;
238  std::cout<<"Total amortized storage = "<<
239  umem[l+1].amortized_total_storage<<std::endl; std::cout<<"Entity storage =
240  "<<umem[l+1].entity_storage<<std::endl; std::cout<<"Amortized entity storage =
241  "<<umem[l+1].amortized_entity_storage<<std::endl; std::cout<<"Adjacency storage = "<<
242  umem[l+1].adjacency_storage <<std::endl; std::cout<<"Amortized adjacency storage =
243  "<<umem[l+1].amortized_adjacency_storage <<std::endl; std::cout<<"Tag storage = "<<
244  umem[l+1].tag_storage<<std::endl; std::cout<<"Amortized tag storage =
245  "<<umem[l+1].amortized_tag_storage <<std::endl;*/
246  std::cout << std::endl;
247  }
248 
249  if( output == BOTH )
250  {
251  // Loop over all vertices and get their coordinates
252  time_start = mt->time_elapsed();
253  for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
254  {
255  double coords[3];
256  EntityHandle vid = *i;
257  error = uref.get_coordinates( &vid, 1, (int)l, &coords[0] );CHECK_ERR( error );
258  }
259  time_total = mt->time_elapsed() - time_start;
260  time_avg = time_total / (double)verts.size();
261 
262  std::cout << "Class NR :: OPERATION:: get_coordinates"
263  << " :: Time_total = " << time_total << " :: Time_avg = " << time_avg << std::endl;
264 
265  time_start = mt->time_elapsed();
266  for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
267  {
268  double coords[3];
269  EntityHandle vid = *i;
270  error = mbImpl->get_coords( &vid, 1, &coords[0] );CHECK_ERR( error );
271  }
272  time_total = mt->time_elapsed() - time_start;
273  time_avg = time_total / (double)verts.size();
274 
275  std::cout << "Class Core :: OPERATION:: get_coordinates"
276  << " :: Time_total = " << time_total << " :: Time_avg = " << time_avg << std::endl;
277 
278  // Loop over all entities and get their connectivity
279  time_start = mt->time_elapsed();
280  for( Range::iterator i = ents.begin(); i != ents.end(); ++i )
281  {
282  std::vector< EntityHandle > conn;
283  error = uref.get_connectivity( *i, l, conn );CHECK_ERR( error );
284  }
285  time_total = mt->time_elapsed() - time_start;
286  time_avg = time_total / (double)ents.size();
287  std::cout << std::endl;
288  std::cout << "Class NR :: OPERATION:: get_connectivity"
289  << " :: Time_total = " << time_total << " :: Time_avg = " << time_avg << std::endl;
290 
291  time_start = mt->time_elapsed();
292  for( Range::iterator i = ents.begin(); i != ents.end(); ++i )
293  {
294  std::vector< EntityHandle > conn;
295  error = mbImpl->get_connectivity( &*i, 1, conn );CHECK_ERR( error );
296  }
297  time_total = mt->time_elapsed() - time_start;
298  time_avg = time_total / (double)ents.size();
299 
300  std::cout << "Class Core :: OPERATION:: get_connectivity"
301  << " :: Time_total = " << time_total << " :: Time_avg = " << time_avg << std::endl;
302  std::cout << std::endl;
303  }
304  }
305 
306  /* if (output == MEM || output == BOTH){
307 
308  unsigned long long sTotS, sTAS, sES, sAES, sAS, sAAS, sTS, sATS;
309  sTotS = sTAS = sES = sAES = sAS = sAAS = sTS = sATS = 0;
310  mbImpl->estimated_memory_use(NULL, 0, &sTotS, &sTAS, &sES, &sAES, &sAS, &sAAS, NULL, 0,
311  &sTS, &sATS);
312 
313  umem[num_levels+1].total_storage = sTotS;
314  umem[num_levels+1].amortized_total_storage = sTAS;
315  umem[num_levels+1].entity_storage = sES;
316  umem[num_levels+1].amortized_entity_storage = sAES;
317  umem[num_levels+1].adjacency_storage = sAS;
318  umem[num_levels+1].amortized_adjacency_storage = sAAS;
319  umem[num_levels+1].tag_storage = sTS;
320  umem[num_levels+1].amortized_tag_storage = sATS;
321 
322  std::cout<<"MEMORY STORAGE:: WHOLE MESH HIERARCHY"<<std::endl;
323  std::cout<<std::endl;
324  std::cout<<"Total storage = "<<umem[num_levels+1].total_storage<<std::endl;
325  std::cout<<"Total amortized storage = "<<
326  umem[num_levels+1].amortized_total_storage<<std::endl; std::cout<<"Entity storage =
327  "<<umem[num_levels+1].entity_storage<<std::endl; std::cout<<"Amortized entity storage =
328  "<<umem[num_levels+1].amortized_entity_storage<<std::endl; std::cout<<"Adjacency storage =
329  "<< umem[num_levels+1].adjacency_storage <<std::endl; std::cout<<"Amortized adjacency storage
330  = "<<umem[num_levels+1].amortized_adjacency_storage <<std::endl; std::cout<<"Tag storage =
331  "<< umem[num_levels+1].tag_storage<<std::endl; std::cout<<"Amortized tag storage =
332  "<<umem[num_levels+1].amortized_tag_storage <<std::endl; std::cout<<std::endl;
333  }*/
334 
335  return MB_SUCCESS;
336 }
337 
338 ErrorCode create_simple_mesh( Core* mb, EntityType type )
339 {
340  ErrorCode error;
341  Interface* mbImpl = mb;
342  if( type == MBEDGE )
343  {
344  const double coords[] = { 0, 0, 0, 1, 0, 0, 2, 0, 0, 3, 0, 0, 4, 0, 0,
345  4, 1, 0, 3, 1, 0, 2, 1, 0, 1, 1, 0, 0, 1, 0 };
346  const size_t num_vtx = sizeof( coords ) / sizeof( double ) / 3;
347 
348  const int conn[] = { 1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 0 };
349  const size_t num_elems = sizeof( conn ) / sizeof( int ) / 2;
350 
351  EntityHandle verts[num_vtx], edges[num_elems];
352  for( size_t i = 0; i < num_vtx; ++i )
353  {
354  error = mbImpl->create_vertex( coords + 3 * i, verts[i] );
355  if( error != MB_SUCCESS ) return error;
356  }
357 
358  for( size_t i = 0; i < num_elems; ++i )
359  {
360  EntityHandle c[2];
361  c[0] = verts[conn[2 * i]];
362  c[1] = verts[conn[2 * i + 1]];
363 
364  error = mbImpl->create_element( MBEDGE, c, 2, edges[i] );
365  if( error != MB_SUCCESS ) return error;
366  }
367  }
368  else if( type == MBTRI )
369  {
370  const double coords[] = { 0, 0, 0, 1, 0, 0, 2, 0, 0, 2.5, 1, 0, 1.5, 1, 0, 0.5, 1,
371  0, -0.5, 1, 0, -0.5, -1, 0, 0.5, -1, 0, 1.5, -1, 0, 2.5, -1, 0 };
372 
373  const size_t num_vtx = sizeof( coords ) / sizeof( double ) / 3;
374 
375  const int conn[] = { 0, 5, 6, 0, 1, 5, 1, 4, 5, 1, 2, 4, 2, 3, 4,
376  7, 8, 0, 8, 1, 0, 8, 9, 1, 9, 2, 1, 9, 10, 2 };
377 
378  const size_t num_elems = sizeof( conn ) / sizeof( int ) / 3;
379 
380  EntityHandle verts[num_vtx], faces[num_elems];
381  for( size_t i = 0; i < num_vtx; ++i )
382  {
383  error = mbImpl->create_vertex( coords + 3 * i, verts[i] );
384  if( error != MB_SUCCESS ) return error;
385  }
386 
387  for( size_t i = 0; i < num_elems; ++i )
388  {
389  EntityHandle c[3];
390  for( int j = 0; j < 3; j++ )
391  c[j] = verts[conn[3 * i + j]];
392 
393  error = mbImpl->create_element( MBTRI, c, 3, faces[i] );
394  if( error != MB_SUCCESS ) return error;
395  }
396  }
397  else if( type == MBQUAD )
398  {
399  const double coords[] = { 0, 0, 0, 1, 0, 0, 2, 0, 0, 3, 0, 0, 4, 0, 0, 5, 0, 0, 0, 1, 0, 1, 1, 0, 2, 1, 0,
400  3, 1, 0, 4, 1, 0, 5, 1, 0, 0, 2, 0, 1, 2, 0, 2, 2, 0, 3, 2, 0, 4, 2, 0, 5, 2, 0 };
401 
402  const size_t num_vtx = sizeof( coords ) / sizeof( double ) / 3;
403 
404  const int conn[] = { 0, 1, 7, 6, 1, 2, 8, 7, 2, 3, 9, 8, 3, 4, 10, 9, 4, 5, 11, 10,
405  6, 7, 13, 12, 7, 8, 14, 13, 8, 9, 15, 14, 9, 10, 16, 15, 10, 11, 17, 16 };
406 
407  const size_t num_elems = sizeof( conn ) / sizeof( int ) / 4;
408 
409  EntityHandle verts[num_vtx], faces[num_elems];
410  for( size_t i = 0; i < num_vtx; ++i )
411  {
412  error = mbImpl->create_vertex( coords + 3 * i, verts[i] );
413  if( error != MB_SUCCESS ) return error;
414  }
415 
416  for( size_t i = 0; i < num_elems; ++i )
417  {
418  EntityHandle c[4];
419  for( int j = 0; j < 4; j++ )
420  c[j] = verts[conn[4 * i + j]];
421 
422  error = mbImpl->create_element( MBQUAD, c, 4, faces[i] );
423  if( error != MB_SUCCESS ) return error;
424  }
425  }
426  else if( type == MBTET )
427  {
428  const double coords[] = { 0, 0, 0, 1, 0, 0, 0, 1, 0, -1, 0, 0, 0, -1, 0, 0, 0, 1 };
429 
430  const size_t num_vtx = sizeof( coords ) / sizeof( double ) / 3;
431 
432  const int conn[] = { 0, 1, 2, 5, 3, 0, 2, 5, 4, 1, 0, 5, 4, 0, 3, 5 };
433 
434  const size_t num_elems = sizeof( conn ) / sizeof( int ) / 4;
435 
436  EntityHandle verts[num_vtx], cells[num_elems];
437  for( size_t i = 0; i < num_vtx; ++i )
438  {
439  error = mbImpl->create_vertex( coords + 3 * i, verts[i] );
440  if( error != MB_SUCCESS ) return error;
441  }
442 
443  for( size_t i = 0; i < num_elems; ++i )
444  {
445  EntityHandle c[4];
446  for( int j = 0; j < 4; j++ )
447  c[j] = verts[conn[4 * i + j]];
448 
449  error = mbImpl->create_element( MBTET, c, 4, cells[i] );
450  if( error != MB_SUCCESS ) return error;
451  }
452  }
453  else if( type == MBHEX )
454  {
455  const double coords[] = { 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 1, 0, 1, 1, 0, 2, 1, 0, 0, 2, 0, 1, 2, 0, 2, 2, 0,
456  0, 0, 1, 1, 0, 1, 2, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 1, 0, 2, 1, 1, 2, 1, 2, 2, 1 };
457  const size_t num_vtx = sizeof( coords ) / sizeof( double ) / 3;
458 
459  const int conn[] = { 0, 1, 4, 3, 9, 10, 13, 12, 1, 2, 5, 4, 10, 11, 14, 13,
460  3, 4, 7, 6, 12, 13, 16, 15, 4, 5, 8, 7, 13, 14, 17, 16 };
461  const size_t num_elems = sizeof( conn ) / sizeof( int ) / 8;
462 
463  EntityHandle verts[num_vtx], cells[num_elems];
464  for( size_t i = 0; i < num_vtx; ++i )
465  {
466  error = mbImpl->create_vertex( coords + 3 * i, verts[i] );
467  if( error != MB_SUCCESS ) return error;
468  }
469 
470  for( size_t i = 0; i < num_elems; ++i )
471  {
472  EntityHandle c[8];
473  for( int j = 0; j < 8; j++ )
474  c[j] = verts[conn[8 * i + j]];
475 
476  error = mbImpl->create_element( MBHEX, c, 8, cells[i] );
477  if( error != MB_SUCCESS ) return error;
478  }
479  }
480  return MB_SUCCESS;
481 }
482 
483 ErrorCode test_mesh( EntityType type, int* level_degrees, int num_level )
484 {
485  ErrorCode error;
486  Core mb;
487 
488  error = create_simple_mesh( &mb, type );
489  if( error != MB_SUCCESS ) return error;
490 
491  OUTTYPE output = BOTH;
492  error = umr_perf_test( &mb, level_degrees, num_level, output );
493  if( error != MB_SUCCESS ) return error;
494 
495  return MB_SUCCESS;
496 }
497 
498 ErrorCode test_1D()
499 {
500  ErrorCode error;
501  std::cout << std::endl;
502  std::cout << "EntityType = MBEDGE" << std::endl;
503 
504  std::cout << "Deg = 2" << std::endl;
505  int deg[7] = { 5, 5, 2, 2, 2, 2, 2 };
506  int len = sizeof( deg ) / sizeof( int );
507  error = test_mesh( MBEDGE, deg, len );
508  if( error != MB_SUCCESS ) return error;
509 
510  std::cout << std::endl;
511  std::cout << "Deg = 3" << std::endl;
512  deg[4] = 3;
513  deg[5] = 3;
514  deg[6] = 3;
515  error = test_mesh( MBEDGE, deg, len );
516  if( error != MB_SUCCESS ) return error;
517 
518  std::cout << std::endl;
519  std::cout << "Deg = 5" << std::endl;
520  deg[4] = 5;
521  deg[5] = 5;
522  deg[6] = 5;
523  error = test_mesh( MBEDGE, deg, len );
524  if( error != MB_SUCCESS ) return error;
525 
526  return MB_SUCCESS;
527 }
528 
529 ErrorCode test_2D()
530 {
531  ErrorCode error;
532  EntityType type = MBTRI;
533  std::cout << std::endl;
534  std::cout << "EntityType = MBTRI" << std::endl;
535 
536  std::cout << "Deg = 2" << std::endl;
537  int deg[5] = { 5, 2, 2, 2, 2 };
538  int len = sizeof( deg ) / sizeof( int );
539  error = test_mesh( type, deg, len );
540  if( error != MB_SUCCESS ) return error;
541 
542  std::cout << std::endl;
543  std::cout << "Deg = 3" << std::endl;
544  deg[2] = 3;
545  deg[3] = 3;
546  deg[4] = 3;
547  error = test_mesh( type, deg, len );
548  if( error != MB_SUCCESS ) return error;
549 
550  std::cout << std::endl;
551  std::cout << "Deg = 5" << std::endl;
552  deg[2] = 5;
553  deg[3] = 5;
554  deg[4] = 5;
555  error = test_mesh( type, deg, len );
556  if( error != MB_SUCCESS ) return error;
557 
558  type = MBQUAD;
559  std::cout << std::endl;
560  std::cout << "EntityType = MBQUAD" << std::endl;
561 
562  std::cout << "Deg = 2" << std::endl;
563  deg[2] = 2;
564  deg[3] = 2;
565  deg[4] = 2;
566  error = test_mesh( type, deg, len );
567  if( error != MB_SUCCESS ) return error;
568 
569  std::cout << std::endl;
570  std::cout << "Deg = 3" << std::endl;
571  deg[2] = 3;
572  deg[3] = 3;
573  deg[4] = 3;
574  error = test_mesh( type, deg, len );
575  if( error != MB_SUCCESS ) return error;
576 
577  std::cout << std::endl;
578  std::cout << "Deg = 5" << std::endl;
579  deg[2] = 5;
580  deg[3] = 5;
581  deg[4] = 5;
582  error = test_mesh( type, deg, len );
583  if( error != MB_SUCCESS ) return error;
584 
585  return MB_SUCCESS;
586 }
587 
588 ErrorCode test_3D()
589 {
590  ErrorCode error;
591  EntityType type = MBTET;
592  std::cout << std::endl;
593  std::cout << "EntityType = MBTET" << std::endl;
594 
595  std::cout << "Deg = 2" << std::endl;
596  int deg[6] = { 2, 2, 2, 2, 2, 2 };
597  int len = sizeof( deg ) / sizeof( int );
598  error = test_mesh( type, deg, len );
599  if( error != MB_SUCCESS ) return error;
600 
601  std::cout << std::endl;
602  std::cout << "Deg = 3" << std::endl;
603  deg[3] = 3;
604  deg[4] = 3;
605  deg[5] = 3;
606  error = test_mesh( type, deg, len );
607  if( error != MB_SUCCESS ) return error;
608 
609  type = MBHEX;
610  std::cout << std::endl;
611  std::cout << "EntityType = MBHEX" << std::endl;
612 
613  std::cout << "Deg = 2" << std::endl;
614  deg[3] = 2;
615  deg[4] = 2;
616  deg[5] = 2;
617  error = test_mesh( type, deg, len );
618  if( error != MB_SUCCESS ) return error;
619 
620  std::cout << std::endl;
621  std::cout << "Deg = 3" << std::endl;
622  deg[3] = 3;
623  deg[4] = 3;
624  deg[5] = 3;
625  error = test_mesh( type, deg, len );
626  if( error != MB_SUCCESS ) return error;
627 
628  return MB_SUCCESS;
629 }
630 
631 ErrorCode perf_inmesh( const char* filename, int* level_degrees, int num_levels, OUTTYPE output )
632 {
633  ErrorCode error;
634  Core mb;
635  Interface* mbImpl = &mb;
636 
637 #ifdef MOAB_HAVE_MPI
638  int procs = 1;
639  MPI_Comm_size( MPI_COMM_WORLD, &procs );
640 
641  if( procs > 1 )
642  {
643  read_options = "PARALLEL=READ_PART;PARTITION=PARALLEL_PARTITION;PARALLEL_RESOLVE_SHARED_ENTS;";
644 
645  error = mbImpl->load_file( filename, 0, read_options.c_str() );CHECK_ERR( error );
646  }
647  else if( procs == 1 )
648  {
649 #endif
650  error = mbImpl->load_file( filename );CHECK_ERR( error );
651 #ifdef MOAB_HAVE_MPI
652  }
653 #endif
654  // OUTTYPE output = MEM;
655  error = umr_perf_test( &mb, level_degrees, num_levels, output );
656  if( error != MB_SUCCESS ) return error;
657 
658  return MB_SUCCESS;
659 }
660 
661 int main( int argc, char* argv[] )
662 {
663 
664 #ifdef MOAB_HAVE_MPI
665  MPI_Init( &argc, &argv );
666 
667  int nprocs, rank;
668  MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
669  MPI_Comm_rank( MPI_COMM_WORLD, &rank );
670 #endif
671 
672 #ifdef MOAB_HAVE_MPI
673  if( rank == 0 ) std::cout << " para_umr_perf: ";
674 #else
675  std::cout << "umr_perf:";
676 #endif
677 
678  if( argc == 1 )
679  {
680  ErrorCode result;
681 
682  result = test_1D();
683  handle_error_code( result, number_tests_failed, number_tests_successful );
684  std::cout << "\n";
685 
686  result = test_2D();
687  handle_error_code( result, number_tests_failed, number_tests_successful );
688  std::cout << "\n";
689 
690  result = test_3D();
691  handle_error_code( result, number_tests_failed, number_tests_successful );
692  std::cout << "\n";
693  }
694 
695  else if( argc == 2 )
696  {
697  const char* filename = argv[1];
698  ErrorCode result;
699 
700  OUTTYPE output = MEM;
701 
702  if( output == MEM )
703  {
704  int deg[3] = { 2, 2, 2 };
705  int len = sizeof( deg ) / sizeof( int );
706  result = perf_inmesh( filename, deg, len, output );
707  handle_error_code( result, number_tests_failed, number_tests_successful );
708  std::cout << "\n";
709 
710  deg[0] = 3;
711  deg[1] = 3;
712  deg[2] = 3;
713  result = perf_inmesh( filename, deg, len, output );
714  handle_error_code( result, number_tests_failed, number_tests_successful );
715  std::cout << "\n";
716 
717  /* deg[0] = 5; deg[1] = 5; deg[2] = 5;
718  result = perf_inmesh(filename, deg, len, output);
719  handle_error_code(result, number_tests_failed, number_tests_successful);
720  std::cout<<"\n";*/
721  }
722  else if( output == TIME )
723  {
724  for( int L = 0; L < 3; L++ )
725  {
726  int* level_degrees = new int[L + 1];
727  for( int i = 0; i < L + 1; i++ )
728  {
729  level_degrees[i] = 3;
730  }
731 
732  result = perf_inmesh( filename, level_degrees, L + 1, output );
733  handle_error_code( result, number_tests_failed, number_tests_successful );
734  std::cout << "\n";
735 
736  delete[] level_degrees;
737  }
738  }
739  }
740  else
741  {
742  std::cerr << "Usage: " << argv[0] << " [filename]" << std::endl;
743  return 1;
744  }
745 
746 #ifdef MOAB_HAVE_MPI
747  MPI_Finalize();
748 #endif
749 
750  return number_tests_failed;
751 }