sparse_dense_product.cpp File Reference

#include "BenchSparseUtil.h"

Macros
#define	SIZE   650000
#define	DENSITY   0.01
#define	REPEAT   1
#define	MINDENSITY   0.0004
#define	NBTRIES   10
#define	BENCH(X)

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

Macro Definition Documentation

BENCH

#define BENCH

(

X

)

Value:

  timer.reset();                          \
  for (int _j = 0; _j < NBTRIES; ++_j) {  \
    timer.start();                        \
    for (int _k = 0; _k < REPEAT; ++_k) { \
      X                                   \
    }                                     \
    timer.stop();                         \
  }

DENSITY

#define DENSITY   0.01

MINDENSITY

#define MINDENSITY   0.0004

NBTRIES

#define NBTRIES   10

REPEAT

#define REPEAT   1

SIZE

#define SIZE   650000

Function Documentation

main()

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

                                 {
  int rows = SIZE;
  int cols = SIZE;
  float density = DENSITY;
 
  EigenSparseMatrix sm1(rows, cols);
  DenseVector v1(cols), v2(cols);
  v1.setRandom();
 
  BenchTimer timer;
  for (float density = DENSITY; density >= MINDENSITY; density *= 0.5) {
    // fillMatrix(density, rows, cols, sm1);
    fillMatrix2(7, rows, cols, sm1);
 
// dense matrices
#ifdef DENSEMATRIX
    {
      std::cout << "Eigen Dense\t" << density * 100 << "%\n";
      DenseMatrix m1(rows, cols);
      eiToDense(sm1, m1);
 
      timer.reset();
      timer.start();
      for (int k = 0; k < REPEAT; ++k) v2 = m1 * v1;
      timer.stop();
      std::cout << "   a * v:\t" << timer.best() << "  " << double(REPEAT) / timer.best() << " * / sec " << endl;
 
      timer.reset();
      timer.start();
      for (int k = 0; k < REPEAT; ++k) v2 = m1.transpose() * v1;
      timer.stop();
      std::cout << "   a' * v:\t" << timer.best() << endl;
    }
#endif
 
    // eigen sparse matrices
    {
      std::cout << "Eigen sparse\t" << sm1.nonZeros() / float(sm1.rows() * sm1.cols()) * 100 << "%\n";
 
      BENCH(asm("#myc"); v2 = sm1 * v1; asm("#myd");)
      std::cout << "   a * v:\t" << timer.best() / REPEAT << "  " << double(REPEAT) / timer.best(REAL_TIMER)
                << " * / sec " << endl;
 
      BENCH({
        asm("#mya");
        v2 = sm1.transpose() * v1;
        asm("#myb");
      })
 
      std::cout << "   a' * v:\t" << timer.best() / REPEAT << endl;
    }
 
    //     {
    //       DynamicSparseMatrix<Scalar> m1(sm1);
    //       std::cout << "Eigen dyn-sparse\t" << m1.nonZeros()/float(m1.rows()*m1.cols())*100 << "%\n";
    //
    //       BENCH(for (int k=0; k<REPEAT; ++k) v2 = m1 * v1;)
    //       std::cout << "   a * v:\t" << timer.value() << endl;
    //
    //       BENCH(for (int k=0; k<REPEAT; ++k) v2 = m1.transpose() * v1;)
    //       std::cout << "   a' * v:\t" << timer.value() << endl;
    //     }
 
// GMM++
#ifndef NOGMM
    {
      std::cout << "GMM++ sparse\t" << density * 100 << "%\n";
      // GmmDynSparse  gmmT3(rows,cols);
      GmmSparse m1(rows, cols);
      eiToGmm(sm1, m1);
 
      std::vector<Scalar> gmmV1(cols), gmmV2(cols);
      Map<Matrix<Scalar, Dynamic, 1> >(&gmmV1[0], cols) = v1;
      Map<Matrix<Scalar, Dynamic, 1> >(&gmmV2[0], cols) = v2;
 
      BENCH(asm("#myx"); gmm::mult(m1, gmmV1, gmmV2); asm("#myy");)
      std::cout << "   a * v:\t" << timer.value() << endl;
 
      BENCH(gmm::mult(gmm::transposed(m1), gmmV1, gmmV2);)
      std::cout << "   a' * v:\t" << timer.value() << endl;
    }
#endif
 
#ifndef NOUBLAS
    {
      std::cout << "ublas sparse\t" << density * 100 << "%\n";
      UBlasSparse m1(rows, cols);
      eiToUblas(sm1, m1);
 
      boost::numeric::ublas::vector<Scalar> uv1, uv2;
      eiToUblasVec(v1, uv1);
      eiToUblasVec(v2, uv2);
 
      //       std::vector<Scalar> gmmV1(cols), gmmV2(cols);
      //       Map<Matrix<Scalar,Dynamic,1> >(&gmmV1[0], cols) = v1;
      //       Map<Matrix<Scalar,Dynamic,1> >(&gmmV2[0], cols) = v2;
 
      BENCH(uv2 = boost::numeric::ublas::prod(m1, uv1);)
      std::cout << "   a * v:\t" << timer.value() << endl;
 
      //       BENCH( boost::ublas::prod(gmm::transposed(m1), gmmV1, gmmV2); )
      //       std::cout << "   a' * v:\t" << timer.value() << endl;
    }
#endif
 
// MTL4
#ifndef NOMTL
    {
      std::cout << "MTL4\t" << density * 100 << "%\n";
      MtlSparse m1(rows, cols);
      eiToMtl(sm1, m1);
      mtl::dense_vector<Scalar> mtlV1(cols, 1.0);
      mtl::dense_vector<Scalar> mtlV2(cols, 1.0);
 
      timer.reset();
      timer.start();
      for (int k = 0; k < REPEAT; ++k) mtlV2 = m1 * mtlV1;
      timer.stop();
      std::cout << "   a * v:\t" << timer.value() << endl;
 
      timer.reset();
      timer.start();
      for (int k = 0; k < REPEAT; ++k) mtlV2 = trans(m1) * mtlV1;
      timer.stop();
      std::cout << "   a' * v:\t" << timer.value() << endl;
    }
#endif
 
    std::cout << "\n\n";
  }
 
  return 0;
}

References BENCH, cols, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), UniformPSDSelfTest::density, DENSITY, eiToDense(), eiToGmm(), eiToMtl(), eiToUblas(), eiToUblasVec(), fillMatrix2(), k, m1, MINDENSITY, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::nonZeros(), prod(), Eigen::REAL_TIMER, REPEAT, rows, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), SIZE, trans, Eigen::SparseMatrixBase< Derived >::transpose(), v1(), and v2().