test/test_matrix_memory.cpp

Go to the documentation of this file.

//
// C++ Implementation: test_romberg
//
// Description: unit tests for CRS matrix memory consumption
//
//
// Author: Roman Geus <geus@maxwell>, (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//

#include <cmath>
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <unistd.h>
#include <limits>
#include <tut.h>
#include "Epetra_Comm.h"
#include "Epetra_CrsMatrix.h"
#include "Epetra_Map.h"
#include "Epetra_Vector.h"
#include "Trilinos_Util_CrsMatrixGallery.h"
#include "myrlog.h"
#include "balancedmtxreader.h"
#include "mtxreader.h"

#undef RLOG_TIME_TSC
#include "rlog/RLogTime.h"

namespace tut {
Epetra_Comm& get_comm_world();
}

namespace {

struct testdata {
    testdata()
            : comm(tut::get_comm_world()) {}
    Epetra_Comm& comm;
};

typedef tut::test_group<testdata> testgroup;
typedef testgroup::object testobject;
testgroup group("matrix_memory");


template<>
template<>
void testobject::test<5>() {
    rInfo("Reading test matrices...");
    string filename;
    BaseMtxReader *reader = 0;

    // read matrix Y_transp
    filename = "test/ml_laplace/H.mtx";
    if (access(filename.c_str(), R_OK)) {
        rError("Unable to access H matrix file.");
        exit(1);
    }
    reader = new BalancedMtxReader(filename, comm);

    size_t before, after;
    before = get_mem_footprint();

    Epetra_CrsMatrix* A = reader->read();

    after = get_mem_footprint();
    size_t measured = after - before;

    // estimate size
    size_t estimated = get_matrix_mem_footprint(*A);

    rInfo("estimated = %s, measured = %s",
          rlog::bytes2str(estimated).c_str(),
          rlog::bytes2str(measured).c_str());

    // allow +/- 30% error in estimation
    ensure(0.7 * estimated < measured && measured < 1.3 * estimated);

    delete reader;
    delete A;
}

template<>
template<>
void testobject::test<10>() {
    const int N = 1000000;

    Trilinos_Util::CrsMatrixGallery gallery("laplace_2d", comm);
    gallery.Set("problem_size", N);
    gallery.Set("map_type", "linear");
    gallery.Set("exact_solution", "random");

    size_t before, after;
    before = get_mem_footprint();
    // create the matrix (vectors should not be created)
    Epetra_CrsMatrix* A = gallery.GetMatrix();
    after = get_mem_footprint();
    size_t measured = after - before;

    // estimate size
    size_t estimated = get_matrix_mem_footprint(*A);
    rInfo("estimated = %s, measured = %s",
          rlog::bytes2str(estimated).c_str(),
          rlog::bytes2str(measured).c_str());

    // allow +/- 30% error in estimation
    ensure(0.7 * estimated < measured && measured < 1.3 * estimated);
    // Matrix will be deleted by gallery object
}

template<>
template<>
void testobject::test<1>() {
    int nx = 1000;
    int ny = 1000;
    int numPoint = nx*ny;

    size_t before, after;
    before = get_mem_footprint();
    
    Epetra_Map unifMap(numPoint, 0, comm);
    Epetra_CrsMatrix A(Copy, unifMap, 5, false);

    for (int iy = 0; iy < ny; ++iy) {
        for (int ix = 0; ix < nx; ++ix) {
            int point = iy*nx + ix;
            if (unifMap.MyGID(point) == false)
                continue;
            int col = point;
            double val = 4.0;
            assert(A.InsertGlobalValues(point, 1, &val, &col) >= 0);
            if (ix > 0) {
                col = point-1;
                val = -1.0;
                assert(A.InsertGlobalValues(point, 1, &val, &col) >= 0);
            }
            if (ix < nx-1) {
                col = point+1;
                val = -1.0;
                assert(A.InsertGlobalValues(point, 1, &val, &col) >= 0);
            }
            if (iy > 0) {
                col = point-nx;
                val = -1.0;
                assert(A.InsertGlobalValues(point, 1, &val, &col) >= 0);
            }
            if (iy < ny-1) {
                col = point+nx;
                val = -1.0;
                assert(A.InsertGlobalValues(point, 1, &val, &col) >= 0);
            }
        }
    }
    assert(A.FillComplete() >= 0);
    assert(A.OptimizeStorage() >= 0);
    
    after = get_mem_footprint();
    size_t measured = after - before;

    // estimate size
    size_t estimated = get_matrix_mem_footprint(A);
    rInfo("estimated = %s, measured = %s",
          rlog::bytes2str(estimated).c_str(),
          rlog::bytes2str(measured).c_str());

    // allow +/- 30% error in estimation
    ensure(0.7 * estimated < measured && measured < 1.3 * estimated);
}

};

---