seqperf.cpp

Go to the documentation of this file.

#include <ctime>
#include <cassert>
#include <iostream>
#include <sstream>
#include "moab/Core.hpp"
#include "moab/ReadUtilIface.hpp"
 
#define PRINT_SEQUENCE_COUNT
 
#ifdef PRINT_SEQUENCE_COUNT
#ifndef IS_BUILDING_MB
#define IS_BUILDING_MB
#endif
#include "EntitySequence.hpp"
#ifdef MB_ENTITY_SEQUENCE_HPP
#include "EntitySequenceManager.hpp"
#else
#include "SequenceManager.hpp"
#endif
#endif
 
using namespace moab;
 
// constants
const bool dump_mesh = false; //!< write mesh to vtk file
const int default_intervals = 25; //!< defaul interval count for cubic structured hex mesh
const int default_query_count = 100; //!< number of times to do each query set
const int default_order[] = { 0, 1, 2 };
const int default_create[] = { 0, 1 };
const int default_delete[] = { 0, 10, 30, 50, 70, 90 };
#define ARRSIZE( A ) ( sizeof( A ) / sizeof( ( A )[0] ) )
 
// input parameters
long numSideInt, numVert, numElem; //!< total counts;
int queryCount; //!< number of times to do each query set
 
// misc globals
Core mb_core; //!< moab instance
Interface& mb = mb_core; //!< moab instance
EntityHandle vertStart, elemStart; //!< first handle
ReadUtilIface* readTool = 0;
long* queryVertPermutation = 0; //!< pupulated by init(): "random" order for vertices
long* queryElemPermutation = 0; //!< pupulated by init(): "random" order for elements
 
//! Generate random permutation of values in [0,count-1]
long* permutation( long count )
{
 srand( count );
 long* array = new long[count];
 for( long i = 0; i < count; ++i )
 array[i] = i;
 
 for( long i = 0; i < count; ++i )
 {
 long r = rand();
 if( count > RAND_MAX )
 {
 r += RAND_MAX * rand();
 if( count / RAND_MAX > RAND_MAX )
 {
 long t = (long)RAND_MAX * rand();
 r += (long)RAND_MAX * t;
 }
 }
 std::swap( array[i], array[r % count] );
 }
 
 return array;
}
 
//! Initialize global variables
void init()
{
 ErrorCode rval = mb.query_interface( readTool );
 if( rval || !readTool )
 {
 assert( false );
 abort();
 }
 
 queryVertPermutation = permutation( numVert );
 queryElemPermutation = permutation( numElem );
}
 
void create_vertices_single(); //!< create vertices one at a time
void create_vertices_block(); //!< create vertices in block using ReadUtilIface
void create_elements_single(); //!< create elements one at a time
void create_elements_block(); //!< create elements in block using ReadUtilIface
 
void forward_order_query_vertices( int percent ); //!< calculate mean of all vertex coordinates
void reverse_order_query_vertices( int percent ); //!< calculate mean of all vertex coordinates
void random_order_query_vertices( int percent ); //!< calculate mean of all vertex coordinates
 
void forward_order_query_elements( int percent ); //!< check all element connectivity for valid vertex handles
void reverse_order_query_elements( int percent ); //!< check all element connectivity for valid vertex handles
void random_order_query_elements( int percent ); //!< check all element connectivity for valid vertex handles
 
void forward_order_query_element_verts( int percent ); //!< calculate centroid
void reverse_order_query_element_verts( int percent ); //!< calculate centroid
void random_order_query_element_verts( int percent ); //!< calculate centroid
 
void forward_order_delete_vertices( int percent ); //!< delete x% of vertices
void reverse_order_delete_vertices( int percent ); //!< delete x% of vertices
void random_order_delete_vertices( int percent ); //!< delete x% of vertices
 
void forward_order_delete_elements( int percent ); //!< delete x% of elements
void reverse_order_delete_elements( int percent ); //!< delete x% of elements
void random_order_delete_elements( int percent ); //!< delete x% of elements
 
void create_missing_vertices( int percent ); //!< re-create deleted vertices
void create_missing_elements( int percent ); //!< re-create deleted elements
 
