adj_mem_time_test.cpp

Go to the documentation of this file.

/*This function profiles the performance of the AHF datastructure */
#include <iostream>
#include <cassert>
#include <ctime>
#include <vector>
#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include "moab/MeshTopoUtil.hpp"
#include "moab/HalfFacetRep.hpp"
#include "../TestUtil.hpp"
#include "moab/CpuTimer.hpp"

#ifdef MOAB_HAVE_MPI
#include "moab/ParallelComm.hpp"
#include "MBParallelConventions.h"
#include "moab/FileOptions.hpp"
#include "MBTagConventions.hpp"
#include "moab_mpi.h"
#endif

using namespace moab;

#ifdef MOAB_HAVE_MPI
std::string read_options;
#endif

int number_tests_successful = 0;
int number_tests_failed     = 0;

struct query_time
{
    double ds_construction;
    double vertex_to_edges_total;
    double vertex_to_edges_avg;
    double edge_to_edges_total;
    double edge_to_edges_avg;
    double vertex_to_faces_total;
    double vertex_to_faces_avg;
    double edge_to_faces_total;
    double edge_to_faces_avg;
    double face_to_faces_total;
    double face_to_faces_avg;
    double face_to_edges_total;
    double face_to_edges_avg;
    double vertex_to_cells_total;
    double vertex_to_cells_avg;
    double edge_to_cells_total;
    double edge_to_cells_avg;
    double face_to_cells_total;
    double face_to_cells_avg;
    double cell_to_cells_total;
    double cell_to_cells_avg;
    double cell_to_edges_total;
    double cell_to_edges_avg;
    double cell_to_faces_total;
    double cell_to_faces_avg;
};

struct mesh_mem
{
    unsigned long long total_storage[2];
    unsigned long long amortized_total_storage[2];
    unsigned long long entity_storage[2];
    unsigned long long amortized_entity_storage[2];
    unsigned long long adjacency_storage[2];
    unsigned long long amortized_adjacency_storage[2];
    unsigned long long tag_storage[2];
    unsigned long long amortized_tag_storage[2];
};

void handle_error_code( ErrorCode rv, int& number_failed, int& number_successful )
{
    if( rv == MB_SUCCESS )
    {
#ifdef MOAB_HAVE_MPI
        int rank = 0;
        MPI_Comm_rank( MPI_COMM_WORLD, &rank );
        if( rank == 0 ) std::cout << "Success";
#else
        std::cout << "Success";
#endif
        number_successful++;
    }
    else
    {
        std::cout << "Failure";
        number_failed++;
    }
}

