 |
Mesh Oriented datABase
(version 5.4.1)
Array-based unstructured mesh datastructure
|
|
Mesh Oriented datABase
(version 5.4.1)
Array-based unstructured mesh datastructure
|
00001 #include "moab/Core.hpp"
00002 #include "moab/Range.hpp"
00003 #include "moab/CN.hpp"
00004
00005 #include
00006 #include
00007 #include
00008 #include
00009 #include
00010 #include
00011
00012 #ifndef _WIN32
00013 #include
00014 #include
00015 #include
00016 #endif
00017
00018 static void usage( const char* argv0, bool help = false )
00019 {
00020 std::ostream& str = help ? std::cout : std::cerr;
00021 str << "Usage: " << argv0 << " [-H|-b|-k|-m] [ ...]" << std::endl
00022 << " " << argv0 << " [-H|-b|-k|-m] -T" << std::endl;
00023 if( !help )
00024 {
00025 str << " " << argv0 << " -h" << std::endl;
00026 std::exit( 1 );
00027 }
00028
00029 std::cerr << " -H : human readable units" << std::endl
00030 << " -b : bytes" << std::endl
00031 << " -k : kilobytes (1 kB == 1024 bytes)" << std::endl
00032 << " -m : megabytes (1 MB == 1024 kB)" << std::endl
00033 << " -g : gigabytes (1 GB == 1024 MB)" << std::endl
00034 << " -T : test mode" << std::endl
00035 << std::endl;
00036 std::exit( 0 );
00037 }
00038
00039 enum Units
00040 {
00041 HUMAN,
00042 BYTES,
00043 KILOBYTES,
00044 MEGABYTES,
00045 GIGABYTES
00046 };
00047 Units UNITS = HUMAN;
00048
00049 // The core functionality of this example
00050 static void print_memory_stats( moab::Interface& mb,
00051 bool per_type = true,
00052 bool per_tag = true,
00053 bool totals = true,
00054 bool sysstats = true );
00055
00056 // Generate a series of meshes for testing
00057 static void do_test_mode();
00058
00059 // main routine: read any specified files and call print_memory_stats
00060 int main( int argc, char* argv[] )
00061 {
00062 moab::ErrorCode rval;
00063 bool no_more_flags = false;
00064 bool test_mode = false;
00065 std::vector< int > input_file_list;
00066
00067 // load each file specified on command line
00068 for( int i = 1; i < argc; ++i )
00069 {
00070 if( !no_more_flags && argv[i][0] == '-' )
00071 {
00072 if( !strcmp( argv[i], "-H" ) )
00073 UNITS = HUMAN;
00074 else if( !strcmp( argv[i], "-b" ) )
00075 UNITS = BYTES;
00076 else if( !strcmp( argv[i], "-k" ) )
00077 UNITS = KILOBYTES;
00078 else if( !strcmp( argv[i], "-m" ) )
00079 UNITS = MEGABYTES;
00080 else if( !strcmp( argv[i], "-g" ) )
00081 UNITS = GIGABYTES;
00082 else if( !strcmp( argv[i], "-T" ) )
00083 test_mode = true;
00084 else if( !strcmp( argv[i], "-h" ) )
00085 usage( argv[0], true );
00086 else if( !strcmp( argv[i], "--" ) )
00087 no_more_flags = true;
00088 else
00089 {
00090 std::cerr << argv[0] << ": Invalid flag: \"" << argv[i] << "\"." << std::endl << std::endl;
00091 usage( argv[0] );
00092 }
00093 }
00094 else
00095 {
00096 input_file_list.push_back( i );
00097 }
00098 }
00099
00100 if( test_mode )
00101 {
00102 do_test_mode();
00103 if( input_file_list.empty() ) return 0;
00104 }
00105
00106 moab::Core mbcore;
00107 moab::Interface& mb = mbcore;
00108 for( std::vector< int >::iterator it = input_file_list.begin(); it != input_file_list.end(); ++it )
00109 {
00110 rval = mb.load_file( argv[*it] );
00111
00112 // if file load failed, print some info and exit
00113 if( moab::MB_SUCCESS != rval )
00114 {
00115 std::string message;
00116 mb.get_last_error( message );
00117 std::cerr << mb.get_error_string( rval ) << ": " << message << std::endl
00118 << argv[*it] << ": Failed to read file." << std::endl;
00119 return 1;
00120 }
00121
00122 std::cout << "Loaded file: " << argv[*it] << std::endl;
00123 }
00124
00125 // print summary of MOAB's memory use
00126 print_memory_stats( mb );
00127 return 0;
00128 }
00129
00130 // struct to store memory stats
00131 struct MemStats
00132 {
00133 unsigned long long total_storage;
00134 unsigned long long total_amortized;
00135 unsigned long long entity_storage;
00136 unsigned long long entity_amortized;
00137 unsigned long long adjacency_storage;
00138 unsigned long long adjacency_amortized;
00139 unsigned long long tag_storage;
00140 unsigned long long tag_amortized;
00141 };
00142
00143 // test if MemStats object indicates no memory
00144 static bool is_zero( const MemStats& stats );
00145
00146 // populdate a MemStats structg by calling
00147 // moab::Interface::estimated_memory_use
00148 static void get_mem_stats( moab::Interface& mb, MemStats& data, moab::EntityType type = moab::MBMAXTYPE );
00149
00150 // Formatted string representation of memory size value
00151 static std::string memstr( unsigned long long val );
00152
00153 // Get string describing tag data type
00154 static std::string tag_type_string( moab::Interface& mb, moab::Tag tag );
00155
00156 // Get string representation of tag storage type
00157 static std::string tag_storage_string( moab::Interface& mb, moab::Tag tag );
00158
00159 // Center
00160 static std::string center( const char* str, size_t width );
00161
00162 void print_memory_stats( moab::Interface& mb, bool per_type, bool per_tag, bool totals, bool sysstats )
00163 {
00164 moab::ErrorCode rval;
00165 const char ANON_TAG_NAME[] = "(anonymous)";
00166 const int TYPE_WIDTH = 10;
00167 const int MEM_WIDTH = 7;
00168 const int MEM2_WIDTH = 2 * MEM_WIDTH + 1;
00169 const int MIN_TAG_NAME_WIDTH = strlen( ANON_TAG_NAME );
00170 const int DTYPE_WIDTH = 12;
00171 const int STORAGE_WIDTH = 8;
00172
00173 // per-entity-type table header
00174 MemStats stats;
00175
00176 if( per_type )
00177 {
00178
00179 std::cout.fill( ' ' );
00180 std::cout << std::left << std::setw( TYPE_WIDTH ) << "Type" << ' ' << center( "Total", MEM2_WIDTH ) << ' '
00181 << center( "Entity", MEM2_WIDTH ) << ' ' << center( "Adjacency", MEM2_WIDTH ) << ' '
00182 << center( "Tag", MEM2_WIDTH ) << ' ' << std::endl
00183 << std::setw( TYPE_WIDTH ) << " ";
00184 for( int i = 0; i < 4; ++i )
00185 std::cout << ' ' << std::left << std::setw( MEM_WIDTH ) << "Used" << ' ' << std::left
00186 << std::setw( MEM_WIDTH ) << "Alloc";
00187 std::cout << std::endl;
00188 std::cout.fill( '-' );
00189 std::cout << std::setw( TYPE_WIDTH ) << '-';
00190 for( int i = 0; i < 8; ++i )
00191 std::cout << ' ' << std::setw( MEM_WIDTH ) << '-';
00192 std::cout.fill( ' ' );
00193 std::cout << std::endl;
00194
00195 // per-entity-type memory use
00196 for( moab::EntityType t = moab::MBVERTEX; t != moab::MBMAXTYPE; ++t )
00197 {
00198 get_mem_stats( mb, stats, t );
00199 if( is_zero( stats ) ) continue; // skip types with no allocated memory
00200
00201 std::cout << std::left << std::setw( TYPE_WIDTH ) << moab::CN::EntityTypeName( t ) << ' ' << std::right
00202 << std::setw( MEM_WIDTH ) << memstr( stats.total_storage ) << ' ' << std::right
00203 << std::setw( MEM_WIDTH ) << memstr( stats.total_amortized ) << ' ' << std::right
00204 << std::setw( MEM_WIDTH ) << memstr( stats.entity_storage ) << ' ' << std::right
00205 << std::setw( MEM_WIDTH ) << memstr( stats.entity_amortized ) << ' ' << std::right
00206 << std::setw( MEM_WIDTH ) << memstr( stats.adjacency_storage ) << ' ' << std::right
00207 << std::setw( MEM_WIDTH ) << memstr( stats.adjacency_amortized ) << ' ' << std::right
00208 << std::setw( MEM_WIDTH ) << memstr( stats.tag_storage ) << ' ' << std::right
00209 << std::setw( MEM_WIDTH ) << memstr( stats.tag_amortized ) << std::endl;
00210 }
00211 } // end per_type
00212
00213 if( per_tag )
00214 {
00215 // get list of tags
00216 std::vector< moab::Tag > tags;
00217 std::vector< moab::Tag >::const_iterator ti;
00218 mb.tag_get_tags( tags );
00219
00220 // figure out required field with to fit longest tag name
00221 unsigned maxlen = MIN_TAG_NAME_WIDTH;
00222 for( ti = tags.begin(); ti != tags.end(); ++ti )
00223 {
00224 std::string name;
00225 rval = mb.tag_get_name( *ti, name );
00226 if( moab::MB_SUCCESS != rval ) continue;
00227 if( name.size() > maxlen ) maxlen = name.size();
00228 }
00229
00230 // print header for per-tag data
00231 if( !tags.empty() )
00232 {
00233 std::cout.fill( ' ' );
00234 std::cout << std::endl
00235 << std::left << std::setw( maxlen ) << "Tag Name" << ' ' << std::left << std::setw( DTYPE_WIDTH )
00236 << "Type" << ' ' << std::left << std::setw( STORAGE_WIDTH ) << "Storage" << ' ' << std::left
00237 << std::setw( MEM_WIDTH ) << "Used" << ' ' << std::left << std::setw( MEM_WIDTH ) << "Alloc"
00238 << std::endl;
00239 std::cout.fill( '-' );
00240 std::cout << std::setw( maxlen ) << '-' << ' ' << std::setw( DTYPE_WIDTH ) << '-' << ' '
00241 << std::setw( STORAGE_WIDTH ) << '-' << ' ' << std::setw( MEM_WIDTH ) << '-' << ' '
00242 << std::setw( MEM_WIDTH ) << '-' << std::endl;
00243 std::cout.fill( ' ' );
00244 }
00245
00246 // print per-tag memory use
00247 for( ti = tags.begin(); ti != tags.end(); ++ti )
00248 {
00249 std::string name;
00250 rval = mb.tag_get_name( *ti, name );
00251 if( moab::MB_SUCCESS != rval || name.empty() ) name = ANON_TAG_NAME;
00252
00253 unsigned long long occupied, allocated;
00254 mb.estimated_memory_use( 0, 0, 0, 0, 0, 0, 0, 0, &*ti, 1, &occupied, &allocated );
00255
00256 std::cout << std::left << std::setw( maxlen ) << name << ' ' << std::right << std::setw( DTYPE_WIDTH )
00257 << tag_type_string( mb, *ti ) << ' ' << std::right << std::setw( STORAGE_WIDTH )
00258 << tag_storage_string( mb, *ti ) << ' ' << std::right << std::setw( MEM_WIDTH )
00259 << memstr( occupied ) << ' ' << std::right << std::setw( MEM_WIDTH ) << memstr( allocated )
00260 << std::endl;
00261 }
00262 } // end per_tag
00263
00264 if( totals )
00265 {
00266 // print summary of overall memory use
00267 get_mem_stats( mb, stats );
00268 std::cout << std::endl
00269 << "TOTAL: (Used/Allocated)" << std::endl
00270 << "memory: " << memstr( stats.total_storage ) << "/" << memstr( stats.total_amortized )
00271 << std::endl
00272 << "entity: " << memstr( stats.entity_storage ) << "/" << memstr( stats.entity_amortized )
00273 << std::endl
00274 << "adjacency: " << memstr( stats.adjacency_storage ) << "/" << memstr( stats.adjacency_amortized )
00275 << std::endl
00276 << "tag: " << memstr( stats.tag_storage ) << "/" << memstr( stats.tag_amortized ) << std::endl
00277 << std::endl;
00278
00279 } // end totals
00280
00281 if( sysstats )
00282 {
00283 std::FILE* filp = std::fopen( "/proc/self/stat", "r" );
00284 unsigned long long vsize;
00285 long rss;
00286 if( filp && 2 == std::fscanf( filp,
00287 "%*d " // pid
00288 "%*s " // comm
00289 "%*c " // state
00290 "%*d " // ppid
00291 "%*d " // pgrp
00292 "%*d " // session
00293 "%*d " // tty_nr
00294 "%*d " // tpgid
00295 "%*u " // flags
00296 "%*u " // minflt
00297 "%*u " // cminflt
00298 "%*u " // majflt
00299 "%*u " // cmajflt
00300 "%*u " // utime
00301 "%*u " // stime
00302 "%*d " // cutime
00303 "%*d " // cstime
00304 "%*d " // priority
00305 "%*d " // nice
00306 "%*d " // num_threads
00307 "%*d " // itrealvalue
00308 "%*u " // starttime
00309 "%llu " // vsize
00310 "%ld", // rss
00311 &vsize, &rss ) )
00312 {
00313 #ifndef _WIN32
00314 long long tmprss = rss * getpagesize();
00315 #endif
00316 std::cout << std::endl
00317 << "SYSTEM:" << std::endl
00318 << "Virtual memory: " << memstr( vsize )
00319 #ifndef _WIN32
00320 << std::endl
00321 << "Resident set size: " << memstr( tmprss )
00322 #endif
00323 << std::endl;
00324 }
00325 else
00326 {
00327 #ifndef _WIN32
00328 struct rusage sysdata;
00329 if( getrusage( RUSAGE_SELF, &sysdata ) )
00330 {
00331 std::cerr << "getrusage failed" << std::endl;
00332 }
00333 else
00334 {
00335 rss = sysdata.ru_maxrss;
00336 long long tmprss = rss * getpagesize();
00337 std::cerr << std::endl
00338 << "SYSTEM:" << std::endl
00339 << "Resident set size: " << memstr( tmprss ) << std::endl;
00340 }
00341 #endif
00342 }
00343 if( filp ) fclose( filp );
00344 } // end sysstats
00345 }
00346
00347 bool is_zero( const MemStats& stats )
00348 {
00349 return stats.total_amortized == 0;
00350 }
00351
00352 void get_mem_stats( moab::Interface& mb, MemStats& data, moab::EntityType type )
00353 {
00354 if( type != moab::MBMAXTYPE )
00355 {
00356 moab::Range range;
00357 mb.get_entities_by_type( 0, type, range );
00358 mb.estimated_memory_use( range, &data.total_storage, &data.total_amortized, &data.entity_storage,
00359 &data.entity_amortized, &data.adjacency_storage, &data.adjacency_amortized, 0, 0,
00360 &data.tag_storage, &data.tag_amortized );
00361 }
00362 else
00363 {
00364 mb.estimated_memory_use( 0, 0, &data.total_storage, &data.total_amortized, &data.entity_storage,
00365 &data.entity_amortized, &data.adjacency_storage, &data.adjacency_amortized, 0, 0,
00366 &data.tag_storage, &data.tag_amortized );
00367 }
00368 }
00369
00370 // rounded division
00371 static unsigned long long rdiv( unsigned long long num, unsigned long long den )
00372 {
00373 return ( num + den / 2 ) / den;
00374 }
00375
00376 std::string memstr( unsigned long long val )
00377 {
00378 const unsigned long long kb = 1024;
00379 const unsigned long long mb = kb * kb;
00380 const unsigned long long gb = kb * mb;
00381 const unsigned long long tb = kb * gb;
00382
00383 std::ostringstream s;
00384 if( UNITS == HUMAN )
00385 {
00386 if( val >= 10 * tb )
00387 s << rdiv( val, tb ) << "TB";
00388 else if( val >= 10 * gb )
00389 s << rdiv( val, gb ) << "GB";
00390 else if( val >= 10 * mb )
00391 s << rdiv( val, mb ) << "MB";
00392 else if( val >= 10 * kb )
00393 s << rdiv( val, kb ) << "kB";
00394 else if( val > 0 )
00395 s << val << " B";
00396 else
00397 s << "0 ";
00398 }
00399 else
00400 {
00401 unsigned long long den = 1;
00402 switch( UNITS )
00403 {
00404 case BYTES:
00405 den = 1;
00406 break;
00407 case KILOBYTES:
00408 den = kb;
00409 break;
00410 case MEGABYTES:
00411 den = mb;
00412 break;
00413 case GIGABYTES:
00414 den = gb;
00415 break;
00416 case HUMAN:
00417 break; // handled above, list here to suppress warning
00418 }
00419
00420 s << rdiv( val, den );
00421 }
00422 return s.str();
00423 }
00424
00425 std::string tag_type_string( moab::Interface& mb, moab::Tag tag )
00426 {
00427 moab::ErrorCode rval;
00428 std::ostringstream s;
00429
00430 moab::DataType type;
00431 rval = mb.tag_get_data_type( tag, type );
00432 if( moab::MB_SUCCESS != rval ) return std::string();
00433
00434 int typesize;
00435 std::string typestr;
00436 switch( type )
00437 {
00438 case moab::MB_TYPE_INTEGER:
00439 typestr = "int";
00440 typesize = sizeof( int );
00441 break;
00442 case moab::MB_TYPE_DOUBLE:
00443 typestr = "double";
00444 typesize = sizeof( double );
00445 break;
00446 case moab::MB_TYPE_HANDLE:
00447 typestr = "handle";
00448 typesize = sizeof( moab::EntityHandle );
00449 break;
00450 case moab::MB_TYPE_BIT:
00451 typesize = 1;
00452 typestr = "bits";
00453 break;
00454 case moab::MB_TYPE_OPAQUE:
00455 typesize = 1;
00456 typestr = "bytes";
00457 break;
00458 default:
00459 typesize = 1;
00460 typestr = "???";
00461 break;
00462 }
00463
00464 int size;
00465 rval = mb.tag_get_length( tag, size );
00466 if( moab::MB_VARIABLE_DATA_LENGTH == rval )
00467 s << "VAR " << typestr;
00468 else if( moab::MB_SUCCESS == rval )
00469 s << size / typesize << " " << typestr;
00470 // else do nothing
00471
00472 return s.str();
00473 }
00474
00475 std::string tag_storage_string( moab::Interface& mb, moab::Tag tag )
00476 {
00477 moab::ErrorCode rval;
00478 moab::TagType type;
00479 rval = mb.tag_get_type( tag, type );
00480 if( moab::MB_SUCCESS != rval ) return std::string();
00481
00482 switch( type )
00483 {
00484 case moab::MB_TAG_DENSE:
00485 return "dense";
00486 case moab::MB_TAG_SPARSE:
00487 return "sparse";
00488 case moab::MB_TAG_BIT:
00489 return "bit";
00490 default:
00491 return "(none)";
00492 }
00493 }
00494
00495 std::string center( const char* str, size_t width )
00496 {
00497 std::string text( str );
00498 if( text.size() >= width ) return text;
00499
00500 width -= text.size();
00501 if( 1u == width )
00502 {
00503 text += " ";
00504 return text;
00505 }
00506
00507 std::ostringstream s;
00508 s << std::setw( width / 2 ) << ' ' << text << std::setw( width / 2 + width % 2 ) << ' ';
00509 return s.str();
00510 }
00511
00512 void do_test_mode()
00513 {
00514 const char prefix[] = "****************";
00515 moab::Core mbcore;
00516 moab::Interface& mb = mbcore;
00517 moab::ErrorCode rval;
00518 moab::Range handles;
00519 moab::EntityHandle h;
00520 moab::Range::iterator jt, it;
00521 const unsigned N = 1000;
00522
00523 // creating some vertices
00524 double coords[3] = { 1, 2, 3 };
00525 for( unsigned i = 0; i < N; ++i )
00526 mb.create_vertex( coords, h );
00527 std::cout << std::endl << prefix << "Created " << N << " vertices" << std::endl;
00528 print_memory_stats( mb, true, false, true, true );
00529
00530 for( unsigned i = 0; i < N; ++i )
00531 mb.create_vertex( coords, h );
00532 std::cout << std::endl << prefix << "Created another " << N << " vertices" << std::endl;
00533 print_memory_stats( mb, true, false, true, true );
00534
00535 for( int i = 0; i < 100; ++i )
00536 {
00537 for( unsigned j = 0; j < N; ++j )
00538 mb.create_vertex( coords, h );
00539 }
00540 std::cout << std::endl << prefix << "Created another " << 100 * N << " vertices" << std::endl;
00541 print_memory_stats( mb, true, false, true, true );
00542
00543 // create some elements
00544 handles.clear();
00545 mb.get_entities_by_type( 0, moab::MBVERTEX, handles );
00546 it = handles.begin();
00547 for( unsigned i = 0; i < N - 2; ++i, ++it )
00548 {
00549 jt = it;
00550 moab::EntityHandle conn[3];
00551 conn[0] = *jt;
00552 ++jt;
00553 conn[1] = *jt;
00554 ++jt;
00555 conn[2] = *jt;
00556 ++jt;
00557 mb.create_element( moab::MBTRI, conn, 3, h );
00558 }
00559 std::cout << std::endl << prefix << "Created " << N - 2 << " triangles" << std::endl;
00560 print_memory_stats( mb, true, false, true, true );
00561
00562 it = handles.begin();
00563 for( unsigned i = 0; i < N - 3; ++i, ++it )
00564 {
00565 jt = it;
00566 moab::EntityHandle conn[4];
00567 conn[0] = *jt;
00568 ++jt;
00569 conn[1] = *jt;
00570 ++jt;
00571 conn[2] = *jt;
00572 ++jt;
00573 conn[3] = *jt;
00574 ++jt;
00575 mb.create_element( moab::MBQUAD, conn, 4, h );
00576 }
00577 std::cout << std::endl << prefix << "Created " << N - 3 << " quads" << std::endl;
00578 print_memory_stats( mb, true, false, true, true );
00579
00580 for( int i = 0; i < 100; ++i )
00581 {
00582 it = handles.begin();
00583 for( unsigned j = 0; j < N - 3; ++j, ++it )
00584 {
00585 jt = it;
00586 moab::EntityHandle conn[4];
00587 conn[0] = *jt;
00588 ++jt;
00589 conn[1] = *jt;
00590 ++jt;
00591 conn[2] = *jt;
00592 ++jt;
00593 conn[3] = *jt;
00594 ++jt;
00595 mb.create_element( moab::MBQUAD, conn, 4, h );
00596 }
00597 }
00598 std::cout << std::endl << prefix << "Created another " << 100 * ( N - 3 ) << " quads" << std::endl;
00599 print_memory_stats( mb, true, false, true, true );
00600
00601 // set global ID
00602 moab::Tag tag;
00603 rval = mb.tag_get_handle( "GLOBAL_ID", 1, moab::MB_TYPE_INTEGER, tag );
00604 if( moab::MB_SUCCESS != rval )
00605 {
00606 std::cerr << "Failed to get GLOBAL_ID tag handle" << std::endl;
00607 return;
00608 }
00609 handles.clear();
00610 mb.get_entities_by_type( 0, moab::MBVERTEX, handles );
00611 int id = 1;
00612 for( it = handles.begin(); it != handles.end(); ++it )
00613 {
00614 mb.tag_set_data( tag, &*it, 1, &id );
00615 ++id;
00616 }
00617 std::cout << std::endl << prefix << "Set global ID tag on " << handles.size() << " vertices" << std::endl;
00618 print_memory_stats( mb, true, true, true, true );
00619
00620 handles.clear();
00621 mb.get_entities_by_type( 0, moab::MBQUAD, handles );
00622 id = 1;
00623 for( it = handles.begin(); it != handles.end(); ++it )
00624 {
00625 mb.tag_set_data( tag, &*it, 1, &id );
00626 ++id;
00627 }
00628 std::cout << std::endl << prefix << "Set global ID tag on " << handles.size() << " quads" << std::endl;
00629 print_memory_stats( mb, true, true, true, true );
00630
00631 // create and set a sparse tag
00632 mb.tag_get_handle( "mem_test_tag", 3, moab::MB_TYPE_DOUBLE, tag, moab::MB_TAG_SPARSE | moab::MB_TAG_CREAT );
00633 handles.clear();
00634 mb.get_entities_by_type( 0, moab::MBVERTEX, handles );
00635 for( it = handles.begin(); it != handles.end(); ++it )
00636 {
00637 mb.get_coords( &*it, 1, coords );
00638 mb.tag_set_data( tag, &*it, 1, coords );
00639 }
00640 std::cout << std::endl
00641 << prefix << "Copied vertex coords to sparse tag for " << handles.size() << " vertices" << std::endl;
00642 print_memory_stats( mb, true, true, true, true );
00643
00644 // create and set bit tag
00645 mb.tag_get_handle( "mem_test_bit", 1, moab::MB_TYPE_BIT, tag, moab::MB_TAG_CREAT );
00646 handles.clear();
00647 mb.get_entities_by_type( 0, moab::MBTRI, handles );
00648 for( it = handles.begin(); it != handles.end(); ++it )
00649 {
00650 char byte = '\001';
00651 mb.tag_set_data( tag, &*it, 1, &byte );
00652 }
00653 std::cout << std::endl << prefix << "Set 1-bit tag for " << handles.size() << " triangles" << std::endl;
00654 print_memory_stats( mb, true, true, true, true );
00655
00656 // create vertex to element adjacency data
00657 handles.clear();
00658 mb.get_entities_by_type( 0, moab::MBVERTEX, handles );
00659 std::vector< moab::EntityHandle > adj_vec;
00660 mb.get_adjacencies( &*handles.begin(), 1, 2, false, adj_vec );
00661 std::cout << std::endl << prefix << "Created vertex-to-element adjacencies" << std::endl;
00662 print_memory_stats( mb, true, false, true, true );
00663 std::cout << std::endl;
00664 }
1.7.6.1.
Dark theme by Tilen Majerle. All rights reserved.