#ifdef PRINT_SEQUENCE_COUNT
unsigned get_number_sequences( EntityType type );
#endif
 
/* Build arrays of function pointers, indexed by the order the entities are traversed in */
 
typedef void ( *naf_t )();
typedef void ( *iaf_t )( int );
 
iaf_t query_verts[3] = { &forward_order_query_vertices, &reverse_order_query_vertices, &random_order_query_vertices };
 
iaf_t query_elems[3] = { &forward_order_query_elements, &reverse_order_query_elements, &random_order_query_elements };
 
iaf_t query_elem_verts[3] = { &forward_order_query_element_verts, &reverse_order_query_element_verts,
 &random_order_query_element_verts };
 
iaf_t delete_verts[3] = { &forward_order_delete_vertices, &reverse_order_delete_vertices,
 &random_order_delete_vertices };
 
iaf_t delete_elems[3] = { &forward_order_delete_elements, &reverse_order_delete_elements,
 &random_order_delete_elements };
 
const char* order_strs[] = { "Forward", "Reverse", "Random" };
 
//! Coordinates for ith vertex in structured hex mesh
inline void vertex_coords( long vert_index, double& x, double& y, double& z );
//! Connectivity for ith hex in structured hex mesh
inline void element_conn( long elem_index, EntityHandle conn[8] );
//! True if passed index is one of the x% to be deleted
inline bool deleted_vert( long index, int percent );
//! True if passed index is one of the x% to be deleted
inline bool deleted_elem( long index, int percent );
//! if (deleted_vert(index,percent)) delete vertex
inline void delete_vert( long index, int percent );
//! if (deleted_elem(index,percent)) delete element
inline void delete_elem( long index, int percent );
 
//! print usage and exit
void usage()
{
 std::cerr << "Usage: seqperf [-i <intervals>] [-o <order>] [-d <percent>] [-b|-s] [-q <count>]" << std::endl;
 std::cerr << " -i specify size of cubic structured hex mesh in intervals. Default: " << default_intervals
 << std::endl;
 std::cerr << " -o one of \"forward\", \"reverse\", or \"random\". May be specified multiple "
 "times. Default is all."
 << std::endl;
 std::cerr << " -d percent of entities to delete. May be specified multiple times. Default is {";
 for( unsigned i = 0; i < ARRSIZE( default_delete ) - 1; ++i )
 std::cerr << default_delete[i] << ",";
 std::cerr << default_delete[ARRSIZE( default_delete ) - 1] << "}" << std::endl;
 std::cerr << " -b block creation of mesh" << std::endl;
 std::cerr << " -s single entity mesh creation" << std::endl;
 std::cerr << " -q number of times to repeat queries. Default: " << default_query_count << std::endl;
 exit( 1 );
}
 
//! convert CPU time to string
std::string ts( clock_t t )
{
 std::ostringstream s;
 s << ( (double)t ) / CLOCKS_PER_SEC << 's';
 return s.str();
}
 
//! run function, printing time spent
void TIME( const char* str, void ( *func )() )
{
 std::cout << str << "... " << std::flush;
 clock_t t = clock();
 ( *func )();
 std::cout << ts( clock() - t ) << std::endl;
}
 
//! run function query_repeat times, printing time spent
void TIME_QRY( const char* str, void ( *func )( int percent ), int percent )
{
 std::cout << str << "... " << std::flush;
 clock_t t = clock();
 for( int i = 0; i < queryCount; ++i )
 ( *func )( percent );
 std::cout << ts( clock() - t ) << std::endl;
}
 
//! run function with integer argument, printing time spent
void TIME_DEL( const char* str, void ( *func )( int ), int percent )
{
 std::cout << str << "... " << std::flush;
 clock_t t = clock();
 ( *func )( percent );
 std::cout << ts( clock() - t ) << std::endl;
}
 
//! call MB::delete_mesh(). function so can be passed to TIME
void delete_mesh()
{
 mb.delete_mesh();
}
 