ErrorCode adj_perf( const char* filename )
{
    ErrorCode error;
    Core moab;
    Interface* mbImpl = &moab;
    MeshTopoUtil mtu( mbImpl );

    struct query_time qtime;
    struct mesh_mem qmem;

#ifdef MOAB_HAVE_MPI
    int procs = 1;
    MPI_Comm_size( MPI_COMM_WORLD, &procs );

    if( procs > 1 )
    {
        read_options = "PARALLEL=READ_PART;PARTITION=PARALLEL_PARTITION;PARALLEL_RESOLVE_SHARED_ENTS";

        error = mbImpl->load_file( filename, 0, read_options.c_str() );CHECK_ERR( error );
    }
    else if( procs == 1 )
    {
#endif
        error = mbImpl->load_file( filename );CHECK_ERR( error );
#ifdef MOAB_HAVE_MPI
    }
#endif

    // Storage Costs before any call to adjacencies
    unsigned long long sTotS, sTAS, sES, sAES, sAS, sAAS, sTS, sATS;
    sTotS = sTAS = sES = sAES = sAS = sAAS = sTS = sATS = 0;
    mbImpl->estimated_memory_use( NULL, 0, &sTotS, &sTAS, &sES, &sAES, &sAS, &sAAS, NULL, 0, &sTS, &sATS );

    qmem.total_storage[0]               = sTotS;
    qmem.amortized_total_storage[0]     = sTAS;
    qmem.entity_storage[0]              = sES;
    qmem.amortized_entity_storage[0]    = sAES;
    qmem.adjacency_storage[0]           = sAS;
    qmem.amortized_adjacency_storage[0] = sAAS;
    qmem.tag_storage[0]                 = sTS;
    qmem.amortized_tag_storage[0]       = sATS;

    // Create ranges for handles of explicit elements of the mixed mesh
    Range verts, edges, faces, cells;
    error = mbImpl->get_entities_by_dimension( 0, 0, verts );
    error = mbImpl->get_entities_by_dimension( 0, 1, edges );
    error = mbImpl->get_entities_by_dimension( 0, 2, faces );
    error = mbImpl->get_entities_by_dimension( 0, 3, cells );

    int nverts = verts.size();
    int nedges = edges.size();
    int nfaces = faces.size();
    int ncells = cells.size();

    std::cout << "MESH SIZE :: "
              << "NV = " << nverts << ", NE = " << nedges << ", NF = " << nfaces << ", NC = " << ncells << std::endl;

    CpuTimer* mt = new CpuTimer;
    double time_start, time_avg, time_total;

    // Perform queries
    std::vector< EntityHandle > adjents;
    Range ngbents;

    // This call should create all the necessary ahf maps or adjacency lists
    time_start            = mt->time_elapsed();
    error                 = mbImpl->get_adjacencies( &*verts.begin(), 1, 1, false, adjents );
    time_total            = mt->time_elapsed() - time_start;
    qtime.ds_construction = time_total;

    // 1D Queries

    std::cout << "1D QUERIES Start" << std::endl;

    // IQ1: For every vertex, obtain incident edges
    time_start = mt->time_elapsed();
    for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)verts.size();

    qtime.vertex_to_edges_total = time_total;
    qtime.vertex_to_edges_avg   = time_avg;

    // NQ1:  For every edge, obtain neighbor edges
#ifdef MOAB_HAVE_AHF
    time_start = mt->time_elapsed();
    for( Range::iterator i = edges.begin(); i != edges.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)edges.size();