//! Run a single combination of test parameters
void do_test( int create_mode, //!< 0 == single, 1 == block
 int order, //!< 0 == forward, 1 == reverse, 2 == random
 int percent ) //!< percent of entities to delete
{
 clock_t t = clock();
 if( create_mode )
 {
 std::cout << "Block Entity Creation (all entities in single block of memory)" << std::endl;
 TIME( " Creating initial vertices", create_vertices_block );
 TIME( " Creating initial elements", create_elements_block );
 if( dump_mesh && !percent && mb.write_file( "seqperf.vtk" ) == MB_SUCCESS )
 std::cout << "Wrote mesh to file: seqperf.vtk" << std::endl;
 }
 else
 {
 std::cout << "Single Entity Creation (entities grouped in memory blocks of constant size)" << std::endl;
 TIME( " Creating initial vertices", create_vertices_single );
 TIME( " Creating initial elements", create_elements_single );
 }
 
 std::cout << order_strs[order] << " order with deletion of " << percent << "% of vertices and elements"
 << std::endl;
 
 TIME_DEL( " Deleting elements", delete_elems[order], percent );
 TIME_DEL( " Deleting vertices", delete_verts[order], percent );
 
 int num_vert = 0;
 int num_elem = 0;
 mb.get_number_entities_by_type( 0, MBVERTEX, num_vert );
 mb.get_number_entities_by_type( 0, MBHEX, num_elem );
 std::cout << " " << num_vert << " vertices and " << num_elem << " elements remaining" << std::endl;
#ifdef PRINT_SEQUENCE_COUNT
 std::cout << " " << get_number_sequences( MBVERTEX ) << " vertex sequences and " << get_number_sequences( MBHEX )
 << " element sequences." << std::endl;
#endif
 
 TIME_QRY( " Querying vertex coordinates", query_verts[order], percent );
 TIME_QRY( " Querying element connectivity", query_elems[order], percent );
 TIME_QRY( " Querying element coordinates", query_elem_verts[order], percent );
 
 TIME_DEL( " Re-creating vertices", create_missing_vertices, percent );
 TIME_DEL( " Re-creating elements", create_missing_elements, percent );
 
 TIME( " Clearing mesh instance", delete_mesh );
 
 std::cout << "Total time for test: " << ts( clock() - t ) << std::endl << std::endl;
}
 
void parse_order( const char* str, std::vector< int >& list )
{
 if( str[0] == 'f' )
 {
 if( strncmp( str, "forward", strlen( str ) ) != 0 ) usage();
 list.push_back( 0 );
 }
 else if( str[0] != 'r' )
 usage();
 else if( str[1] == 'e' )
 {
 if( strncmp( str, "reverse", strlen( str ) ) != 0 ) usage();
 list.push_back( 0 );
 }
 else
 {
 if( strncmp( str, "random", strlen( str ) ) != 0 ) usage();
 list.push_back( 0 );
 }
}
 
void parse_percent( const char* str, std::vector< int >& list )
{
 char* endptr;
 long p = strtol( str, &endptr, 0 );
 if( !endptr || *endptr || p < 0 || p > 100 ) usage();
 
 list.push_back( (int)p );
}
 
int parse_positive_int( const char* str )
{
 char* endptr;
 long p = strtol( str, &endptr, 0 );
 if( !endptr || *endptr || p < 1 ) usage();
 int result = p;
 if( p != (long)result ) // overflow
 usage();
 
 return result;
}
 
void check_default( std::vector< int >& list, const int* array, size_t array_len )
{
 if( list.empty() ) std::copy( array, array + array_len, std::back_inserter( list ) );
}
 
int main( int argc, char* argv[] )
{
 // Parse arguments
 std::vector< int > createList, orderList, deleteList;
 numSideInt = default_intervals;
 queryCount = default_query_count;
 
 for( int i = 1; i < argc; ++i )
 {
 // check that arg is a '-' followed by a single character
 if( argv[i][0] != '-' || argv[i][1] == '\0' || argv[i][2] != '\0' ) usage();
 
 const char flag = argv[i][1];
 switch( flag )
 {
 case 'b':
 createList.push_back( 1 );
 break;
 case 's':
 createList.push_back( 0 );
 break;
 default:
 if( ++i == argc ) usage();
 switch( flag )
 {
 case 'i':
 numSideInt = parse_positive_int( argv[i] );
 break;
 case 'o':
 parse_order( argv[i], orderList );
 break;
 case 'd':
 parse_percent( argv[i], deleteList );
 break;
 case 'q':
 queryCount = parse_positive_int( argv[i] );
 break;
 default:
 usage();
 }
 }
 }
 check_default( createList, default_create, ARRSIZE( default_create ) );
 check_default( orderList, default_order, ARRSIZE( default_order ) );
 check_default( deleteList, default_delete, ARRSIZE( default_delete ) );
 
 // Do some initialization.
 
 int numSideVert = numSideInt + 1;
 numVert = numSideVert * numSideVert * numSideVert;
 numElem = numSideInt * numSideInt * numSideInt;
 if( numVert / numSideVert / numSideVert != numSideVert ) // overflow
 usage();
 init();
 
 // Echo input args
 
 std::cout << numSideInt << "x" << numSideInt << "x" << numSideInt << " hex grid: " << numElem << " elements and "
 << numVert << " vertices" << std::endl;
 
 // Run tests
 
 std::vector< int >::const_iterator i, j, k;
 clock_t t = clock();
 for( i = createList.begin(); i != createList.end(); ++i )
 {
 for( j = deleteList.begin(); j != deleteList.end(); ++j )
 {
 for( k = orderList.begin(); k != orderList.end(); ++k )
 {
 do_test( *i, *k, *j );
 }
 }
 }
 
 // Clean up
 
 std::cout << "TOTAL: " << ts( clock() - t ) << std::endl << std::endl;
 delete[] queryVertPermutation;
 delete[] queryElemPermutation;
 return 0;
}
 
inline void vertex_coords( long vert_index, double& x, double& y, double& z )
{
 const long vs = numSideInt + 1;
 x = vert_index % vs;
 y = ( vert_index / vs ) % vs;
 z = ( vert_index / vs / vs );
}
 
inline long vert_index( long x, long y, long z )
{
 const long vs = numSideInt + 1;
 return x + vs * ( y + vs * z );
}
 
inline void element_conn( long elem_index, EntityHandle conn[8] )
{
 const long x = elem_index % numSideInt;
 const long y = ( elem_index / numSideInt ) % numSideInt;
 const long z = ( elem_index / numSideInt / numSideInt );
 conn[0] = vertStart + vert_index( x, y, z );
 conn[1] = vertStart + vert_index( x + 1, y, z );
 conn[2] = vertStart + vert_index( x + 1, y + 1, z );
 conn[3] = vertStart + vert_index( x, y + 1, z );
 conn[4] = vertStart + vert_index( x, y, z + 1 );
 conn[5] = vertStart + vert_index( x + 1, y, z + 1 );
 conn[6] = vertStart + vert_index( x + 1, y + 1, z + 1 );
 conn[7] = vertStart + vert_index( x, y + 1, z + 1 );
}
 
inline bool deleted_vert( long index, int percent )
{
 return index % ( numSideInt + 1 ) >= ( numSideInt + 1 ) * ( 100 - percent ) / 100;
}
 
inline bool deleted_elem( long index, int percent )
{
 return index % numSideInt + 1 >= ( numSideInt + 1 ) * ( 100 - percent ) / 100;
}
 
void create_vertices_single()
{
 double coords[3];
 vertex_coords( 0, coords[0], coords[1], coords[2] );
 ErrorCode rval = mb.create_vertex( coords, vertStart );
 assert( !rval );
 if( rval )
 {
 } // empty line to remove compiler warning
 
 EntityHandle h;
 for( long i = 1; i < numVert; ++i )
 {
 vertex_coords( i, coords[0], coords[1], coords[2] );
 rval = mb.create_vertex( coords, h );
 assert( !rval );
 assert( h - vertStart == (EntityHandle)i );
 }
}
 
void create_vertices_block()
{
 std::vector< double* > arrays;
 ErrorCode rval = readTool->get_node_coords( 3, numVert, 0, vertStart, arrays );
 if( rval || arrays.size() != 3 )
 {
 assert( false );
 abort();
 }
 double *x = arrays[0], *y = arrays[1], *z = arrays[2];
 assert( x && y && z );
 
 for( long i = 0; i < numVert; ++i )
 vertex_coords( i, *x++, *y++, *z++ );
}
 