#else
    error = mtu.get_bridge_adjacencies( *edges.begin(), 0, 1, ngbents );
    time_start = mt->time_elapsed();
    for( Range::iterator i = edges.begin(); i != edges.end(); ++i )
    {
        ngbents.clear();
        error = mtu.get_bridge_adjacencies( *i, 0, 1, ngbents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg = time_total / (double)edges.size();
#endif

    qtime.edge_to_edges_total = time_total;
    qtime.edge_to_edges_avg   = time_avg;

    std::cout << "1D QUERIES End" << std::endl;

    // 2D Queries

    std::cout << "2D QUERIES Start" << std::endl;

    // IQ21: For every vertex, obtain incident faces
    time_start = mt->time_elapsed();
    for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)verts.size();

    qtime.vertex_to_faces_total = time_total;
    qtime.vertex_to_faces_avg   = time_avg;

    // IQ22: For every edge, obtain incident faces
    time_start = mt->time_elapsed();
    for( Range::iterator i = edges.begin(); i != edges.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)edges.size();

    qtime.edge_to_faces_total = time_total;
    qtime.edge_to_faces_avg   = time_avg;

    // NQ2: For every face, obtain neighbor faces
#ifdef MOAB_HAVE_AHF
    time_start = mt->time_elapsed();
    for( Range::iterator i = faces.begin(); i != faces.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)faces.size();
#else
    error = mtu.get_bridge_adjacencies( *faces.begin(), 1, 2, ngbents );
    time_start = mt->time_elapsed();
    for( Range::iterator i = faces.begin(); i != faces.end(); ++i )
    {
        ngbents.clear();
        error = mtu.get_bridge_adjacencies( *i, 1, 2, ngbents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg = time_total / (double)faces.size();
#endif

    qtime.face_to_faces_total = time_total;
    qtime.face_to_faces_avg   = time_avg;

    // DQ2: For every face, obtain its edges
    time_start = mt->time_elapsed();
    for( Range::iterator i = faces.begin(); i != faces.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)faces.size();

    qtime.face_to_edges_total = time_total;
    qtime.face_to_edges_avg   = time_avg;

    std::cout << "2D QUERIES End" << std::endl;

    // 3D Queries

    std::cout << "3D QUERIES Start " << std::endl;

    // IQ31: For every vertex, obtain incident cells
    time_start = mt->time_elapsed();
    for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)verts.size();

    qtime.vertex_to_cells_total = time_total;
    qtime.vertex_to_cells_avg   = time_avg;

    // IQ 32: For every edge, obtain incident cells
    time_start = mt->time_elapsed();
    for( Range::iterator i = edges.begin(); i != edges.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)edges.size();

    qtime.edge_to_cells_total = time_total;
    qtime.edge_to_cells_avg   = time_avg;

    // IQ32: For every face, obtain incident cells
    time_start = mt->time_elapsed();
    for( Range::iterator i = faces.begin(); i != faces.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)faces.size();

    qtime.face_to_cells_total = time_total;
    qtime.face_to_cells_avg   = time_avg;

    // NQ3: For every cell, obtain neighbor cells
#ifdef MOAB_HAVE_AHF
    time_start = mt->time_elapsed();
    for( Range::iterator i = cells.begin(); i != cells.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 3, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)cells.size();
#else
    error = mtu.get_bridge_adjacencies( *cells.begin(), 2, 3, ngbents );
    time_start = mt->time_elapsed();
    for( Range::iterator i = cells.begin(); i != cells.end(); ++i )
    {
        ngbents.clear();
        error = mtu.get_bridge_adjacencies( *i, 2, 3, ngbents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg = time_total / (double)cells.size();
#endif

    qtime.cell_to_cells_total = time_total;
    qtime.cell_to_cells_avg   = time_avg;

    // DQ31: For every cell, obtain its edges
    time_start = mt->time_elapsed();
    for( Range::iterator i = cells.begin(); i != cells.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 1, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)cells.size();

    qtime.cell_to_edges_total = time_total;
    qtime.cell_to_edges_avg   = time_avg;

    // DQ32: For every cell, obtain its faces
    time_start = mt->time_elapsed();
    for( Range::iterator i = cells.begin(); i != cells.end(); ++i )
    {
        adjents.clear();
        error = mbImpl->get_adjacencies( &*i, 1, 2, false, adjents );
    }
    time_total = mt->time_elapsed() - time_start;
    time_avg   = time_total / (double)cells.size();

    qtime.cell_to_faces_total = time_total;
    qtime.cell_to_faces_avg   = time_avg;

    std::cout << "3D QUERIES End" << std::endl;

    // Storage Costs after calling ahf deinitialize
    unsigned long long eTotS, eTAS, eES, eAES, eAS, eAAS, eTS, eATS;
    eTotS = eTAS = eES = eAES = eAS = eAAS = eTS = eATS = 0;
    mbImpl->estimated_memory_use( NULL, 0, &eTotS, &eTAS, &eES, &eAES, &eAS, &eAAS, NULL, 0, &eTS, &eATS );

    qmem.total_storage[1]               = eTotS;
    qmem.amortized_total_storage[1]     = eTAS;
    qmem.entity_storage[1]              = eES;
    qmem.amortized_entity_storage[1]    = eAES;
    qmem.adjacency_storage[1]           = eAS;
    qmem.amortized_adjacency_storage[1] = eAAS;
    qmem.tag_storage[1]                 = eTS;
    qmem.amortized_tag_storage[1]       = eATS;

    // Print times
    std::cout << std::endl;
    std::cout << " Data Structure Construction Time = " << qtime.ds_construction << " Secs" << std::endl;
    std::cout << std::endl;
    std::cout << "Query times in Seconds" << std::endl;
#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Vertex -> Edges :: MOAB_AHF: Average time =  " << qtime.vertex_to_edges_avg;
    std::cout << ", Total time = " << qtime.vertex_to_edges_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Vertex -> Edges :: MOAB: Average time =  " << qtime.vertex_to_edges_avg;
    std::cout << ", Total time = " << qtime.vertex_to_edges_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Edge -> Edges :: MOAB_AHF: Average time = " << qtime.edge_to_edges_avg;
    std::cout << ", Total time = " << qtime.edge_to_edges_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Edge -> Edges :: MOAB: Average time = " << qtime.edge_to_edges_avg;
    std::cout << ", Total time = " << qtime.edge_to_edges_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Vertex -> Faces :: MOAB_AHF: Average time =  " << qtime.vertex_to_faces_avg;
    std::cout << ", Total time = " << qtime.vertex_to_faces_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Vertex -> Faces :: MOAB: Average time =  " << qtime.vertex_to_faces_avg;
    std::cout << ", Total time = " << qtime.vertex_to_faces_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Edge -> Faces :: MOAB_AHF: Average time =  " << qtime.edge_to_faces_avg;
    std::cout << ", Total time = " << qtime.edge_to_faces_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Edge -> Faces :: MOAB: Average time =  " << qtime.edge_to_faces_avg;
    std::cout << ", Total time = " << qtime.edge_to_faces_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Face -> Faces :: MOAB_AHF: Average time = " << qtime.face_to_faces_avg;
    std::cout << ", Total time = " << qtime.face_to_faces_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Face -> Faces :: MOAB: Average time = " << qtime.face_to_faces_avg;
    std::cout << ", Total time = " << qtime.face_to_faces_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Face -> Edges :: MOAB_AHF: Average time =  " << qtime.face_to_edges_avg;
    std::cout << ", Total time = " << qtime.face_to_edges_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Face -> Edges :: MOAB: Average time =  " << qtime.face_to_edges_avg;
    std::cout << ", Total time = " << qtime.face_to_edges_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Vertex -> Cells :: MOAB_AHF: Average time =  " << qtime.vertex_to_cells_avg;
    std::cout << ", Total time = " << qtime.vertex_to_cells_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Vertex -> Cells :: MOAB: Average time =  " << qtime.vertex_to_cells_avg;
    std::cout << ", Total time = " << qtime.vertex_to_cells_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Edge -> Cells :: MOAB_AHF: Average time =  " << qtime.edge_to_cells_avg;
    std::cout << ", Total time = " << qtime.edge_to_cells_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Edge -> Cells :: MOAB: Average time =  " << qtime.edge_to_cells_avg;
    std::cout << ", Total time = " << qtime.edge_to_cells_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Face -> Cells :: MOAB_AHF: Average time =  " << qtime.face_to_cells_avg;
    std::cout << ", Total time = " << qtime.face_to_cells_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Face -> Cells :: MOAB: Average time =  " << qtime.face_to_cells_avg;
    std::cout << ", Total time = " << qtime.face_to_cells_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Cell -> Cells :: MOAB_AHF: Average time =  " << qtime.cell_to_cells_avg;
    std::cout << ", Total time = " << qtime.cell_to_cells_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Cell -> Cells :: MOAB: Average time =  " << qtime.cell_to_cells_avg;
    std::cout << ", Total time = " << qtime.cell_to_cells_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Cell -> Edges :: MOAB_AHF: Average time =  " << qtime.cell_to_edges_avg;
    std::cout << ", Total time = " << qtime.cell_to_edges_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Cell -> Edges :: MOAB: Average time =  " << qtime.cell_to_edges_avg;
    std::cout << ", Total time = " << qtime.cell_to_edges_total << std::endl;
    std::cout << std::endl;
#endif

#ifdef MOAB_HAVE_AHF
    std::cout << "QUERY: Cell -> Faces :: MOAB_AHF: Average time =  " << qtime.cell_to_faces_avg;
    std::cout << ", Total time = " << qtime.cell_to_faces_total << std::endl;
    std::cout << std::endl;
#else
    std::cout << "QUERY: Cell -> Faces :: MOAB: Average time =  " << qtime.cell_to_faces_avg;
    std::cout << ", Total time = " << qtime.cell_to_faces_total << std::endl;
    std::cout << std::endl;
#endif

    // Print Storage
    std::cout << std::endl;
    for( int i = 0; i < 2; i++ )
    {
        if( i == 0 )
            std::cout << "STORAGE BEFORE CALLING ADJACENCIES" << std::endl;
        else
            std::cout << "STORAGE AFTER CALLING ADJACENCIES" << std::endl;

        std::cout << "Total storage = " << qmem.total_storage[i] << std::endl;
        std::cout << "Total amortized storage = " << qmem.amortized_total_storage[i] << std::endl;
        std::cout << std::endl;

        std::cout << "Entity storage = " << qmem.entity_storage[i] << std::endl;
        std::cout << "Amortized entity storage = " << qmem.amortized_entity_storage[i] << std::endl;
        std::cout << std::endl;

        std::cout << "Adjacency storage = " << qmem.adjacency_storage[i] << std::endl;
        std::cout << "Amortized adjacency storage = " << qmem.amortized_adjacency_storage[i] << std::endl;
        std::cout << std::endl;

        std::cout << "Tag storage = " << qmem.tag_storage[i] << std::endl;
        std::cout << "Amortized tag storage = " << qmem.amortized_tag_storage[i] << std::endl;
        std::cout << std::endl;
    }

    double total_time = qtime.vertex_to_edges_total + qtime.edge_to_edges_total + qtime.vertex_to_faces_total +
                        qtime.edge_to_faces_total + qtime.face_to_faces_total + qtime.face_to_edges_total +
                        qtime.vertex_to_cells_total + qtime.edge_to_cells_total + qtime.face_to_cells_total +
                        qtime.cell_to_cells_total + qtime.cell_to_edges_total + qtime.cell_to_faces_total;

    // Print values in a line to aid data copying later
    std::cout << qtime.ds_construction << "  " << total_time << "  " << qmem.entity_storage[1] << "  "
              << qmem.adjacency_storage[1] << "  " << qtime.vertex_to_edges_avg << "  " << qtime.edge_to_edges_avg
              << "  " << qtime.vertex_to_faces_avg << "  " << qtime.edge_to_faces_avg << "  " << qtime.face_to_faces_avg
              << "  " << qtime.face_to_edges_avg << "  " << qtime.vertex_to_cells_avg << "  " << qtime.edge_to_cells_avg
              << "  " << qtime.face_to_cells_avg << "  " << qtime.cell_to_cells_avg << "  " << qtime.cell_to_edges_avg
              << "  " << qtime.cell_to_faces_avg << std::endl;

    delete mt;
    return MB_SUCCESS;
}

int main( int argc, char* argv[] )
{

#ifdef MOAB_HAVE_MPI
    MPI_Init( &argc, &argv );

    int nprocs, rank;
    MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
#endif

    std::string filename;
#ifdef MOAB_HAVE_HDF5
    filename = TestDir + "unittest/32hex_ef.h5m";
#else
    filename = TestDir + "unittest/hexes_mixed.vtk";
#endif

    if( argc == 1 )
    {
#ifdef MOAB_HAVE_MPI
        if( rank == 0 ) std::cout << "Using default input file:" << filename << std::endl;
#else
        std::cout << "Using default input file:" << filename << std::endl;
#endif
    }

    else if( argc == 2 )
        filename = argv[1];
    else
    {
        std::cerr << "Usage: " << argv[0] << " [filename]" << std::endl;
        return 1;
    }

    ErrorCode result;

#ifdef MOAB_HAVE_MPI
    if( rank == 0 ) std::cout << " para_adj_perf: ";
#else
    std::cout << "adj_perf:";
#endif

    result = adj_perf( filename.c_str() );
    handle_error_code( result, number_tests_failed, number_tests_successful );
    std::cout << "\n";

#ifdef MOAB_HAVE_MPI
    MPI_Finalize();
#endif

    return number_tests_failed;
}