void create_elements_single()
{
 EntityHandle conn[8];
 element_conn( 0, conn );
 ErrorCode rval = mb.create_element( MBHEX, conn, 8, elemStart );
 if( rval )
 {
 assert( false );
 abort();
 }
 
 EntityHandle h;
 for( long i = 1; i < numElem; ++i )
 {
 element_conn( i, conn );
 rval = mb.create_element( MBHEX, conn, 8, h );
 assert( !rval );
 assert( h - elemStart == (EntityHandle)i );
 }
}
 
void create_elements_block()
{
 EntityHandle* conn = 0;
 ErrorCode rval = readTool->get_element_connect( numElem, 8, MBHEX, 0, elemStart, conn );
 if( rval && !conn )
 {
 assert( false );
 abort();
 }
 
 for( long i = 0; i < numElem; ++i )
 element_conn( i, conn + 8 * i );
}
 
void forward_order_query_vertices( int percent )
{
 ErrorCode r;
 double coords[3];
 long x, y, z;
 const long vert_per_edge = numSideInt + 1;
 const long deleted_x = ( numSideInt + 1 ) * ( 100 - percent ) / 100;
 EntityHandle h = vertStart;
 for( z = 0; z < vert_per_edge; ++z )
 {
 for( y = 0; y < vert_per_edge; ++y )
 {
 for( x = 0; x < deleted_x; ++x, ++h )
 {
 r = mb.get_coords( &h, 1, coords );
 if( MB_SUCCESS != r )
 {
 assert( false );
 abort();
 }
 }
 h += ( vert_per_edge - deleted_x );
 }
 }
}
 
void reverse_order_query_vertices( int percent )
{
 ErrorCode r;
 double coords[3];
 long x, y, z;
 const long vert_per_edge = numSideInt + 1;
 const long deleted_x = ( numSideInt + 1 ) * ( 100 - percent ) / 100;
 EntityHandle h = vertStart + numVert - 1;
 ;
 for( z = vert_per_edge - 1; z >= 0; --z )
 {
 for( y = vert_per_edge - 1; y >= 0; --y )
 {
 h -= ( vert_per_edge - deleted_x );
 for( x = deleted_x - 1; x >= 0; --x, --h )
 {
 r = mb.get_coords( &h, 1, coords );
 assert( MB_SUCCESS == r );
 if( r )
 {
 } // empty line to remove compiler warning
 }
 }
 }
}
 
void random_order_query_vertices( int percent )
{
 ErrorCode r;
 EntityHandle h;
 double coords[3];
 for( long i = 0; i < numVert; ++i )
 {
 if( !deleted_vert( queryVertPermutation[i], percent ) )
 {
 h = vertStart + queryVertPermutation[i];
 r = mb.get_coords( &h, 1, coords );
 assert( MB_SUCCESS == r );
 if( r )
 {
 } // empty line to remove compiler warning
 }
 }
}
 
void forward_order_query_elements( int percent )
{
 ErrorCode r;
 const EntityHandle* conn;
 int len;
 long x, y, z;
 const long elem_per_edge = numSideInt;
 const long deleted_x = ( numSideInt + 1 ) * ( 100 - percent ) / 100 - 1;
 EntityHandle h = elemStart;
 for( z = 0; z < elem_per_edge; ++z )
 {
 for( y = 0; y < elem_per_edge; ++y )
 {
 for( x = 0; x < deleted_x; ++x, ++h )
 {
 r = mb.get_connectivity( h, conn, len );
 assert( MB_SUCCESS == r );
 if( r )
 {
 } // empty line to remove compiler warning
 assert( conn && 8 == len );
 }
 h += ( elem_per_edge - deleted_x );
 }
 }
}
 
void reverse_order_query_elements( int percent )
{
 ErrorCode r;
 const EntityHandle* conn;
 int len;
 long x, y, z;
 const long elem_per_edge = numSideInt;
 const long deleted_x = ( numSideInt + 1 ) * ( 100 - percent ) / 100 - 1;
 EntityHandle h = elemStart + numElem - 1;
 ;
 for( z = elem_per_edge - 1; z >= 0; --z )
 {
 for( y = elem_per_edge - 1; y >= 0; --y )
 {
 h -= ( elem_per_edge - deleted_x );
 for( x = deleted_x - 1; x >= 0; --x, --h )
 {
 r = mb.get_connectivity( h, conn, len );
 assert( MB_SUCCESS == r );
 if( r )
 {
 } // empty line to remove compiler warning
 assert( conn && 8 == len );
 }
 }
 }
}
 
void random_order_query_elements( int percent )
{
 ErrorCode r;
 const EntityHandle* conn;
 int len;
 for( long i = 0; i < numElem; ++i )
 {
 if( !deleted_elem( queryElemPermutation[i], percent ) )
 {
 r = mb.get_connectivity( elemStart + queryElemPermutation[i], conn, len );
 assert( MB_SUCCESS == r );
 if( r )
 {
 } // empty line to remove compiler warning
 assert( conn && 8 == len );
 }
 }
}
 
/*
static double hex_centroid( double coords[24], double cent[3] )
{
 double a[3], b[3], c[3], vol;
 cent[0] += 0.125*(coords[0] + coords[3] + coords[6] + coords[ 9] + coords[12] + coords[15] +
coords[18] + coords[21]); cent[1] += 0.125*(coords[1] + coords[4] + coords[7] + coords[10] +
coords[13] + coords[16] + coords[19] + coords[22]); cent[2] += 0.125*(coords[2] + coords[5] +
coords[8] + coords[11] + coords[14] + coords[17] + coords[20] + coords[23]); a[0] = coords[0] +
coords[3] + coords[15] + coords[12] - coords[ 9] - coords[6] - coords[18] - coords[21]; a[1] =
coords[1] + coords[4] + coords[16] + coords[13] - coords[10] - coords[7] - coords[19] - coords[22];
 a[2] = coords[2] + coords[5] + coords[17] + coords[14] - coords[11] - coords[8] - coords[20] -
coords[23]; b[0] = coords[0] + coords[ 9] + coords[21] + coords[12] - coords[3] - coords[6] -
coords[18] - coords[15]; b[1] = coords[1] + coords[10] + coords[22] + coords[13] - coords[4] -
coords[7] - coords[19] - coords[16]; b[2] = coords[2] + coords[11] + coords[23] + coords[14] -
coords[5] - coords[8] - coords[20] - coords[17]; c[0] = coords[0] + coords[3] + coords[6] + coords[
9] - coords[12] - coords[15] - coords[18] - coords[21]; c[1] = coords[1] + coords[4] + coords[7] +
coords[10] - coords[13] - coords[16] - coords[19] - coords[22]; c[2] = coords[2] + coords[5] +
coords[8] + coords[11] - coords[14] - coords[17] - coords[20] - coords[23]; vol = c[0]*(a[1]*b[2] -
a[2]*b[1]) + c[1]*(a[2]*b[0] - a[0]*b[2]) + c[2]*(a[0]*b[1] - a[1]*b[0]); return (1./64.) * vol;
}
*/
 
void forward_order_query_element_verts( int percent )
{
 ErrorCode r = MB_SUCCESS;
 if( r )
 {
 } // empty line to remove compiler warning
 const EntityHandle* conn;
 int len;
 long x, y, z;
 double coords[24];
 const long elem_per_edge = numSideInt;
 const long deleted_x = ( numSideInt + 1 ) * ( 100 - percent ) / 100 - 1;
 EntityHandle h = elemStart;
 for( z = 0; z < elem_per_edge; ++z )
 {
 for( y = 0; y < elem_per_edge; ++y )
 {
 for( x = 0; x < deleted_x; ++x, ++h )
 {
 r = mb.get_connectivity( h, conn, len );
 assert( MB_SUCCESS == r );
 assert( conn && 8 == len );
 r = mb.get_coords( conn, len, coords );
 assert( MB_SUCCESS == r );
 }
 h += ( elem_per_edge - deleted_x );
 }
 }
}
 
void reverse_order_query_element_verts( int percent )
{
 ErrorCode r = MB_SUCCESS;
 if( r )
 {
 } // empty statement to remove compiler warning
 
 const EntityHandle* conn;
 int len;
 long x, y, z;
 double coords[24];
 const long elem_per_edge = numSideInt;
 const long deleted_x = ( numSideInt + 1 ) * ( 100 - percent ) / 100 - 1;
 EntityHandle h = elemStart + numElem - 1;
 ;
 for( z = elem_per_edge - 1; z >= 0; --z )
 {
 for( y = elem_per_edge - 1; y >= 0; --y )
 {
 h -= ( elem_per_edge - deleted_x );
 for( x = deleted_x - 1; x >= 0; --x, --h )
 {
 r = mb.get_connectivity( h, conn, len );
 assert( MB_SUCCESS == r );
 assert( conn && 8 == len );
 r = mb.get_coords( conn, len, coords );
 assert( MB_SUCCESS == r );
 }
 }
 }
}
 
void random_order_query_element_verts( int percent )
{
 ErrorCode r = MB_SUCCESS;
 if( r )
 {
 } // empty line to remove compiler warning
 const EntityHandle* conn;
 int len;
 double coords[24];
 for( long i = 0; i < numElem; ++i )
 {
 if( !deleted_elem( queryElemPermutation[i], percent ) )
 {
 r = mb.get_connectivity( elemStart + queryElemPermutation[i], conn, len );
 assert( MB_SUCCESS == r );
 assert( conn && 8 == len );
 r = mb.get_coords( conn, len, coords );
 assert( MB_SUCCESS == r );
 }
 }
}
 
void forward_order_delete_vertices( int percent )
{
 for( long i = 0; i < numVert; ++i )
 delete_vert( i, percent );
}
 
void reverse_order_delete_vertices( int percent )
{
 for( long i = numVert - 1; i >= 0; --i )
 delete_vert( i, percent );
}
 
void random_order_delete_vertices( int percent )
{
 for( long i = 0; i < numVert; ++i )
 delete_vert( queryVertPermutation[i], percent );
}
 
void forward_order_delete_elements( int percent )
{
 for( long i = 0; i < numElem; ++i )
 delete_elem( i, percent );
}
 
void reverse_order_delete_elements( int percent )
{
 for( long i = numElem - 1; i >= 0; --i )
 delete_elem( i, percent );
}
 
void random_order_delete_elements( int percent )
{
 for( long i = 0; i < numElem; ++i )
 delete_elem( queryElemPermutation[i], percent );
}
 
void create_missing_vertices( int percent )
{
 EntityHandle h;
 ErrorCode rval = MB_SUCCESS;
 if( rval )
 {
 } // empty line to remove compiler warning
 double coords[3];
 for( long i = 0; i < numVert; ++i )
 if( deleted_vert( i, percent ) )
 {
 vertex_coords( i, coords[0], coords[1], coords[2] );
 rval = mb.create_vertex( coords, h );
 assert( !rval );
 }
}
 
void create_missing_elements( int percent )
{
 EntityHandle h;
 ErrorCode rval;
 EntityHandle conn[8];
 for( long i = 0; i < numElem; ++i )
 if( deleted_elem( i, percent ) )
 {
 element_conn( i, conn );
 rval = mb.create_element( MBHEX, conn, 8, h );
 if( rval )
 {
 assert( false );
 abort();
 }
 }
}
 
inline void delete_vert( long index, int percent )
{
 if( deleted_vert( index, percent ) )
 {
 EntityHandle h = index + vertStart;
 ErrorCode rval = mb.delete_entities( &h, 1 );
 if( rval )
 {
 assert( false );
 abort();
 }
 }
}
 
inline void delete_elem( long index, int percent )
{
 if( deleted_elem( index, percent ) )
 {
 EntityHandle h = index + elemStart;
 ErrorCode rval = mb.delete_entities( &h, 1 );
 if( rval )
 {
 assert( false );
 abort();
 }
 }
}
 
#ifdef PRINT_SEQUENCE_COUNT
unsigned get_number_sequences( EntityType type )
{
#ifdef MB_ENTITY_SEQUENCE_HPP
 return mb_core.sequence_manager()->entity_map( type )->size();
#else
 return mb_core.sequence_manager()->entity_map( type ).get_sequence_count();
#endif
}
#endif